gnosys 5.11.4 → 5.12.0

package/dist/lib/backupCommand.js

@@ -0,0 +1,54 @@
+import { copyFileSync, existsSync } from "fs";
+import path from "path";
+import { GnosysDB } from "./db.js";
+export async function runBackupCommand(opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available (better-sqlite3 missing).");
+            process.exitCode = 1;
+            return;
+        }
+        const outputDir = opts.to || opts.output;
+        const backupPath = await centralDb.backup(outputDir);
+        const counts = centralDb.getMemoryCount();
+        const projectCount = centralDb.getAllProjects().length;
+        const centralDir = GnosysDB.getCentralDbDir();
+        const copiedFiles = [backupPath];
+        const backupDir = path.dirname(backupPath);
+        const sandboxLog = path.join(centralDir, "sandbox", "sandbox.log");
+        if (existsSync(sandboxLog)) {
+            const logDest = path.join(backupDir, "sandbox.log.bak");
+            copyFileSync(sandboxLog, logDest);
+            copiedFiles.push(logDest);
+        }
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true, backupPath, memories: counts.total,
+                active: counts.active, archived: counts.archived,
+                projects: projectCount, files: copiedFiles,
+            }));
+        }
+        else {
+            console.log(`Backup created: ${backupPath}`);
+            console.log(`  Memories: ${counts.total} (${counts.active} active, ${counts.archived} archived)`);
+            console.log(`  Projects: ${projectCount}`);
+            if (copiedFiles.length > 1)
+                console.log(`  Additional files: ${copiedFiles.length - 1}`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Backup failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/bootstrapCommand.d.ts

@@ -0,0 +1,15 @@
+import type { GnosysResolver } from "./resolver.js";
+export type BootstrapCommandOptions = {
+    pattern?: string[];
+    skipExisting?: boolean;
+    category: string;
+    author: string;
+    authority: string;
+    confidence: string;
+    preserveFrontmatter?: boolean;
+    dryRun?: boolean;
+    store?: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runBootstrapCommand(getResolver: GetResolver, sourceDir: string, opts: BootstrapCommandOptions): Promise<void>;
+export {};

package/dist/lib/bootstrapCommand.js

@@ -0,0 +1,51 @@
+export async function runBootstrapCommand(getResolver, sourceDir, opts) {
+    const resolver = await getResolver();
+    const writeTarget = resolver.getWriteTarget(opts.store || undefined);
+    if (!writeTarget) {
+        console.error("No writable store found.");
+        process.exit(1);
+    }
+    // Show what we'll scan
+    const { bootstrap, discoverFiles } = await import("./bootstrap.js");
+    const files = await discoverFiles(sourceDir, opts.pattern);
+    console.log(`Found ${files.length} files in ${sourceDir}\n`);
+    if (files.length === 0) {
+        console.log("Nothing to import.");
+        return;
+    }
+    const result = await bootstrap(writeTarget.store, {
+        sourceDir,
+        patterns: opts.pattern,
+        skipExisting: opts.skipExisting,
+        defaultCategory: opts.category,
+        defaultAuthor: opts.author,
+        defaultAuthority: opts.authority,
+        defaultConfidence: parseFloat(opts.confidence),
+        preserveFrontmatter: opts.preserveFrontmatter,
+        dryRun: opts.dryRun,
+    });
+    const mode = opts.dryRun ? "DRY RUN" : "COMPLETE";
+    console.log(`\nBootstrap ${mode}:`);
+    console.log(`  Scanned: ${result.totalScanned}`);
+    console.log(`  ${opts.dryRun ? "Would import" : "Imported"}: ${result.imported.length}`);
+    console.log(`  Skipped: ${result.skipped.length}`);
+    console.log(`  Failed: ${result.failed.length}`);
+    if (result.imported.length > 0) {
+        console.log(`\n${opts.dryRun ? "Would import" : "Imported"}:`);
+        for (const f of result.imported) {
+            console.log(`  + ${f}`);
+        }
+    }
+    if (result.skipped.length > 0) {
+        console.log(`\nSkipped (already exist):`);
+        for (const f of result.skipped) {
+            console.log(`  ⏭ ${f}`);
+        }
+    }
+    if (result.failed.length > 0) {
+        console.log(`\nFailed:`);
+        for (const f of result.failed) {
+            console.log(`  ❌ ${f.path}: ${f.error}`);
+        }
+    }
+}

package/dist/lib/briefingCommand.d.ts

@@ -0,0 +1,7 @@
+export type BriefingCommandOptions = {
+    project?: string;
+    all?: boolean;
+    directory?: string;
+    json: boolean;
+};
+export declare function runBriefingCommand(projectNameOrId: string | undefined, opts: BriefingCommandOptions): Promise<void>;

package/dist/lib/briefingCommand.js

@@ -0,0 +1,92 @@
+import { GnosysDB } from "./db.js";
+export async function runBriefingCommand(projectNameOrId, opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const { generateBriefing, generateAllBriefings, detectCurrentProject } = await import("./federated.js");
+        if (opts.all) {
+            const briefings = generateAllBriefings(centralDb);
+            if (opts.json) {
+                console.log(JSON.stringify({ count: briefings.length, briefings }, null, 2));
+            }
+            else {
+                if (briefings.length === 0) {
+                    console.log("No projects registered.");
+                    return;
+                }
+                for (const b of briefings) {
+                    console.log(`\n## ${b.projectName}`);
+                    console.log(b.summary);
+                }
+            }
+            return;
+        }
+        // v5.7.0: accept project name as positional argument in addition to --project <id>.
+        // Resolution order: positional name → --project flag → cwd auto-detect.
+        let pid = opts.project ?? null;
+        if (!pid && projectNameOrId) {
+            const byId = centralDb.getProject(projectNameOrId);
+            if (byId) {
+                pid = byId.id;
+            }
+            else {
+                const all = centralDb.getAllProjects();
+                const byName = all.find((p) => p.name === projectNameOrId);
+                if (byName)
+                    pid = byName.id;
+            }
+            if (!pid) {
+                console.error(`Project not found: "${projectNameOrId}". Run 'gnosys projects' to list registered projects.`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        if (!pid)
+            pid = await detectCurrentProject(centralDb, opts.directory || undefined);
+        if (!pid) {
+            console.error("No project specified and none detected.");
+            process.exitCode = 1;
+            return;
+        }
+        const briefing = generateBriefing(centralDb, pid);
+        if (!briefing) {
+            console.error(`Project not found: ${pid}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.json) {
+            console.log(JSON.stringify(briefing, null, 2));
+        }
+        else {
+            console.log(`# Briefing: ${briefing.projectName}`);
+            console.log(`Directory: ${briefing.workingDirectory}`);
+            console.log(`Active memories: ${briefing.activeMemories} / ${briefing.totalMemories}`);
+            console.log(`\nCategories:`);
+            for (const [cat, count] of Object.entries(briefing.categories).sort((a, b) => b[1] - a[1])) {
+                console.log(`  ${cat}: ${count}`);
+            }
+            console.log(`\nRecent activity (7d):`);
+            if (briefing.recentActivity.length === 0) {
+                console.log("  None");
+            }
+            for (const r of briefing.recentActivity) {
+                console.log(`  - ${r.title} (${r.modified})`);
+            }
+            console.log(`\nTop tags: ${briefing.topTags.slice(0, 10).map((t) => `${t.tag}(${t.count})`).join(", ") || "None"}`);
+            console.log(`\n${briefing.summary}`);
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/centralizeCommand.d.ts

@@ -0,0 +1,5 @@
+export type CentralizeCommandOptions = {
+    to: string;
+    force?: boolean;
+};
+export declare function runCentralizeCommand(opts: CentralizeCommandOptions): Promise<void>;

package/dist/lib/centralizeCommand.js

@@ -0,0 +1,16 @@
+import { centralizeDb } from "./centralize.js";
+export async function runCentralizeCommand(opts) {
+    try {
+        const r = await centralizeDb({ to: opts.to, force: opts.force });
+        const mb = (r.bytes / 1024 / 1024).toFixed(1);
+        console.log("✓ Seeded central brain:");
+        console.log(`  from: ${r.source}`);
+        console.log(`  to:   ${r.target} (${mb} MB)`);
+        console.log("");
+        console.log(`Run the server against it with GNOSYS_HOME=${opts.to}, or mount this dir as the container's /data volume.`);
+    }
+    catch (e) {
+        console.error(`centralize failed: ${e instanceof Error ? e.message : e}`);
+        process.exitCode = 1;
+    }
+}

package/dist/lib/chatCommand.d.ts

@@ -0,0 +1,12 @@
+import type { GnosysResolver } from "./resolver.js";
+export type ChatCommandOptions = {
+    resume?: string;
+    list?: boolean;
+    search?: string;
+    provider?: string;
+    model?: string;
+    limit: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runChatCommand(getResolver: GetResolver, opts: ChatCommandOptions): Promise<void>;
+export {};

package/dist/lib/chatCommand.js

@@ -0,0 +1,46 @@
+import { DEFAULT_CONFIG, loadConfig, resolveTaskModel, } from "./config.js";
+export async function runChatCommand(getResolver, opts) {
+    const limit = parseInt(opts.limit, 10) || 20;
+    const chat = await import("./chat/index.js");
+    if (opts.list) {
+        chat.printSessionList(limit);
+        return;
+    }
+    if (opts.search) {
+        chat.printSearchResults(opts.search, limit);
+        return;
+    }
+    const resolver = await getResolver();
+    const stores = resolver.getStores();
+    const storePath = stores[0]?.path ?? process.cwd();
+    let cliConfig;
+    try {
+        cliConfig = await loadConfig(storePath);
+    }
+    catch {
+        cliConfig = DEFAULT_CONFIG;
+    }
+    // Fail-fast on missing API key before TUI render.
+    {
+        const chatTask = resolveTaskModel(cliConfig, "chat");
+        const provider = opts.provider ?? chatTask.provider;
+        if (provider !== "ollama" && provider !== "lmstudio") {
+            const { getApiKeyForProvider } = await import("./setup.js");
+            const key = await getApiKeyForProvider(provider);
+            if (!key) {
+                const { Status } = await import("./setup/ui/status.js");
+                const envVar = `${provider.toUpperCase()}_API_KEY`;
+                process.stderr.write(`${Status("fail", `no API key for ${provider} (the configured chat provider)`)}\n`);
+                process.stderr.write(`   fix:  gnosys setup           pick a provider with a key, or add one\n`);
+                process.stderr.write(`         export ${envVar}=...\n`);
+                process.exit(1);
+            }
+        }
+    }
+    await chat.startChat({
+        config: cliConfig,
+        resume: opts.resume,
+        providerName: opts.provider,
+        modelName: opts.model,
+    });
+}

package/dist/lib/checkCommand.d.ts

@@ -0,0 +1,4 @@
+export type CheckCommandOptions = {
+    task?: string;
+};
+export declare function runCheckCommand(opts: CheckCommandOptions): Promise<void>;

package/dist/lib/checkCommand.js

@@ -0,0 +1,133 @@
+import path from "path";
+import { loadConfig, DEFAULT_CONFIG, resolveTaskModel, } from "./config.js";
+import { getGnosysHome } from "./paths.js";
+import { getLLMProvider, isProviderAvailable } from "./llm.js";
+export async function runCheckCommand(opts) {
+    const projectDir = process.cwd();
+    const storePath = path.join(projectDir, ".gnosys");
+    const globalStorePath = getGnosysHome();
+    // Load config: try project-level first, fall back to global ~/.gnosys/
+    let cfg;
+    let configSource;
+    try {
+        const projectCfg = await loadConfig(storePath);
+        // Check if it's just defaults (no actual config file) by seeing if dream has been configured
+        const hasProjectConfig = projectCfg.dream?.provider !== DEFAULT_CONFIG.dream?.provider ||
+            projectCfg.llm?.defaultProvider !== DEFAULT_CONFIG.llm?.defaultProvider;
+        if (hasProjectConfig) {
+            cfg = projectCfg;
+            configSource = storePath;
+        }
+        else {
+            cfg = await loadConfig(globalStorePath);
+            configSource = globalStorePath;
+        }
+    }
+    catch {
+        cfg = await loadConfig(globalStorePath);
+        configSource = globalStorePath;
+    }
+    const GREEN = "\x1b[32m";
+    const RED = "\x1b[31m";
+    const YELLOW = "\x1b[33m";
+    const DIM = "\x1b[2m";
+    const BOLD = "\x1b[1m";
+    const RESET = "\x1b[0m";
+    const CHECK = `${GREEN}✓${RESET}`;
+    const CROSS = `${RED}✗${RESET}`;
+    const WARN = `${YELLOW}⚠${RESET}`;
+    console.log(`\n${BOLD}Gnosys LLM Check${RESET} ${DIM}(config: ${configSource})${RESET}\n`);
+    const tasks = [
+        {
+            name: "structuring",
+            description: "adding memories, tagging",
+            resolve: () => resolveTaskModel(cfg, "structuring"),
+        },
+        {
+            name: "synthesis",
+            description: "Q&A answers (gnosys ask)",
+            resolve: () => resolveTaskModel(cfg, "synthesis"),
+        },
+        {
+            name: "chat",
+            description: "interactive chat (gnosys chat)",
+            // Chat reuses the synthesis task's model — surface it under its own name
+            // so users can see exactly what their TUI will use.
+            resolve: () => resolveTaskModel(cfg, "synthesis"),
+        },
+        {
+            name: "vision",
+            description: "images, PDFs",
+            resolve: () => resolveTaskModel(cfg, "vision"),
+        },
+        {
+            name: "transcription",
+            description: "audio files",
+            resolve: () => resolveTaskModel(cfg, "transcription"),
+        },
+        {
+            name: "dream",
+            description: "overnight consolidation",
+            resolve: () => ({
+                provider: cfg.dream?.provider || "ollama",
+                model: cfg.dream?.model || "llama3.2",
+            }),
+        },
+    ];
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    // Filter to a single task if --task was given.
+    const filteredTasks = opts.task
+        ? tasks.filter((t) => t.name === opts.task)
+        : tasks;
+    if (opts.task && filteredTasks.length === 0) {
+        console.error(`Unknown task: ${opts.task}. Pick one of: ${tasks.map((t) => t.name).join(", ")}`);
+        process.exit(1);
+    }
+    for (const task of filteredTasks) {
+        const { provider, model } = task.resolve();
+        const label = `${task.name.padEnd(16)} ${DIM}${provider} / ${model}${RESET}`;
+        const desc = `${DIM}(${task.description})${RESET}`;
+        // Special handling for dream — check if enabled
+        if (task.name === "dream" && !cfg.dream?.enabled) {
+            console.log(`  ${WARN} ${label}  disabled  ${desc}`);
+            skipped++;
+            continue;
+        }
+        // Check provider availability (API key, etc.)
+        const availability = isProviderAvailable(cfg, provider);
+        if (!availability.available) {
+            console.log(`  ${CROSS} ${label}  ${RED}${availability.error}${RESET}  ${desc}`);
+            failed++;
+            continue;
+        }
+        // Test actual connection with timing
+        const start = Date.now();
+        try {
+            const llmProvider = getLLMProvider({ ...cfg, llm: { ...cfg.llm, defaultProvider: provider } });
+            await llmProvider.testConnection();
+            const ms = Date.now() - start;
+            console.log(`  ${CHECK} ${label}  ${GREEN}${ms}ms${RESET}  ${desc}`);
+            passed++;
+        }
+        catch (err) {
+            const ms = Date.now() - start;
+            const errMsg = err instanceof Error ? err.message : String(err);
+            // Truncate long error messages
+            const shortErr = errMsg.length > 60 ? errMsg.slice(0, 57) + "..." : errMsg;
+            console.log(`  ${CROSS} ${label}  ${RED}${shortErr}${RESET} (${ms}ms)  ${desc}`);
+            failed++;
+        }
+    }
+    console.log();
+    const total = passed + failed + skipped;
+    if (failed === 0) {
+        console.log(`${CHECK} All ${passed}/${total} tasks connected.`);
+    }
+    else {
+        console.log(`${passed}/${total} connected, ${failed} failed${skipped > 0 ? `, ${skipped} skipped` : ""}.`);
+        console.log(`\n${DIM}Fix: Run 'gnosys setup' to configure providers and API keys.${RESET}`);
+    }
+    console.log();
+}

package/dist/lib/clientReadOverlay.d.ts

@@ -0,0 +1,27 @@
+/**
+ * v13 client read overlay — merge pending-adds into read results.
+ */
+import type { DbMemory } from "./db.js";
+export type PendingAddRow = {
+    id: string;
+    title: string;
+    category: string;
+    content: string;
+    tags: string;
+    project_id: string | null;
+    scope: string;
+    created: string;
+};
+export interface OverlayReadResult {
+    memories: DbMemory[];
+    overlayCount: number;
+    source: string;
+}
+export declare function pendingAddToDbMemory(p: PendingAddRow): DbMemory;
+export declare function applyPendingOverlay(baseMemories: DbMemory[], pendingAdds: PendingAddRow[], ingestedUlids: Set<string>): OverlayReadResult;
+export declare function mergeOverlayDiscoverResults<T extends {
+    id: string;
+}>(base: T[], pendingAdds: PendingAddRow[], query: string, limit: number, toRow: (p: PendingAddRow) => T): T[];
+export declare function mergeOverlaySearchResults<T extends {
+    id: string;
+}>(base: T[], pendingAdds: PendingAddRow[], query: string, limit: number, toRow: (p: PendingAddRow) => T): T[];

package/dist/lib/clientReadOverlay.js

@@ -0,0 +1,73 @@
+/**
+ * v13 client read overlay — merge pending-adds into read results.
+ */
+export function pendingAddToDbMemory(p) {
+    return {
+        id: p.id,
+        title: p.title,
+        category: p.category,
+        content: p.content,
+        summary: null,
+        tags: p.tags,
+        relevance: "",
+        author: "user",
+        authority: "user",
+        confidence: 0.8,
+        reinforcement_count: 0,
+        content_hash: "",
+        status: "active",
+        tier: "active",
+        supersedes: null,
+        superseded_by: null,
+        last_reinforced: null,
+        created: p.created,
+        modified: p.created,
+        embedding: null,
+        source_path: null,
+        source_file: null,
+        source_page: null,
+        source_timerange: null,
+        project_id: p.project_id,
+        scope: p.scope,
+    };
+}
+export function applyPendingOverlay(baseMemories, pendingAdds, ingestedUlids) {
+    const stillPending = pendingAdds.filter((p) => !ingestedUlids.has(p.id));
+    const overlayMemories = stillPending.map(pendingAddToDbMemory);
+    const seen = new Set(baseMemories.map((m) => m.id));
+    const merged = [...baseMemories];
+    for (const m of overlayMemories) {
+        if (!seen.has(m.id)) {
+            merged.push(m);
+            seen.add(m.id);
+        }
+    }
+    return {
+        memories: merged,
+        overlayCount: overlayMemories.length,
+        source: "merged",
+    };
+}
+function pendingMatchesQuery(p, query) {
+    const q = query.replace(/['"]/g, "").trim().toLowerCase();
+    if (!q)
+        return true;
+    const hay = `${p.title} ${p.content} ${p.tags} ${p.category}`.toLowerCase();
+    return q.split(/\s+/).every((term) => hay.includes(term));
+}
+export function mergeOverlayDiscoverResults(base, pendingAdds, query, limit, toRow) {
+    const seen = new Set(base.map((r) => r.id));
+    const merged = [...base];
+    for (const p of pendingAdds) {
+        if (merged.length >= limit)
+            break;
+        if (seen.has(p.id) || !pendingMatchesQuery(p, query))
+            continue;
+        merged.push(toRow(p));
+        seen.add(p.id);
+    }
+    return merged;
+}
+export function mergeOverlaySearchResults(base, pendingAdds, query, limit, toRow) {
+    return mergeOverlayDiscoverResults(base, pendingAdds, query, limit, toRow);
+}

package/dist/lib/clientReadResolve.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared client read-path resolution for MCP tools and CLI commands.
+ */
+import { GnosysDB } from "./db.js";
+import { type ClientReadContext } from "./syncClient.js";
+import type { PendingAddRow } from "./clientReadOverlay.js";
+import type { DbMemory } from "./db.js";
+export interface ResolvedClientRead {
+    db: GnosysDB;
+    localDb: GnosysDB;
+    pendingOverlay: PendingAddRow[];
+    clientRead: ClientReadContext | null;
+    release: () => void;
+}
+/** Open central DB and apply v13 client read context when role is client. */
+export declare function resolveClientRead(): ResolvedClientRead | null;
+export declare function listMemoriesWithOverlay(resolved: ResolvedClientRead, fetch: (db: GnosysDB) => DbMemory[]): DbMemory[];
+export declare function getMemoryWithOverlay(resolved: ResolvedClientRead, id: string): DbMemory | null;
+export declare function discoverWithOverlay(resolved: ResolvedClientRead, query: string, limit: number): Array<{
+    id: string;
+    title: string;
+    relevance: string;
+    rank: number;
+    project_id: string | null;
+}>;
+export declare function searchWithOverlay(resolved: ResolvedClientRead, query: string, limit: number): Array<{
+    id: string;
+    title: string;
+    snippet: string;
+    rank: number;
+    project_id: string | null;
+}>;

package/dist/lib/clientReadResolve.js

@@ -0,0 +1,84 @@
+/**
+ * Shared client read-path resolution for MCP tools and CLI commands.
+ */
+import { GnosysDB } from "./db.js";
+import { readMachineConfig } from "./machineConfig.js";
+import { getConfiguredRemotePath } from "./remote.js";
+import { closeClientReadContext, openClientReadContext, } from "./syncClient.js";
+import { applyPendingOverlay, mergeOverlayDiscoverResults, mergeOverlaySearchResults, pendingAddToDbMemory, } from "./clientReadOverlay.js";
+/** Open central DB and apply v13 client read context when role is client. */
+export function resolveClientRead() {
+    const localDb = GnosysDB.openCentral();
+    if (!localDb.isAvailable()) {
+        localDb.close();
+        return null;
+    }
+    const mc = readMachineConfig();
+    if (!mc?.remote.enabled || mc.remote.role !== "client") {
+        return {
+            db: localDb,
+            localDb,
+            pendingOverlay: [],
+            clientRead: null,
+            release: () => localDb.close(),
+        };
+    }
+    const masterPath = getConfiguredRemotePath(localDb);
+    if (!masterPath) {
+        return {
+            db: localDb,
+            localDb,
+            pendingOverlay: [],
+            clientRead: null,
+            release: () => localDb.close(),
+        };
+    }
+    const clientRead = openClientReadContext(localDb, masterPath, mc.machineId);
+    return {
+        db: clientRead.db,
+        localDb,
+        pendingOverlay: clientRead.pendingOverlay,
+        clientRead,
+        release: () => {
+            closeClientReadContext(clientRead);
+            localDb.close();
+        },
+    };
+}
+export function listMemoriesWithOverlay(resolved, fetch) {
+    const base = fetch(resolved.db);
+    if (resolved.pendingOverlay.length === 0)
+        return base;
+    return applyPendingOverlay(base, resolved.pendingOverlay, new Set()).memories;
+}
+export function getMemoryWithOverlay(resolved, id) {
+    const fromDb = resolved.db.getMemory(id);
+    if (fromDb)
+        return fromDb;
+    const pending = resolved.pendingOverlay.find((p) => p.id === id);
+    return pending ? pendingAddToDbMemory(pending) : null;
+}
+export function discoverWithOverlay(resolved, query, limit) {
+    const base = resolved.db.discoverFts(query, limit);
+    if (resolved.pendingOverlay.length === 0)
+        return base;
+    return mergeOverlayDiscoverResults(base, resolved.pendingOverlay, query, limit, (p) => ({
+        id: p.id,
+        title: p.title,
+        relevance: "",
+        rank: 0,
+        project_id: p.project_id,
+    }));
+}
+export function searchWithOverlay(resolved, query, limit) {
+    const base = resolved.db.searchFts(query, limit);
+    if (resolved.pendingOverlay.length === 0)
+        return base;
+    return mergeOverlaySearchResults(base, resolved.pendingOverlay, query, limit, (p) => ({
+        id: p.id,
+        title: p.title,
+        snippet: p.content.substring(0, 200),
+        rank: 0,
+        project_id: p.project_id,
+    }));
+}

package/dist/lib/commitContextCommand.d.ts

@@ -0,0 +1,9 @@
+import type { GnosysResolver } from "./resolver.js";
+export type CommitContextOptions = {
+    dryRun?: boolean;
+    store?: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+type ResolveProjectId = (dir?: string) => Promise<string | null>;
+export declare function runCommitContextCommand(getResolver: GetResolver, resolveProjectId: ResolveProjectId, context: string, opts: CommitContextOptions): Promise<void>;
+export {};