kennel 0.1.8 → 0.2.0

package/node_modules/@raggle-ai/local/dist/adapters/github.js

@@ -0,0 +1,301 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.githubRepositoryFromUrl = githubRepositoryFromUrl;
+exports.githubCliPath = githubCliPath;
+exports.githubViewerLogin = githubViewerLogin;
+exports.githubAuthenticatedAccounts = githubAuthenticatedAccounts;
+exports.githubSearchUsers = githubSearchUsers;
+exports.githubDiscoverOwnerRepositories = githubDiscoverOwnerRepositories;
+exports.githubPullRequestLookupErrorMessage = githubPullRequestLookupErrorMessage;
+exports.fallbackGitHubViewerLogin = fallbackGitHubViewerLogin;
+exports.githubPullRequestsByAuthor = githubPullRequestsByAuthor;
+exports.githubSearchPullRequests = githubSearchPullRequests;
+exports.githubSearchIssues = githubSearchIssues;
+exports.githubSearchPullRequestsAndIssues = githubSearchPullRequestsAndIssues;
+exports.githubPullRequestForCurrentBranch = githubPullRequestForCurrentBranch;
+exports.githubPullRequestsBrowserUrl = githubPullRequestsBrowserUrl;
+exports.githubSearchBrowserUrl = githubSearchBrowserUrl;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const native_bridge_1 = require("../native-bridge");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function githubRepositoryFromUrl(input) {
+    if (!input)
+        return undefined;
+    const browserUrl = (0, native_bridge_1.remoteToBrowserUrl)(input);
+    if (!browserUrl)
+        return undefined;
+    const parsedUrl = new URL(browserUrl);
+    if (parsedUrl.hostname !== "github.com")
+        return undefined;
+    const segments = parsedUrl.pathname.split("/").filter(Boolean);
+    if (segments.length < 2)
+        return undefined;
+    return {
+        owner: segments[0],
+        repo: segments[1],
+        browserUrl: `https://github.com/${segments[0]}/${segments[1]}`,
+    };
+}
+async function ghOutput(args, options = {}) {
+    const { stdout } = await execFileAsync(githubCliPath(), args, {
+        cwd: options.cwd,
+        env: {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: "0",
+        },
+        maxBuffer: 1024 * 1024 * 4,
+    });
+    return stdout.trim();
+}
+function executableSearchPaths() {
+    return [
+        ...(process.env.PATH || "").split(node_path_1.default.delimiter).filter(Boolean),
+        node_path_1.default.join(node_os_1.default.homedir(), ".local", "bin"),
+        node_path_1.default.join(node_os_1.default.homedir(), ".bun", "bin"),
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+    ];
+}
+function githubCliPath() {
+    for (const directory of executableSearchPaths()) {
+        const candidate = node_path_1.default.join(directory, "gh");
+        try {
+            (0, node_fs_1.accessSync)(candidate, node_fs_1.constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Try next location.
+        }
+    }
+    return "gh";
+}
+async function githubViewerLogin() {
+    return ghOutput(["api", "user", "--template", "{{.login}}"]);
+}
+async function githubAuthenticatedAccounts() {
+    const output = await ghOutput(["auth", "status"]);
+    const accountMatches = [
+        ...output.matchAll(/Logged in to github\.com account ([^\s]+) \(keyring\)([\s\S]*?)(?=\n\n|\n  \u2713|\n  X|$)/g),
+    ];
+    return accountMatches.map((match) => {
+        const username = match[1];
+        return {
+            username,
+            active: match[2].includes("Active account: true"),
+            avatarUrl: `https://github.com/${encodeURIComponent(username)}.png`,
+        };
+    });
+}
+async function githubSearchUsers(query, limit = 20) {
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery)
+        return [];
+    const output = await ghOutput([
+        "api",
+        "--method",
+        "GET",
+        "search/users",
+        "-f",
+        `q=${trimmedQuery} in:login`,
+        "-f",
+        `per_page=${limit}`,
+    ]);
+    const results = JSON.parse(output);
+    return (results.items ?? [])
+        .filter((item) => item.login)
+        .map((item) => {
+        const username = item.login;
+        return {
+            username,
+            kind: item.type === "Organization" ? "Organization" : "User",
+            browserUrl: item.html_url ?? `https://github.com/${encodeURIComponent(username)}`,
+            avatarUrl: item.avatar_url,
+        };
+    });
+}
+async function githubDiscoverOwnerRepositories(owner, options = {}) {
+    const trimmedOwner = owner.trim();
+    if (!/^[a-z\d](?:[a-z\d-]{0,37}[a-z\d])?$/i.test(trimmedOwner))
+        throw new Error("Invalid GitHub owner");
+    const page = options.page ?? 1;
+    const limit = 30;
+    if (!Number.isInteger(page) || page < 1 || page > 34)
+        throw new Error("Invalid GitHub result page");
+    const words = options.query?.trim().match(/[\p{L}\p{N}_.-]+/gu) ?? [];
+    const query = [`user:${trimmedOwner}`, "fork:true", ...(words.length ? [words.join(" "), "in:name"] : [])].join(" ");
+    const output = await ghOutput([
+        "api",
+        "--method",
+        "GET",
+        "search/repositories",
+        "-f",
+        `q=${query}`,
+        "-f",
+        "sort=updated",
+        "-f",
+        "order=desc",
+        "-f",
+        `per_page=${limit}`,
+        "-f",
+        `page=${page}`,
+    ]);
+    const results = JSON.parse(output);
+    const items = (results.items ?? [])
+        .filter((item) => item.name && item.full_name && item.html_url)
+        .map((item) => ({
+        name: item.name,
+        fullName: item.full_name,
+        browserUrl: item.html_url,
+        ownerAvatarUrl: item.owner?.avatar_url,
+        description: item.description ?? undefined,
+        updatedAt: item.updated_at,
+        isPrivate: Boolean(item.private),
+        isFork: Boolean(item.fork),
+    }));
+    return {
+        items,
+        nextPage: page * limit < Math.min(results.total_count, 1000) ? page + 1 : undefined,
+        incomplete: Boolean(results.incomplete_results) || results.total_count > 1000,
+    };
+}
+function githubPullRequestLookupErrorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("spawn gh ENOENT")) {
+        return "GitHub CLI is not installed, so the action is using local Git config for the username when available.";
+    }
+    return "GitHub CLI is not authenticated, so the action is using local Git config for the username when available.";
+}
+async function gitConfigValue(key, worktree) {
+    try {
+        const { stdout } = await execFileAsync("git", ["config", "--get", key], {
+            cwd: worktree,
+            env: {
+                ...process.env,
+                GIT_TERMINAL_PROMPT: "0",
+            },
+            maxBuffer: 1024 * 1024 * 4,
+        });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function gitCurrentBranch(worktree) {
+    try {
+        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], {
+            cwd: worktree,
+            env: {
+                ...process.env,
+                GIT_TERMINAL_PROMPT: "0",
+            },
+            maxBuffer: 1024 * 1024 * 4,
+        });
+        return stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fallbackGitHubViewerLogin(worktree) {
+    return ((await gitConfigValue("github.user", worktree)) ??
+        (await gitConfigValue("github.username", worktree)) ??
+        (await gitConfigValue("user.name", worktree)));
+}
+async function githubPullRequestsByAuthor(repository, author) {
+    const output = await ghOutput([
+        "pr",
+        "list",
+        "--repo",
+        `${repository.owner}/${repository.repo}`,
+        "--author",
+        author,
+        "--state",
+        "open",
+        "--json",
+        "number,title,url",
+    ]);
+    return JSON.parse(output);
+}
+function githubSearchArgs(command, repository, query, limit) {
+    const args = [
+        command,
+        "list",
+        "--repo",
+        `${repository.owner}/${repository.repo}`,
+        "--state",
+        "open",
+        "--limit",
+        String(limit),
+        "--json",
+        command === "pr" ? "number,title,url,author,updatedAt,state,isDraft" : "number,title,url,author,updatedAt,state",
+    ];
+    const trimmedQuery = query.trim();
+    if (trimmedQuery) {
+        args.push("--search", trimmedQuery);
+    }
+    return args;
+}
+async function githubSearchPullRequests(repository, query = "", limit = 30) {
+    const output = await ghOutput(githubSearchArgs("pr", repository, query, limit));
+    const pullRequests = JSON.parse(output);
+    return pullRequests.map((pullRequest) => ({
+        ...pullRequest,
+        kind: "pull-request",
+    }));
+}
+async function githubSearchIssues(repository, query = "", limit = 30) {
+    const output = await ghOutput(githubSearchArgs("issue", repository, query, limit));
+    const issues = JSON.parse(output);
+    return issues.map((issue) => ({
+        ...issue,
+        kind: "issue",
+    }));
+}
+async function githubSearchPullRequestsAndIssues(repository, query = "", limit = 30) {
+    const [pullRequests, issues] = await Promise.all([
+        githubSearchPullRequests(repository, query, limit),
+        githubSearchIssues(repository, query, limit),
+    ]);
+    return [...pullRequests, ...issues].sort((first, second) => {
+        const firstTime = first.updatedAt ? Date.parse(first.updatedAt) : 0;
+        const secondTime = second.updatedAt ? Date.parse(second.updatedAt) : 0;
+        return secondTime - firstTime;
+    });
+}
+async function githubPullRequestForCurrentBranch(repository, worktree) {
+    const branch = await gitCurrentBranch(worktree);
+    if (!branch)
+        return undefined;
+    try {
+        const output = await ghOutput(["pr", "view", branch, "--repo", `${repository.owner}/${repository.repo}`, "--json", "number,title,url"], { cwd: worktree });
+        return JSON.parse(output);
+    }
+    catch {
+        return undefined;
+    }
+}
+function githubPullRequestsBrowserUrl(repository, authors) {
+    const authorList = Array.isArray(authors) ? authors : authors ? [authors] : [];
+    if (!authorList.length)
+        return `${repository.browserUrl}/pulls`;
+    const authorQuery = authorList.map((author) => `author:${author}`).join(" ");
+    const query = encodeURIComponent(`is:pr is:open ${authorQuery}`);
+    return `${repository.browserUrl}/pulls?q=${query}`;
+}
+function githubSearchBrowserUrl(repository, query, kind = "all") {
+    const qualifiers = ["is:open"];
+    if (kind === "pull-request")
+        qualifiers.push("is:pr");
+    if (kind === "issue")
+        qualifiers.push("is:issue");
+    const search = [...qualifiers, query.trim()].filter(Boolean).join(" ");
+    return `${repository.browserUrl}/issues?q=${encodeURIComponent(search)}`;
+}

package/node_modules/@raggle-ai/local/dist/adapters/import.d.ts

@@ -0,0 +1,86 @@
+import { type LinkedOrganisationConfig, type LinkedRepositoryConfig } from "../core/project-schema";
+import { type ImportedRepositorySubpath } from "../core/project-subpaths";
+export type { ImportedRepositorySubpath } from "../core/project-subpaths";
+export { normalizeFolders, normalizeTags, normalizeFolderDepth } from "../native-bridge";
+export type ImportedRepositoryRow = {
+    url: string;
+    name?: unknown;
+    description?: unknown;
+    [key: string]: unknown;
+    tags?: unknown;
+    subpaths?: unknown;
+    allSubpath?: unknown;
+    collapseSubpaths?: unknown;
+    allTopLevelFolders?: unknown;
+    folderDepth?: unknown;
+    folders?: unknown;
+    clonePathTemplate?: unknown;
+    removePathFromName?: unknown;
+    searchPriority?: unknown;
+};
+export type ImportedRepository = {
+    remoteUrl: string;
+    repository: string;
+    name?: string;
+    description?: string;
+    hasCustomName: boolean;
+    tags: string[];
+    subpaths: ImportedRepositorySubpath[];
+    allSubpath: boolean;
+    collapseSubpaths: boolean;
+    allTopLevelFolders: boolean;
+    folderDepth: number;
+    folders: string[];
+    clonePathTemplate?: string;
+    plugins: string[];
+    removePathFromName: boolean;
+    searchPriority: number;
+    linkedRepositories: LinkedRepositoryConfig[];
+    linkedOrganisations: LinkedOrganisationConfig[];
+};
+export declare function normalizeClonePathTemplate(input: unknown): string | undefined;
+export declare function normalizePlugins(input: unknown, baseDirectory: string): string[];
+export declare function readImportedRepositoryRows(filePath: string): ImportedRepositoryRow[];
+export declare function readImportedRepositoryPlugins(filePath: string): string[];
+export declare function writeImportedRepositoryRows(filePath: string, rows: ImportedRepositoryRow[]): void;
+export declare function loadImportedRepositories(filePath: string): {
+    remoteUrl: string;
+    repository: string;
+    name: string | undefined;
+    description: string | undefined;
+    hasCustomName: boolean;
+    tags: string[];
+    subpaths: ImportedRepositorySubpath[];
+    allSubpath: boolean;
+    collapseSubpaths: boolean;
+    allTopLevelFolders: boolean;
+    folderDepth: number;
+    folders: string[];
+    clonePathTemplate: string | undefined;
+    plugins: string[];
+    removePathFromName: boolean;
+    searchPriority: number;
+    linkedRepositories: never[];
+    linkedOrganisations: never[];
+}[];
+export declare function loadImportedRepositoriesFromRows(rows: unknown[], plugins?: string[]): {
+    remoteUrl: string;
+    repository: string;
+    name: string | undefined;
+    description: string | undefined;
+    hasCustomName: boolean;
+    tags: string[];
+    subpaths: ImportedRepositorySubpath[];
+    allSubpath: boolean;
+    collapseSubpaths: boolean;
+    allTopLevelFolders: boolean;
+    folderDepth: number;
+    folders: string[];
+    clonePathTemplate: string | undefined;
+    plugins: string[];
+    removePathFromName: boolean;
+    searchPriority: number;
+    linkedRepositories: never[];
+    linkedOrganisations: never[];
+}[];
+export declare function loadRepositorySubpaths(worktree: string, subpaths: ImportedRepositorySubpath[]): string[];

package/node_modules/@raggle-ai/local/dist/adapters/import.js

@@ -0,0 +1,239 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeFolderDepth = exports.normalizeTags = exports.normalizeFolders = void 0;
+exports.normalizeClonePathTemplate = normalizeClonePathTemplate;
+exports.normalizePlugins = normalizePlugins;
+exports.readImportedRepositoryRows = readImportedRepositoryRows;
+exports.readImportedRepositoryPlugins = readImportedRepositoryPlugins;
+exports.writeImportedRepositoryRows = writeImportedRepositoryRows;
+exports.loadImportedRepositories = loadImportedRepositories;
+exports.loadImportedRepositoriesFromRows = loadImportedRepositoriesFromRows;
+exports.loadRepositorySubpaths = loadRepositorySubpaths;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const git_repository_1 = require("./git-repository");
+const native_bridge_1 = require("../native-bridge");
+const project_schema_1 = require("../core/project-schema");
+const project_subpaths_1 = require("../core/project-subpaths");
+var native_bridge_2 = require("../native-bridge");
+Object.defineProperty(exports, "normalizeFolders", { enumerable: true, get: function () { return native_bridge_2.normalizeFolders; } });
+Object.defineProperty(exports, "normalizeTags", { enumerable: true, get: function () { return native_bridge_2.normalizeTags; } });
+Object.defineProperty(exports, "normalizeFolderDepth", { enumerable: true, get: function () { return native_bridge_2.normalizeFolderDepth; } });
+function normalizeClonePathTemplate(input) {
+    if (typeof input !== "string")
+        return undefined;
+    const value = input.trim();
+    if (!value)
+        return undefined;
+    if (node_path_1.default.isAbsolute(value))
+        return value;
+    const normalized = value
+        .replace(/^\/+|\/+$/g, "")
+        .split("/")
+        .filter(Boolean)
+        .join("/");
+    return normalized || undefined;
+}
+function normalizePlugins(input, baseDirectory) {
+    const plugins = new Set();
+    if (!Array.isArray(input))
+        return [];
+    for (const item of input) {
+        if (typeof item !== "string")
+            continue;
+        const plugin = item.trim();
+        if (!plugin)
+            continue;
+        if (plugin === "~" || plugin.startsWith(`~${node_path_1.default.sep}`)) {
+            plugins.add(expandHomePath(plugin));
+            continue;
+        }
+        if (plugin.startsWith(".") || node_path_1.default.isAbsolute(plugin)) {
+            plugins.add(node_path_1.default.resolve(baseDirectory, plugin));
+            continue;
+        }
+        plugins.add(plugin);
+    }
+    return [...plugins];
+}
+function expandHomePath(input) {
+    if (input === "~")
+        return node_os_1.default.homedir();
+    if (input.startsWith(`~${node_path_1.default.sep}`))
+        return node_path_1.default.join(node_os_1.default.homedir(), input.slice(2));
+    return input;
+}
+function stripJsonComments(input) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const current = input[index];
+        const next = input[index + 1];
+        if (inString) {
+            result += current;
+            if (escaped)
+                escaped = false;
+            else if (current === "\\")
+                escaped = true;
+            else if (current === '"')
+                inString = false;
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            result += current;
+            continue;
+        }
+        if (current === "/" && next === "/") {
+            while (index < input.length && input[index] !== "\n")
+                index += 1;
+            if (index < input.length)
+                result += input[index];
+            continue;
+        }
+        if (current === "/" && next === "*") {
+            index += 2;
+            while (index < input.length && !(input[index] === "*" && input[index + 1] === "/")) {
+                if (input[index] === "\n")
+                    result += "\n";
+                index += 1;
+            }
+            index += 1;
+            continue;
+        }
+        result += current;
+    }
+    return result;
+}
+function stripTrailingCommas(input) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const current = input[index];
+        if (inString) {
+            result += current;
+            if (escaped)
+                escaped = false;
+            else if (current === "\\")
+                escaped = true;
+            else if (current === '"')
+                inString = false;
+            continue;
+        }
+        if (current === '"') {
+            inString = true;
+            result += current;
+            continue;
+        }
+        if (current === ",") {
+            let lookahead = index + 1;
+            while (lookahead < input.length && /\s/.test(input[lookahead]))
+                lookahead += 1;
+            if (input[lookahead] === "]" || input[lookahead] === "}")
+                continue;
+        }
+        result += current;
+    }
+    return result;
+}
+function parseJsonc(input) {
+    return JSON.parse(stripTrailingCommas(stripJsonComments(input)));
+}
+function importedRepositoryRowsFromParsed(parsed) {
+    if (Array.isArray(parsed))
+        return parsed;
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.projects)) {
+        return parsed.projects;
+    }
+    throw new Error("Repository import file must contain a JSON array or an object with a projects array");
+}
+function importedRepositoryPluginsFromParsed(parsed, baseDirectory) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return [];
+    return normalizePlugins(parsed.plugins, baseDirectory);
+}
+function readImportedRepositoryFile(filePath) {
+    const content = (0, node_fs_1.readFileSync)(filePath, "utf8");
+    const parsed = parseJsonc(content);
+    return {
+        rows: importedRepositoryRowsFromParsed(parsed),
+        plugins: importedRepositoryPluginsFromParsed(parsed, node_path_1.default.dirname(filePath)),
+    };
+}
+function readImportedRepositoryRows(filePath) {
+    const { rows } = readImportedRepositoryFile(filePath);
+    return rows.map((item, index) => {
+        const row = item;
+        if (!row?.url || typeof row.url !== "string") {
+            throw new Error(`Repository entry ${index + 1} is missing a valid url`);
+        }
+        return row;
+    });
+}
+function readImportedRepositoryPlugins(filePath) {
+    return readImportedRepositoryFile(filePath).plugins;
+}
+function writeImportedRepositoryRows(filePath, rows) {
+    const content = (0, node_fs_1.readFileSync)(filePath, "utf8");
+    const parsed = parseJsonc(content);
+    if (Array.isArray(parsed)) {
+        (0, node_fs_1.writeFileSync)(filePath, `${JSON.stringify(rows, null, 2)}\n`, "utf8");
+        return;
+    }
+    if (parsed && typeof parsed === "object" && "projects" in parsed) {
+        (0, node_fs_1.writeFileSync)(filePath, `${JSON.stringify({ ...parsed, projects: rows }, null, 2)}\n`, "utf8");
+        return;
+    }
+    throw new Error("Repository import file must contain a JSON array or an object with a projects array");
+}
+function loadImportedRepositories(filePath) {
+    const repositoryFile = readImportedRepositoryFile(filePath);
+    return loadImportedRepositoriesFromRows(repositoryFile.rows, repositoryFile.plugins);
+}
+function loadImportedRepositoriesFromRows(rows, plugins = []) {
+    return rows.map((item, index) => {
+        const row = item;
+        if (!row?.url || typeof row.url !== "string") {
+            throw new Error(`Repository entry ${index + 1} is missing a valid url`);
+        }
+        const remoteUrl = (0, git_repository_1.normalizeRepositoryUrl)(row.url);
+        const repository = (0, git_repository_1.repositoryName)(remoteUrl);
+        const name = typeof row.name === "string" ? row.name.trim() : "";
+        const description = typeof row.description === "string" ? row.description.trim() : "";
+        return {
+            remoteUrl,
+            repository,
+            name: name || undefined,
+            description: description || undefined,
+            hasCustomName: Boolean(name),
+            tags: (0, native_bridge_1.normalizeTags)(row.tags),
+            subpaths: (0, native_bridge_1.normalizeSubpaths)(row.subpaths),
+            allSubpath: row.allSubpath === true,
+            collapseSubpaths: row.collapseSubpaths === true,
+            allTopLevelFolders: row.allTopLevelFolders === true,
+            folderDepth: (0, native_bridge_1.normalizeFolderDepth)(row.folderDepth) ?? 0,
+            folders: (0, native_bridge_1.normalizeFolders)(row.folders),
+            clonePathTemplate: normalizeClonePathTemplate(row.clonePathTemplate),
+            plugins,
+            removePathFromName: row.removePathFromName === true,
+            searchPriority: (0, project_schema_1.normalizeSearchPriority)(row.searchPriority) ?? 0,
+            linkedRepositories: [],
+            linkedOrganisations: [],
+        };
+    });
+}
+function loadRepositorySubpaths(worktree, subpaths) {
+    const items = new Set();
+    for (const subpath of subpaths) {
+        const parentDirectory = subpath.path === "." ? worktree : node_path_1.default.join(worktree, ...subpath.path.split("/"));
+        for (const item of (0, project_subpaths_1.readSubpathChildDirectories)(parentDirectory))
+            items.add(item);
+    }
+    return [...items];
+}

package/node_modules/@raggle-ai/local/dist/adapters/init.d.ts

@@ -0,0 +1 @@
+export declare function initializeRepository(startDirectory: string): Promise<string>;

package/node_modules/@raggle-ai/local/dist/adapters/init.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeRepository = initializeRepository;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const RAGGLE_CONFIG_SCHEMA_URL = "https://raggle.co/config.json";
+const RAGGLE_CONFIG_SCHEMA_VERSION = 1;
+const INITIAL_CONFIG = {
+    $schema: RAGGLE_CONFIG_SCHEMA_URL,
+    schemaVersion: RAGGLE_CONFIG_SCHEMA_VERSION,
+};
+async function initializeRepository(startDirectory) {
+    let configDirectory;
+    try {
+        configDirectory = await (0, promises_1.realpath)(startDirectory);
+    }
+    catch {
+        throw new Error(`Folder does not exist: ${startDirectory}`);
+    }
+    const configPath = node_path_1.default.join(configDirectory, "raggle.json");
+    try {
+        await (0, promises_1.writeFile)(configPath, `${JSON.stringify(INITIAL_CONFIG, null, 2)}\n`, {
+            encoding: "utf8",
+            flag: "wx",
+        });
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            throw new Error(`Raggle config already exists: ${configPath}`);
+        }
+        throw error;
+    }
+    return configPath;
+}

package/node_modules/@raggle-ai/local/dist/adapters/libsql-client.d.ts

@@ -0,0 +1,11 @@
+import { type Client } from "@libsql/client/web";
+/**
+ * Creates a libsql client for a remote (`libsql:`/`https:`) or local (`file:`)
+ * database. Remote URLs use the web client so the package stays free of native
+ * dependencies in web/edge builds; `file:` URLs use the full Node client, which
+ * is the only client that supports local database files.
+ */
+export declare function createLibsqlClient(options: {
+    url: string;
+    authToken?: string;
+}): Client;