kennel 0.1.9 → 0.2.1

package/node_modules/@raggle-ai/local/dist/core/live-project-search.d.ts

@@ -0,0 +1,47 @@
+import { type SearchableProject, type ProjectSearchIndexOptions } from "./search";
+import { type UserProjectLoadOptions } from "./user-projects";
+export type LiveProjectSnapshot<T extends SearchableProject> = {
+    projects: readonly T[];
+    updatedAt?: number;
+    refreshing: boolean;
+    error?: Error;
+};
+export type LiveProjectSearchOptions<T extends SearchableProject> = {
+    loadProjects(): Promise<T[]>;
+    refreshIntervalMs?: number;
+    indexOptions?: ProjectSearchIndexOptions<T>;
+    initialSnapshot?: {
+        projects: T[];
+        updatedAt: number;
+    };
+};
+/** Scout owns scan scheduling and indexing. Hosts own presentation and opening. */
+export declare function createLiveProjectSearch<T extends SearchableProject>(options: LiveProjectSearchOptions<T>): {
+    getSnapshot: () => LiveProjectSnapshot<T>;
+    refresh: () => Promise<void>;
+    refreshIfStale(): Promise<void>;
+    search: (query: string, searchOptions?: {
+        limit?: number;
+    }) => import("./search").GroupedProjectSearchResult<T>;
+    searchFlat: (query: string, searchOptions?: {
+        limit?: number;
+    }) => import("./search").ProjectSearchResult<T>;
+    subscribe: (listener: (value: LiveProjectSnapshot<T>) => void) => () => void;
+    dispose(): void;
+};
+/** A global user catalog unless the caller explicitly selects a narrower scope. */
+export declare function createUserProjectSearch(options?: UserProjectLoadOptions & {
+    refreshIntervalMs?: number;
+}): {
+    getSnapshot: () => LiveProjectSnapshot<import("./project-schema").LocalProject>;
+    refresh: () => Promise<void>;
+    refreshIfStale(): Promise<void>;
+    search: (query: string, searchOptions?: {
+        limit?: number;
+    } | undefined) => import("./search").GroupedProjectSearchResult<import("./project-schema").LocalProject>;
+    searchFlat: (query: string, searchOptions?: {
+        limit?: number;
+    } | undefined) => import("./search").ProjectSearchResult<import("./project-schema").LocalProject>;
+    subscribe: (listener: (value: LiveProjectSnapshot<import("./project-schema").LocalProject>) => void) => () => void;
+    dispose(): void;
+};

package/node_modules/@raggle-ai/local/dist/core/live-project-search.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLiveProjectSearch = createLiveProjectSearch;
+exports.createUserProjectSearch = createUserProjectSearch;
+const search_1 = require("./search");
+const user_project_order_1 = require("../adapters/user-project-order");
+const user_settings_1 = require("../adapters/user-settings");
+const user_projects_1 = require("./user-projects");
+/** Scout owns scan scheduling and indexing. Hosts own presentation and opening. */
+function createLiveProjectSearch(options) {
+    const interval = options.refreshIntervalMs ?? user_projects_1.userProjectCacheMaxAgeMs;
+    if (!Number.isSafeInteger(interval) || interval <= 0)
+        throw new Error("Refresh interval must be a positive integer.");
+    let snapshot = { projects: [], ...options.initialSnapshot, refreshing: false };
+    let index = (0, search_1.buildProjectSearchIndex)(snapshot.projects, options.indexOptions);
+    let inFlight;
+    let disposed = false;
+    let timer;
+    const listeners = new Set();
+    function notify() {
+        for (const listener of listeners)
+            listener(snapshot);
+    }
+    function schedule() {
+        if (timer)
+            clearTimeout(timer);
+        if (disposed || listeners.size === 0)
+            return;
+        const age = snapshot.updatedAt === undefined ? interval : Date.now() - snapshot.updatedAt;
+        const delay = snapshot.error ? interval : Math.max(1, interval - age);
+        timer = setTimeout(() => void refresh().catch(() => { }), delay);
+        timer.unref?.();
+    }
+    function refresh() {
+        if (disposed)
+            return Promise.reject(new Error("Live project search is disposed."));
+        if (inFlight)
+            return inFlight;
+        if (timer)
+            clearTimeout(timer);
+        // Assign the promise before notifying listeners, so re-entrant calls share it.
+        inFlight = Promise.resolve()
+            .then(() => options.loadProjects())
+            .then((projects) => {
+            if (disposed)
+                return;
+            const nextIndex = (0, search_1.buildProjectSearchIndex)(projects, options.indexOptions);
+            index = nextIndex;
+            snapshot = { projects: [...projects], updatedAt: Date.now(), refreshing: false };
+        })
+            .catch((error) => {
+            if (!disposed) {
+                snapshot = {
+                    ...snapshot,
+                    refreshing: false,
+                    error: error instanceof Error ? error : new Error(String(error)),
+                };
+            }
+            throw error;
+        })
+            .finally(() => {
+            inFlight = undefined;
+            if (!disposed) {
+                schedule();
+                notify();
+            }
+        });
+        snapshot = { ...snapshot, refreshing: true };
+        notify();
+        return inFlight;
+    }
+    function subscribe(listener) {
+        if (disposed)
+            throw new Error("Live project search is disposed.");
+        listeners.add(listener);
+        listener(snapshot);
+        if (!snapshot.updatedAt || Date.now() - snapshot.updatedAt >= interval) {
+            void refresh().catch(() => { });
+        }
+        else if (!inFlight) {
+            schedule();
+        }
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0 && timer)
+                clearTimeout(timer);
+        };
+    }
+    return {
+        getSnapshot: () => snapshot,
+        refresh,
+        async refreshIfStale() {
+            if (disposed)
+                throw new Error("Live project search is disposed.");
+            if (inFlight)
+                await inFlight;
+            else if (!snapshot.updatedAt || Date.now() - snapshot.updatedAt >= interval)
+                await refresh();
+        },
+        search: (query, searchOptions) => (0, search_1.searchProjectIndexGrouped)(index, query, searchOptions),
+        searchFlat: (query, searchOptions) => (0, search_1.searchProjectIndex)(index, query, searchOptions),
+        subscribe,
+        dispose() {
+            disposed = true;
+            if (timer)
+                clearTimeout(timer);
+            listeners.clear();
+        },
+    };
+}
+/** A global user catalog unless the caller explicitly selects a narrower scope. */
+function createUserProjectSearch(options = {}) {
+    const cached = (0, user_projects_1.readCachedUserProjectSnapshot)(options);
+    return createLiveProjectSearch({
+        loadProjects: async () => (0, user_project_order_1.orderUserProjects)(await (0, user_projects_1.loadUserProjects)(options)),
+        refreshIntervalMs: options.refreshIntervalMs,
+        indexOptions: { baseGitHubUser: (0, user_settings_1.readRaggleUserSettings)().baseGitHubUser },
+        initialSnapshot: cached
+            ? { projects: (0, user_project_order_1.orderUserProjects)(cached.projects), updatedAt: cached.generatedAt }
+            : undefined,
+    });
+}

package/node_modules/@raggle-ai/local/dist/core/llm-context.d.ts

@@ -0,0 +1,29 @@
+import type { AgentInstructionOptions } from "./agent-instructions-settings";
+import type { UserProjectSearchItem } from "./search";
+import { type PersonalRelationsOverlay } from "./relation-commands";
+import type { RelationDepth } from "./relation-depth";
+export declare function projectSummary(project: UserProjectSearchItem): string | undefined;
+/**
+ * The repository or project root an LLM context message describes: the folder
+ * itself when it is a Git checkout, otherwise the nearest selected project
+ * root. Carries the origin URL and a one-line README purpose so a copied
+ * message stays self-identifying in another agent session.
+ */
+export type WorkingRepositoryIdentity = {
+    /** Resolved repository or project root the context describes. */
+    path: string;
+    /** Browser URL of that root's Git origin, when known. */
+    url?: string;
+    /** The requested folder when it differs from the resolved root. */
+    contextFolder?: string;
+    /** First useful README paragraph of the root, when present. */
+    summary?: string;
+};
+export declare function workingRepositoryIdentity(folder: string, selectedWorktree: string): WorkingRepositoryIdentity;
+export declare function buildLlmContextMessage(folder: string, connected: PersonalRelationsOverlay, options?: {
+    compact?: boolean;
+    includeInstructions?: boolean;
+    workingRepository?: WorkingRepositoryIdentity;
+}): string;
+export declare function buildLlmContextMessageForFolder(folder: string, depth?: RelationDepth, options?: AgentInstructionOptions): Promise<string>;
+export declare function buildOptionalLlmContextMessageForFolder(folder: string, depth?: RelationDepth, options?: AgentInstructionOptions): Promise<string | undefined>;

package/node_modules/@raggle-ai/local/dist/core/llm-context.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSummary = projectSummary;
+exports.workingRepositoryIdentity = workingRepositoryIdentity;
+exports.buildLlmContextMessage = buildLlmContextMessage;
+exports.buildLlmContextMessageForFolder = buildLlmContextMessageForFolder;
+exports.buildOptionalLlmContextMessageForFolder = buildOptionalLlmContextMessageForFolder;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const agent_instructions_1 = require("../adapters/agent-instructions");
+const scanner_1 = require("../discovery/scanner");
+const native_bridge_1 = require("../native-bridge");
+const connected_projects_1 = require("./connected-projects");
+const relation_commands_1 = require("./relation-commands");
+function localSubpathName(folder, project) {
+    if (project.relativePath)
+        return project.relativePath;
+    return node_path_1.default.relative((0, connected_projects_1.canonicalPath)(folder), (0, connected_projects_1.canonicalPath)(project.worktree));
+}
+function linkedRepositoryLabel(project) {
+    const remoteUrl = project.remoteMismatch?.actualRemoteUrl ?? project.remoteUrl;
+    const browserUrl = remoteUrl ? ((0, native_bridge_1.remoteToBrowserUrl)(remoteUrl) ?? remoteUrl) : undefined;
+    const worktree = (0, connected_projects_1.canonicalPath)(project.worktree);
+    return browserUrl ? `${worktree} (${browserUrl})` : worktree;
+}
+const readmeNames = ["README.md", "README.markdown", "README", "readme.md"];
+const maxReadmeBytes = 16 * 1024;
+const maxSummaryLength = 280;
+const repositoryDiscoveryGuidance = 'From this project folder, run `rgl list --q "relevant terms"` to find related repositories when the task needs more context. The command uses the current directory; no --folder argument is needed.';
+function readReadmePrefix(worktree) {
+    for (const name of readmeNames) {
+        let file;
+        try {
+            file = (0, node_fs_1.openSync)(node_path_1.default.join(worktree, name), "r");
+            const buffer = Buffer.alloc(maxReadmeBytes);
+            const bytesRead = (0, node_fs_1.readSync)(file, buffer, 0, buffer.length, 0);
+            return buffer.toString("utf8", 0, bytesRead);
+        }
+        catch {
+            // Try the next common README name.
+        }
+        finally {
+            if (file !== undefined)
+                (0, node_fs_1.closeSync)(file);
+        }
+    }
+    return undefined;
+}
+function firstUsefulParagraph(markdown) {
+    const paragraphs = markdown.replace(/^---\n[\s\S]*?\n---\n/, "").split(/\n\s*\n/);
+    for (const paragraph of paragraphs) {
+        const text = paragraph
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line &&
+            !line.startsWith("#") &&
+            !line.startsWith("```") &&
+            !line.startsWith("![") &&
+            !line.startsWith("[") &&
+            !line.startsWith("<") &&
+            !line.startsWith("|") &&
+            !/^[-:| ]+$/.test(line))
+            .join(" ")
+            .replace(/!\[[^\]]*\]\([^)]*\)/g, "")
+            .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+            .replace(/[*_`]/g, "")
+            .replace(/\s+/g, " ")
+            .trim();
+        if (text.length < 20)
+            continue;
+        return text.length > maxSummaryLength ? `${text.slice(0, maxSummaryLength - 1).trimEnd()}…` : text;
+    }
+    return undefined;
+}
+function folderSummary(worktree) {
+    const readme = readReadmePrefix(worktree);
+    return readme ? firstUsefulParagraph(readme) : undefined;
+}
+function projectSummary(project) {
+    const description = project.description?.trim();
+    if (description)
+        return description;
+    return folderSummary(project.repositoryRoot ?? project.worktree);
+}
+function workingRepositoryIdentity(folder, selectedWorktree) {
+    const folderRepository = (0, scanner_1.discoverRepository)(folder);
+    const repository = folderRepository ?? (0, scanner_1.discoverRepository)(selectedWorktree);
+    const root = folderRepository ? (0, connected_projects_1.canonicalPath)(folder) : selectedWorktree;
+    const rootPath = (0, connected_projects_1.canonicalPath)(root);
+    const contextFolder = (0, connected_projects_1.canonicalPath)(folder);
+    const url = repository?.remoteUrl ? ((0, native_bridge_1.remoteToBrowserUrl)(repository.remoteUrl) ?? repository.remoteUrl) : undefined;
+    const summary = folderSummary(rootPath);
+    return {
+        path: rootPath,
+        ...(url ? { url } : {}),
+        ...(contextFolder !== rootPath ? { contextFolder } : {}),
+        ...(summary ? { summary } : {}),
+    };
+}
+function nearestProjectConfigDirectory(startDirectory) {
+    let directory = (0, connected_projects_1.canonicalPath)(startDirectory);
+    while (true) {
+        if ((0, node_fs_1.statSync)(node_path_1.default.join(directory, "raggle.json"), { throwIfNoEntry: false })?.isFile())
+            return directory;
+        const parent = node_path_1.default.dirname(directory);
+        if (parent === directory)
+            return directory;
+        directory = parent;
+    }
+}
+function projectRepositoryKeys(project) {
+    return [project.remoteUrl, ...(project.relatedIds ?? [])]
+        .map((url) => (url ? (0, native_bridge_1.repositoryLocationKey)(url) : undefined))
+        .filter((key) => Boolean(key));
+}
+function missingDirectLinkedRepositories(folder, connected) {
+    const configDirectory = nearestProjectConfigDirectory(folder);
+    let config;
+    try {
+        config = (0, native_bridge_1.readRaggleProjectConfig)(configDirectory);
+    }
+    catch {
+        return [];
+    }
+    const selected = (0, connected_projects_1.canonicalPath)(connected.selectedWorktree);
+    const directLinks = config.linkedRepositories
+        .filter((entry) => (0, connected_projects_1.canonicalPath)(entry.project) === selected)
+        .map((entry) => ({ repository: entry.repository, type: entry.type }));
+    if (!directLinks.length)
+        return [];
+    const presentKeys = new Set();
+    for (const project of [...connected.linked, ...connected.linking, ...connected.local]) {
+        for (const key of projectRepositoryKeys(project))
+            presentKeys.add(key);
+    }
+    return directLinks.filter(({ repository }) => {
+        const key = (0, native_bridge_1.repositoryLocationKey)(repository);
+        if (!key)
+            return false;
+        return !presentKeys.has(key);
+    });
+}
+function repositoryTreeLines(root, projects, relations, direction, type, options = {}, reasons = new Map()) {
+    const projectByWorktree = new Map(projects.map((project) => [(0, connected_projects_1.canonicalPath)(project.worktree), project]));
+    const children = new Map();
+    for (const relation of relations) {
+        const parent = direction === "linked" ? relation.source : relation.target;
+        const child = direction === "linked" ? relation.target : relation.source;
+        if (!projectByWorktree.has(child))
+            continue;
+        const items = children.get(parent) ?? [];
+        if (!items.some((item) => item.source === relation.source && item.target === relation.target && item.type === relation.type)) {
+            items.push(relation);
+        }
+        children.set(parent, items);
+    }
+    const relationHeading = (relationType) => {
+        if (relationType === "notes")
+            return "Non-code project material";
+        if (relationType === "implementation")
+            return "Implementations";
+        if (relationType === "dependency")
+            return "Dependencies";
+        return "Linked folders";
+    };
+    const lines = [];
+    const visited = new Set();
+    const append = (parent, indent, allowedType, parentType) => {
+        const relationsByType = new Map();
+        for (const relation of children.get(parent) ?? []) {
+            if (allowedType && relation.type !== allowedType)
+                continue;
+            const items = relationsByType.get(relation.type) ?? [];
+            items.push(relation);
+            relationsByType.set(relation.type, items);
+        }
+        for (const [relationType, childRelations] of relationsByType) {
+            const showHeading = !allowedType && relationType !== parentType;
+            if (showHeading)
+                lines.push(`${"  ".repeat(indent)}${relationHeading(relationType)}:`);
+            const childIndent = showHeading ? indent + 1 : indent;
+            for (const relation of childRelations) {
+                const child = direction === "linked" ? relation.target : relation.source;
+                if (visited.has(child))
+                    continue;
+                visited.add(child);
+                const project = projectByWorktree.get(child);
+                if (!project)
+                    continue;
+                const folderPath = (0, connected_projects_1.canonicalPath)(child);
+                const includeInstructions = options.includeInstructions !== false;
+                const instruction = includeInstructions ? options.readInstruction?.(folderPath) : undefined;
+                lines.push(`${"  ".repeat(childIndent)}- ${linkedRepositoryLabel(project)}`);
+                if (instruction) {
+                    lines.push(``, ...instruction.split("\n"), ``);
+                }
+                if (options.notesInstruction && relation.type === "notes") {
+                    lines.push(`${"  ".repeat(childIndent)}Use this folder for any non-code material related to this project. Do not put implementation code there.`);
+                }
+                if (!instruction) {
+                    const summary = reasons.get(child) ?? projectSummary(project);
+                    if (summary)
+                        lines.push(`${"  ".repeat(childIndent + 1)}Description: ${summary}`);
+                }
+                append(child, childIndent + 1, undefined, relationType);
+            }
+        }
+    };
+    append((0, connected_projects_1.canonicalPath)(root), 0, type);
+    return lines;
+}
+function workingFolderLines(working) {
+    const lines = [`## Working folder`, ``];
+    lines.push(`- ${working.url ? `${working.path} (${working.url})` : working.path}`);
+    if (working.contextFolder)
+        lines.push(`  Context folder: ${working.contextFolder}`);
+    if (working.summary)
+        lines.push(`  Description: ${working.summary}`);
+    return lines;
+}
+function buildLlmContextMessage(folder, connected, options = {}) {
+    const selectedWorktree = connected.selectedWorktree ?? folder;
+    const includeInstructions = options.includeInstructions !== false;
+    let remainingBytes = (0, agent_instructions_1.readAgentInstructionSettings)().maxBytes;
+    const inlinedFolders = new Set();
+    const readInstruction = (candidate) => {
+        if (!includeInstructions || inlinedFolders.has(candidate))
+            return undefined;
+        inlinedFolders.add(candidate);
+        const instruction = (0, agent_instructions_1.readRepositoryAgentInstructions)(candidate, remainingBytes);
+        if (!instruction || !instruction.content.trim())
+            return undefined;
+        remainingBytes -= instruction.bytes;
+        return instruction.content.trim();
+    };
+    const reasons = connected.personalReasons ?? new Map();
+    const linkedKeys = new Set(connected.linked.map((project) => (0, connected_projects_1.canonicalPath)(project.worktree)));
+    const localSubpaths = (options.compact ? [] : connected.local)
+        .filter((project) => !linkedKeys.has((0, connected_projects_1.canonicalPath)(project.worktree)))
+        .map((project) => localSubpathName(folder, project))
+        .filter((name) => name && name !== ".");
+    const notesRepositories = repositoryTreeLines(selectedWorktree, connected.linking, connected.relations, "linking", "notes", { notesInstruction: true, includeInstructions, readInstruction }, reasons);
+    const implementationRepositories = [
+        ...repositoryTreeLines(selectedWorktree, connected.linked, connected.relations, "linked", "implementation", { includeInstructions, readInstruction }, reasons),
+        ...repositoryTreeLines(selectedWorktree, connected.linking, connected.relations, "linking", "implementation", { includeInstructions, readInstruction }, reasons),
+        // A notes project's outgoing notes link points at the repository it is
+        // researching, so show that target as an implementation.
+        ...repositoryTreeLines(selectedWorktree, connected.linked, connected.relations, "linked", "notes", { includeInstructions, readInstruction }, reasons),
+    ];
+    const dependencyRepositories = repositoryTreeLines(selectedWorktree, connected.linked, connected.relations, "linked", "dependency", { includeInstructions, readInstruction }, reasons);
+    const relatedRepositories = repositoryTreeLines(selectedWorktree, connected.linked, connected.relations, "linked", "related", { includeInstructions, readInstruction }, reasons);
+    const relatedLinkingRepositories = repositoryTreeLines(selectedWorktree, connected.linking, connected.relations, "linking", "related", { includeInstructions, readInstruction }, reasons);
+    const dependentRepositories = repositoryTreeLines(selectedWorktree, connected.linking, connected.relations, "linking", "dependency", { includeInstructions, readInstruction }, reasons);
+    const missingLinked = missingDirectLinkedRepositories(folder, connected);
+    if (!missingLinked.length &&
+        !localSubpaths.length &&
+        !notesRepositories.length &&
+        !implementationRepositories.length &&
+        !dependencyRepositories.length &&
+        !relatedRepositories.length &&
+        !relatedLinkingRepositories.length &&
+        !dependentRepositories.length) {
+        return [
+            ...(options.workingRepository ? workingFolderLines(options.workingRepository) : []),
+            `No linked repositories or subprojects were found within this folder (${folder}).`,
+            ``,
+            repositoryDiscoveryGuidance,
+        ].join("\n");
+    }
+    const lines = [];
+    if (options.workingRepository) {
+        lines.push(...workingFolderLines(options.workingRepository), ``);
+    }
+    const hasLocalLocations = Boolean(localSubpaths.length ||
+        notesRepositories.length ||
+        implementationRepositories.length ||
+        dependencyRepositories.length ||
+        relatedRepositories.length ||
+        relatedLinkingRepositories.length ||
+        dependentRepositories.length);
+    if (hasLocalLocations && !options.compact) {
+        lines.push(`## Local code locations`, ``, `These repositories are already resolved to local checkouts. Use the paths below directly. Do not search for another checkout or clone these repositories again.`);
+    }
+    if (relatedRepositories.length || relatedLinkingRepositories.length) {
+        lines.push(``, `Linked folders:`, ``, ...relatedRepositories, ...relatedLinkingRepositories);
+    }
+    if (notesRepositories.length) {
+        lines.push(``, `Non-code project material:`, ``, ...notesRepositories);
+    }
+    if (implementationRepositories.length) {
+        lines.push(``, `Implementations:`, ``, ...implementationRepositories);
+    }
+    if (dependencyRepositories.length) {
+        lines.push(``, `Dependencies:`, ``, ...dependencyRepositories);
+    }
+    if (dependentRepositories.length) {
+        lines.push(``, `Dependents:`, ``, ...dependentRepositories);
+    }
+    if (localSubpaths.length) {
+        lines.push(``, `Key local subpaths:`, ``, ...localSubpaths.map((name) => `- ${name}`));
+    }
+    if (hasLocalLocations && !options.compact) {
+        lines.push(``, `## Working with this code`, ``, `- Read and search within the listed roots using absolute paths. Local subpaths are relative to ${(0, connected_projects_1.canonicalPath)(folder)}.`, `- Read each repository's applicable agent instructions before editing.`, `- Edit files at their actual paths, not through .rgl/links mirrors.`, `- Run tests and Git commands in the repository being changed (for example: git -C "/absolute/repository/path" status).`, `- If a path is missing or access is denied, report it; do not silently choose another checkout.`);
+    }
+    if (missingLinked.length) {
+        lines.push(``, `## Not available locally`, ``, ...missingLinked.map(({ repository, type }) => `- ${repository} (${type}) — no local checkout resolved. Ask before cloning or selecting a different location.`));
+    }
+    lines.push(``, `## Discover related repositories`, ``, repositoryDiscoveryGuidance);
+    return lines.join("\n").trim();
+}
+async function contextProjects(folder, depth) {
+    return (0, relation_commands_1.mergePersonalRelations)(folder, await (0, connected_projects_1.listConnectedProjects)(folder, {
+        depth: depth ?? 1,
+        focused: depth === undefined,
+    }));
+}
+async function buildLlmContextMessageForFolder(folder, depth, options = {}) {
+    const instructions = (0, agent_instructions_1.buildAgentInstructionsMessage)(folder, options);
+    const connected = await contextProjects(folder, depth);
+    return [
+        buildLlmContextMessage(folder, connected, {
+            compact: depth === undefined,
+            includeInstructions: options.includeInstructions,
+            workingRepository: workingRepositoryIdentity(folder, connected.selectedWorktree),
+        }),
+        instructions,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+}
+async function buildOptionalLlmContextMessageForFolder(folder, depth, options = {}) {
+    const instructions = (0, agent_instructions_1.buildAgentInstructionsMessage)(folder, options);
+    const connected = await contextProjects(folder, depth);
+    if (!connected.linked.length &&
+        !connected.linking.length &&
+        (depth === undefined || !connected.local.length) &&
+        !missingDirectLinkedRepositories(folder, connected).length)
+        return instructions;
+    return [
+        buildLlmContextMessage(folder, connected, {
+            compact: depth === undefined,
+            includeInstructions: options.includeInstructions,
+            workingRepository: workingRepositoryIdentity(folder, connected.selectedWorktree),
+        }),
+        instructions,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+}

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

@@ -0,0 +1,37 @@
+import type { LocalSessionClient, LocalSessionSummary } from "../sessions";
+import type { LocalGitChange } from "./git-change";
+import type { LocalMarkdownFileSummary } from "./markdown-file";
+export declare const localMetadataSchemaVersion: 3;
+export type LocalMetadataProject = {
+    id: string;
+    worktree: string;
+    name: string;
+    relativePath: string;
+};
+export type LocalMetadata = {
+    schemaVersion: typeof localMetadataSchemaVersion;
+    folder: string;
+    sessions: {
+        items: LocalSessionSummary[];
+    };
+    files: {
+        items: LocalMarkdownFileSummary[];
+    };
+    instructions: {
+        items: LocalMarkdownFileSummary[];
+    };
+    changes: {
+        items: LocalGitChange[];
+    };
+    projects: {
+        items: LocalMetadataProject[];
+    };
+};
+export type ListLocalMetadataOptions = {
+    folder: string;
+    sessionClient?: LocalSessionClient;
+    sessionLimit?: number;
+    fileLimit?: number;
+    changeLimit?: number;
+    projectLimit?: number;
+};

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localMetadataSchemaVersion = void 0;
+exports.localMetadataSchemaVersion = 3;

package/node_modules/@raggle-ai/local/dist/core/local-repository-candidate.d.ts

@@ -0,0 +1,7 @@
+export type LocalRepositoryCandidate = {
+    worktree: string;
+    remoteUrl: string;
+    currentBranch?: string;
+};
+export declare function compareLocalRepositoryCandidatePreference(a: LocalRepositoryCandidate, b: LocalRepositoryCandidate): number;
+export declare function sortLocalRepositoryCandidates<T extends LocalRepositoryCandidate>(candidates: T[]): T[];

package/node_modules/@raggle-ai/local/dist/core/local-repository-candidate.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareLocalRepositoryCandidatePreference = compareLocalRepositoryCandidatePreference;
+exports.sortLocalRepositoryCandidates = sortLocalRepositoryCandidates;
+const node_path_1 = __importDefault(require("node:path"));
+const git_repository_1 = require("../adapters/git-repository");
+const primaryBranchNames = new Set(["main", "master"]);
+function isPrimaryBranch(branch) {
+    return branch ? primaryBranchNames.has(branch) : false;
+}
+function isLikelyGeneratedWorktreeName(name) {
+    return /(?:^|[-_])(?:pr|pull|worktree|wt)[-_]?\d+$/i.test(name);
+}
+function candidatePreferenceScore(candidate) {
+    const basename = node_path_1.default.basename(candidate.worktree).toLowerCase();
+    const remoteRepositoryName = (0, git_repository_1.repositoryName)(candidate.remoteUrl).toLowerCase();
+    return [
+        isPrimaryBranch(candidate.currentBranch) ? 0 : 1,
+        basename === remoteRepositoryName ? 0 : 1,
+        isLikelyGeneratedWorktreeName(basename) ? 1 : 0,
+    ];
+}
+function compareLocalRepositoryCandidatePreference(a, b) {
+    const aScore = candidatePreferenceScore(a);
+    const bScore = candidatePreferenceScore(b);
+    for (let index = 0; index < aScore.length; index += 1) {
+        const diff = aScore[index] - bScore[index];
+        if (diff !== 0)
+            return diff;
+    }
+    return a.worktree.localeCompare(b.worktree);
+}
+function sortLocalRepositoryCandidates(candidates) {
+    return [...candidates].sort((a, b) => {
+        const repositoryKeyCompare = (0, git_repository_1.repositoryLookupKey)(a.remoteUrl).localeCompare((0, git_repository_1.repositoryLookupKey)(b.remoteUrl));
+        if (repositoryKeyCompare !== 0)
+            return repositoryKeyCompare;
+        return compareLocalRepositoryCandidatePreference(a, b);
+    });
+}

package/node_modules/@raggle-ai/local/dist/core/logging.d.ts

@@ -0,0 +1,6 @@
+export type LogDetails = Record<string, number | string | boolean | undefined>;
+export declare function nowMs(): number;
+export declare function setLogsEnabled(enabled: boolean | undefined): void;
+export declare function isLogsEnabled(): boolean;
+export declare function logEvent(namespace: string, label: string, details?: LogDetails): void;
+export declare function logTiming(namespace: string, label: string, startedAt: number, details?: LogDetails): void;