kennel 0.1.8 → 0.2.0

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLibsqlClient = createLibsqlClient;
+const node_module_1 = require("node:module");
+const web_1 = require("@libsql/client/web");
+const requireFromPackage = (0, node_module_1.createRequire)(__filename);
+/**
+ * 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.
+ */
+function createLibsqlClient(options) {
+    if (!options.url.startsWith("file:"))
+        return (0, web_1.createClient)(options);
+    const { createClient } = requireFromPackage("@libsql/client");
+    return createClient(options);
+}

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

@@ -0,0 +1,32 @@
+export type LinkedWorkspaceMarker = {
+    schemaVersion: 1;
+    source: string;
+    repository?: string;
+};
+export type LinkedWorkspaceResult = LinkedWorkspaceMarker & {
+    owner: string;
+    path: string;
+    status: "synced" | "missing" | "unresolved" | "removed";
+};
+export type SearchableFileList = {
+    schemaVersion: 1;
+    root: string;
+    files: string[];
+};
+export declare function linkedWorkspacePath(owner: string, source: string, repository?: string): string;
+export declare function ensureLinkedWorkspaceRules(ownerDirectory: string): Promise<{
+    repositoryRoot: string;
+    excludePath: string;
+    ignorePath: string;
+}>;
+export declare function syncLinkedWorkspace(input: {
+    owner: string;
+    source: string;
+    repository?: string;
+}): Promise<LinkedWorkspaceResult>;
+export declare function listLinkedWorkspaces(ownerDirectory: string): LinkedWorkspaceResult[];
+export declare function removeLinkedWorkspace(ownerDirectory: string, match: {
+    source?: string;
+    repository?: string;
+}): LinkedWorkspaceResult | undefined;
+export declare function listSearchableFiles(folder: string): SearchableFileList;

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

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkedWorkspacePath = linkedWorkspacePath;
+exports.ensureLinkedWorkspaceRules = ensureLinkedWorkspaceRules;
+exports.syncLinkedWorkspace = syncLinkedWorkspace;
+exports.listLinkedWorkspaces = listLinkedWorkspaces;
+exports.removeLinkedWorkspace = removeLinkedWorkspace;
+exports.listSearchableFiles = listSearchableFiles;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const git_repository_1 = require("./git-repository");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const workspaceDirectoryName = ".rgl";
+const linksDirectoryName = "links";
+const markerFileName = ".rgl-link-target";
+const ignoredDirectoryNames = new Set([
+    ".git",
+    ".rgl",
+    ".direnv",
+    ".next",
+    ".nuxt",
+    ".turbo",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "vendor",
+]);
+function safeName(value) {
+    return (value
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "linked-folder");
+}
+function mirrorName(source, repository) {
+    const identity = repository ? (0, git_repository_1.canonicalRepositoryIdentity)(repository) : undefined;
+    if (identity) {
+        const segments = identity.key.split("/").slice(1);
+        return segments.slice(-2).map(safeName).join("--");
+    }
+    return safeName(node_path_1.default.basename(source));
+}
+function linkedWorkspacePath(owner, source, repository) {
+    return node_path_1.default.join(owner, workspaceDirectoryName, linksDirectoryName, mirrorName(source, repository));
+}
+function markerPath(linkPath) {
+    return node_path_1.default.join(linkPath, markerFileName);
+}
+function readMarker(linkPath) {
+    try {
+        const value = JSON.parse((0, node_fs_1.readFileSync)(markerPath(linkPath), "utf8"));
+        if (value.schemaVersion !== 1 || typeof value.source !== "string")
+            return undefined;
+        if (value.repository !== undefined && typeof value.repository !== "string")
+            return undefined;
+        return {
+            schemaVersion: 1,
+            source: node_path_1.default.resolve(value.source),
+            ...(value.repository ? { repository: value.repository } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function sameMarker(left, right) {
+    return left.source === right.source && left.repository === right.repository;
+}
+function syncDirectory(destination, source) {
+    (0, node_fs_1.mkdirSync)(destination, { recursive: true });
+    for (const entry of (0, node_fs_1.readdirSync)(source, { withFileTypes: true })) {
+        if (entry.name === markerFileName)
+            continue;
+        if (entry.isDirectory() && ignoredDirectoryNames.has(entry.name))
+            continue;
+        const sourcePath = node_path_1.default.join(source, entry.name);
+        const destinationPath = node_path_1.default.join(destination, entry.name);
+        if (entry.isDirectory())
+            syncDirectory(destinationPath, sourcePath);
+        else
+            (0, node_fs_1.symlinkSync)(sourcePath, destinationPath);
+    }
+}
+function appendMissingLines(filePath, lines) {
+    let existing = "";
+    try {
+        existing = (0, node_fs_1.readFileSync)(filePath, "utf8");
+    }
+    catch {
+        // The file is created below.
+    }
+    const present = new Set(existing.split(/\r?\n/));
+    const missing = lines.filter((line) => !present.has(line));
+    if (!missing.length)
+        return;
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(filePath), { recursive: true });
+    const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
+    (0, node_fs_1.writeFileSync)(filePath, `${existing}${prefix}${missing.join("\n")}\n`, "utf8");
+}
+async function gitContext(owner) {
+    const [{ stdout: rootOutput }, { stdout: excludeOutput }] = await Promise.all([
+        execFileAsync("git", ["-C", owner, "rev-parse", "--show-toplevel"]),
+        execFileAsync("git", ["-C", owner, "rev-parse", "--git-path", "info/exclude"]),
+    ]);
+    const repositoryRoot = (0, node_fs_1.realpathSync)(rootOutput.trim());
+    const rawExcludePath = excludeOutput.trim();
+    const excludePath = node_path_1.default.isAbsolute(rawExcludePath) ? rawExcludePath : node_path_1.default.resolve(owner, rawExcludePath);
+    return { repositoryRoot, excludePath };
+}
+async function isTracked(repositoryRoot, relativePath) {
+    try {
+        await execFileAsync("git", ["-C", repositoryRoot, "ls-files", "--error-unmatch", "--", relativePath]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureLinkedWorkspaceRules(ownerDirectory) {
+    const owner = (0, node_fs_1.realpathSync)(ownerDirectory);
+    const { repositoryRoot, excludePath } = await gitContext(owner);
+    appendMissingLines(excludePath, [".rgl/", ".ignore"]);
+    const ignorePath = node_path_1.default.join(repositoryRoot, ".ignore");
+    if (!(await isTracked(repositoryRoot, ".ignore"))) {
+        const relativeOwner = node_path_1.default.relative(repositoryRoot, owner).split(node_path_1.default.sep).join("/");
+        const prefix = relativeOwner ? `${relativeOwner}/` : "";
+        appendMissingLines(ignorePath, [
+            `!${prefix}.rgl/`,
+            `!${prefix}.rgl/**`,
+            `${prefix}.rgl/**/.rgl/`,
+            `${prefix}.rgl/**/.rgl/**`,
+        ]);
+    }
+    return { repositoryRoot, excludePath, ignorePath };
+}
+async function syncLinkedWorkspace(input) {
+    const owner = (0, node_fs_1.realpathSync)(input.owner);
+    const source = (0, node_fs_1.realpathSync)(input.source);
+    if (!(0, node_fs_1.statSync)(owner).isDirectory())
+        throw new Error(`Project folder does not exist: ${owner}`);
+    if (!(0, node_fs_1.statSync)(source).isDirectory())
+        throw new Error(`Linked folder does not exist: ${source}`);
+    if (owner === source)
+        throw new Error(`Cannot link a project folder to itself: ${owner}`);
+    const repository = input.repository ? (0, git_repository_1.canonicalRepositoryIdentity)(input.repository)?.repository : undefined;
+    const marker = { schemaVersion: 1, source, ...(repository ? { repository } : {}) };
+    const linkPath = linkedWorkspacePath(owner, source, repository);
+    const existing = readMarker(linkPath);
+    if ((0, node_fs_1.lstatSync)(linkPath, { throwIfNoEntry: false }) && (!existing || !sameMarker(existing, marker))) {
+        throw new Error(`Linked workspace path is not managed for this source: ${linkPath}`);
+    }
+    await ensureLinkedWorkspaceRules(owner);
+    const linksDirectory = node_path_1.default.dirname(linkPath);
+    (0, node_fs_1.mkdirSync)(linksDirectory, { recursive: true });
+    const temporaryPath = `${linkPath}.tmp-${process.pid}-${Date.now()}`;
+    const backupPath = `${linkPath}.old-${process.pid}-${Date.now()}`;
+    try {
+        syncDirectory(temporaryPath, source);
+        (0, node_fs_1.writeFileSync)(markerPath(temporaryPath), `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+        if (existing)
+            (0, node_fs_1.renameSync)(linkPath, backupPath);
+        (0, node_fs_1.renameSync)(temporaryPath, linkPath);
+        (0, node_fs_1.rmSync)(backupPath, { recursive: true, force: true });
+    }
+    catch (error) {
+        (0, node_fs_1.rmSync)(temporaryPath, { recursive: true, force: true });
+        if (!(0, node_fs_1.lstatSync)(linkPath, { throwIfNoEntry: false }) && (0, node_fs_1.lstatSync)(backupPath, { throwIfNoEntry: false })) {
+            (0, node_fs_1.renameSync)(backupPath, linkPath);
+        }
+        throw error;
+    }
+    return { ...marker, owner, path: linkPath, status: "synced" };
+}
+function listLinkedWorkspaces(ownerDirectory) {
+    const owner = (0, node_fs_1.realpathSync)(ownerDirectory);
+    const linksDirectory = node_path_1.default.join(owner, workspaceDirectoryName, linksDirectoryName);
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(linksDirectory, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .flatMap((entry) => {
+        const linkPath = node_path_1.default.join(linksDirectory, entry.name);
+        const marker = readMarker(linkPath);
+        if (!marker)
+            return [];
+        return [
+            {
+                ...marker,
+                owner,
+                path: linkPath,
+                status: (0, node_fs_1.statSync)(marker.source, { throwIfNoEntry: false })?.isDirectory() ? "synced" : "missing",
+            },
+        ];
+    })
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+function removeLinkedWorkspace(ownerDirectory, match) {
+    const owner = (0, node_fs_1.realpathSync)(ownerDirectory);
+    const source = match.source ? node_path_1.default.resolve(match.source) : undefined;
+    const repository = match.repository ? (0, git_repository_1.canonicalRepositoryIdentity)(match.repository)?.repository : undefined;
+    if (!source && !repository)
+        return undefined;
+    const linkPath = linkedWorkspacePath(owner, source ?? "linked-repository", repository);
+    if (!(0, node_fs_1.lstatSync)(linkPath, { throwIfNoEntry: false }))
+        return undefined;
+    const marker = readMarker(linkPath);
+    if (!marker)
+        throw new Error(`Linked workspace is not managed by Raggle: ${linkPath}`);
+    if ((source && marker.source !== source) || (repository && marker.repository !== repository)) {
+        throw new Error(`Linked workspace belongs to a different source: ${linkPath}`);
+    }
+    (0, node_fs_1.rmSync)(linkPath, { recursive: true });
+    return { ...marker, owner, path: linkPath, status: "removed" };
+}
+function listSearchableFiles(folder) {
+    const root = (0, node_fs_1.realpathSync)(folder);
+    if (!(0, node_fs_1.statSync)(root).isDirectory())
+        throw new Error(`Folder does not exist: ${root}`);
+    const files = [];
+    const visit = (directory, relativeDirectory) => {
+        for (const entry of (0, node_fs_1.readdirSync)(directory, { withFileTypes: true })) {
+            if (entry.name === markerFileName)
+                continue;
+            const relativePath = relativeDirectory ? node_path_1.default.join(relativeDirectory, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                if (ignoredDirectoryNames.has(entry.name) && entry.name !== workspaceDirectoryName)
+                    continue;
+                visit(node_path_1.default.join(directory, entry.name), relativePath);
+                continue;
+            }
+            if (entry.isFile() || entry.isSymbolicLink())
+                files.push(relativePath.split(node_path_1.default.sep).join("/"));
+        }
+    };
+    visit(root, "");
+    files.sort((left, right) => left.localeCompare(right));
+    return { schemaVersion: 1, root, files };
+}

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

@@ -0,0 +1,4 @@
+export declare function resolveLocalFolder(value: string | null | undefined, options: {
+    lockedRoot?: string;
+    root: string;
+}): string;

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

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocalFolder = resolveLocalFolder;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function resolveLocalFolder(value, options) {
+    const folder = (0, node_fs_1.realpathSync)(node_path_1.default.resolve(value ?? options.root));
+    if (!options.lockedRoot)
+        return folder;
+    const relativePath = node_path_1.default.relative(options.lockedRoot, folder);
+    if (!relativePath || (!relativePath.startsWith("..") && !node_path_1.default.isAbsolute(relativePath)))
+        return folder;
+    throw new Error(`Folder is outside the viewer root: ${folder}`);
+}

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

@@ -0,0 +1,18 @@
+import type { LocalMetadata } from "../core/local-metadata";
+export type LocalMetadataIconAsset = {
+    data: string;
+    mediaType: "image/jpeg" | "image/png";
+    source: "github" | "local";
+};
+export type LocalMetadataProjectWithIcon = LocalMetadata["projects"]["items"][number] & {
+    iconAssetKey?: string;
+};
+export declare function hydrateLocalMetadataAssets(metadata: LocalMetadata): Promise<{
+    assets: Record<string, LocalMetadataIconAsset>;
+    iconAssetKey: string | undefined;
+    projects: {
+        items: (import("../core/local-metadata").LocalMetadataProject & {
+            iconAssetKey?: string;
+        })[];
+    };
+}>;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hydrateLocalMetadataAssets = hydrateLocalMetadataAssets;
+const folder_metadata_1 = require("../folder-metadata");
+const assets_1 = require("../folder-metadata/assets");
+async function hydrateLocalMetadataAssets(metadata) {
+    const assets = {};
+    const files = new Map();
+    const icon = async (folder) => {
+        const resolved = (0, folder_metadata_1.resolveFolderMetadata)(folder).icon;
+        if (!resolved)
+            return undefined;
+        const existing = files.get(resolved.path);
+        if (existing)
+            return existing;
+        const request = (async () => {
+            const asset = await (0, assets_1.readIconAsset)(resolved.path);
+            if (!asset)
+                return undefined;
+            const key = (0, assets_1.iconAssetKey)(resolved.path);
+            assets[key] = { ...asset, source: "local" };
+            return key;
+        })();
+        files.set(resolved.path, request);
+        return request;
+    };
+    const [iconAssetKey, projects] = await Promise.all([
+        icon(metadata.folder),
+        Promise.all(metadata.projects.items.map(async (project) => ({
+            ...project,
+            iconAssetKey: await icon(project.worktree),
+        }))),
+    ]);
+    return { assets, iconAssetKey, projects: { items: projects } };
+}

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

@@ -0,0 +1,2 @@
+import { type ListLocalMetadataOptions, type LocalMetadata } from "../core/local-metadata";
+export declare function listLocalMetadata(options: ListLocalMetadataOptions): Promise<LocalMetadata>;

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listLocalMetadata = listLocalMetadata;
+const node_path_1 = __importDefault(require("node:path"));
+const sessions_1 = require("../sessions");
+const git_changes_1 = require("./git-changes");
+const markdown_files_1 = require("./markdown-files");
+const local_metadata_1 = require("../core/local-metadata");
+const project_instruction_1 = require("../core/project-instruction");
+const native_bridge_1 = require("../native-bridge");
+function localProjectSummary(p, folder) {
+    return {
+        id: p.id,
+        worktree: p.worktree,
+        name: p.name ?? node_path_1.default.basename(p.worktree),
+        relativePath: node_path_1.default.relative(folder, p.worktree),
+    };
+}
+async function listLocalMetadata(options) {
+    for (const [name, limit] of [
+        ["fileLimit", options.fileLimit],
+        ["changeLimit", options.changeLimit],
+        ["projectLimit", options.projectLimit],
+    ]) {
+        if (limit !== undefined && (!Number.isSafeInteger(limit) || limit < 0)) {
+            throw new Error(`${name} must be a non-negative integer`);
+        }
+    }
+    const folder = node_path_1.default.resolve(options.folder);
+    const [sessions, allFiles, changes, allProjects] = await Promise.all([
+        (0, sessions_1.listLocalSessions)({
+            folder,
+            client: options.sessionClient,
+            limit: options.sessionLimit,
+        }),
+        (0, markdown_files_1.listLocalMarkdownFiles)({ folder }),
+        (0, git_changes_1.listLocalGitChanges)(folder),
+        (0, native_bridge_1.discoverProjectsUnderFolder)({ folder }),
+    ]);
+    const files = options.fileLimit === undefined ? allFiles : allFiles.slice(0, options.fileLimit);
+    const instructions = allFiles.filter(project_instruction_1.isProjectInstruction).sort(project_instruction_1.compareProjectInstructions);
+    const limitedChanges = options.changeLimit === undefined ? changes : changes.slice(0, options.changeLimit);
+    const projects = allProjects
+        .map((project) => ({
+        id: project.id,
+        worktree: project.worktree,
+        name: project.name ?? node_path_1.default.basename(project.worktree),
+        relativePath: node_path_1.default.relative(folder, project.worktree),
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const limitedProjects = options.projectLimit === undefined ? projects : projects.slice(0, options.projectLimit);
+    return {
+        schemaVersion: local_metadata_1.localMetadataSchemaVersion,
+        folder,
+        sessions: { items: sessions },
+        files: { items: files },
+        instructions: { items: instructions },
+        changes: { items: limitedChanges },
+        projects: { items: limitedProjects },
+    };
+}

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

@@ -0,0 +1,17 @@
+export declare const applicationDirs: string[];
+export declare function installedApplicationPath(appNames: string[]): string | undefined;
+export declare function shellQuote(input: string): string;
+export declare function openCommand(target: string): string;
+export declare function openApplicationCommand(appPath: string, target: string): string;
+export declare function openInstalledApplicationCommand(appNames: string[], target: string): string;
+export declare function terminalCommand(binaryPath: string, worktree: string): string;
+export declare function opencodePath(): string;
+export declare function openInTerminalCommand(command: string): string;
+export declare function openIniTermCommand(worktree: string): string;
+export declare function runIniTermCommand(command: string): string;
+export declare function openInTerminal(command: string): Promise<void>;
+export declare function openIniTerm(worktree: string): Promise<void>;
+export declare function runIniTerm(command: string): Promise<void>;
+export declare function openInstalledApplicationUrl(appNames: string[], url: string): Promise<boolean>;
+export declare function openApplicationPath(appPath: string, target: string): Promise<void>;
+export declare function openInstalledApplicationPath(appNames: string[], target: string): Promise<boolean>;

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

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applicationDirs = void 0;
+exports.installedApplicationPath = installedApplicationPath;
+exports.shellQuote = shellQuote;
+exports.openCommand = openCommand;
+exports.openApplicationCommand = openApplicationCommand;
+exports.openInstalledApplicationCommand = openInstalledApplicationCommand;
+exports.terminalCommand = terminalCommand;
+exports.opencodePath = opencodePath;
+exports.openInTerminalCommand = openInTerminalCommand;
+exports.openIniTermCommand = openIniTermCommand;
+exports.runIniTermCommand = runIniTermCommand;
+exports.openInTerminal = openInTerminal;
+exports.openIniTerm = openIniTerm;
+exports.runIniTerm = runIniTerm;
+exports.openInstalledApplicationUrl = openInstalledApplicationUrl;
+exports.openApplicationPath = openApplicationPath;
+exports.openInstalledApplicationPath = openInstalledApplicationPath;
+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 execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+exports.applicationDirs = [
+    "/Applications",
+    "/System/Library/CoreServices",
+    node_path_1.default.join(node_os_1.default.homedir(), "Applications"),
+];
+function installedApplicationPath(appNames) {
+    for (const dir of exports.applicationDirs) {
+        for (const appName of appNames) {
+            const appPath = node_path_1.default.join(dir, appName);
+            if ((0, node_fs_1.existsSync)(appPath))
+                return appPath;
+        }
+    }
+    return undefined;
+}
+// =============================================================================
+// Shell quoting and command string builders
+// =============================================================================
+function shellQuote(input) {
+    return `'${input.replace(/'/g, `'\\''`)}'`;
+}
+function openCommand(target) {
+    return `open ${shellQuote(target)}`;
+}
+function openApplicationCommand(appPath, target) {
+    return `open -a ${shellQuote(appPath)} ${shellQuote(target)}`;
+}
+function openInstalledApplicationCommand(appNames, target) {
+    const application = installedApplicationPath(appNames) ?? appNames[0];
+    return application ? openApplicationCommand(application, target) : openCommand(target);
+}
+function terminalCommand(binaryPath, worktree) {
+    return `${shellQuote(binaryPath)} ${shellQuote(worktree)}`;
+}
+function opencodePath() {
+    return process.env.OPENCODE_PATH || node_path_1.default.join(node_os_1.default.homedir(), ".opencode/bin/opencode");
+}
+// =============================================================================
+// Terminal launching (osascript)
+// =============================================================================
+function terminalScript(command) {
+    return [
+        `tell application "Terminal" to do script ${JSON.stringify(command)}`,
+        'tell application "Terminal" to activate',
+    ];
+}
+function openInTerminalCommand(command) {
+    return ["osascript", ...terminalScript(command).map((line) => `-e ${shellQuote(line)}`)].join(" ");
+}
+function openIniTermCommand(worktree) {
+    return runIniTermCommand(`cd ${shellQuote(worktree)}`);
+}
+function runIniTermCommand(command) {
+    return [
+        "osascript",
+        `-e ${shellQuote('tell application "iTerm" to activate')}`,
+        `-e ${shellQuote(`tell application "iTerm" to set newWindow to create window with default profile`)}`,
+        `-e ${shellQuote(`tell application "iTerm" to tell current session of newWindow to write text ${JSON.stringify(command)}`)}`,
+    ].join(" ");
+}
+async function openInTerminal(command) {
+    await execFileAsync("osascript", terminalScript(command).flatMap((line) => ["-e", line]));
+}
+async function openIniTerm(worktree) {
+    await runIniTerm(`cd ${shellQuote(worktree)}`);
+}
+async function runIniTerm(command) {
+    await execFileAsync("osascript", [
+        "-e",
+        'tell application "iTerm" to activate',
+        "-e",
+        'tell application "iTerm" to set newWindow to create window with default profile',
+        "-e",
+        `tell application "iTerm" to tell current session of newWindow to write text ${JSON.stringify(command)}`,
+    ]);
+}
+// =============================================================================
+// App launching
+// =============================================================================
+async function openInstalledApplicationUrl(appNames, url) {
+    const appPath = installedApplicationPath(appNames);
+    if (!appPath)
+        return false;
+    await execFileAsync("open", ["-a", appPath, url]);
+    return true;
+}
+async function openApplicationPath(appPath, target) {
+    await execFileAsync("open", ["-a", appPath, target]);
+}
+async function openInstalledApplicationPath(appNames, target) {
+    const appPath = installedApplicationPath(appNames);
+    if (!appPath)
+        return false;
+    await openApplicationPath(appPath, target);
+    return true;
+}

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

@@ -0,0 +1,3 @@
+import type { ListLocalMarkdownFilesOptions, LocalMarkdownFile, LocalMarkdownFileSummary, ReadLocalMarkdownFileOptions } from "../core/markdown-file";
+export declare function listLocalMarkdownFiles(options: ListLocalMarkdownFilesOptions): Promise<LocalMarkdownFileSummary[]>;
+export declare function readLocalMarkdownFile(options: ReadLocalMarkdownFileOptions): Promise<LocalMarkdownFile>;