gnosys 5.11.4 → 5.12.2

package/dist/lib/prefCommand.js

@@ -0,0 +1,118 @@
+import { GnosysDB } from "./db.js";
+import { deletePreference, getAllPreferences, getPreference, KNOWN_PREFERENCE_KEYS, setPreference, suggestPreferenceKey, } from "./preferences.js";
+function outputPrefResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runPrefSetCommand(key, value, opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available (better-sqlite3 missing).");
+            process.exitCode = 1;
+            return;
+        }
+        if (!KNOWN_PREFERENCE_KEYS.includes(key)) {
+            const suggestion = suggestPreferenceKey(key);
+            if (suggestion) {
+                console.error(`Unknown preference key \`${key}\` — did you mean \`${suggestion}\`?`);
+                process.exitCode = 1;
+                return;
+            }
+        }
+        const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()) : undefined;
+        const pref = setPreference(centralDb, key, value, { title: opts.title, tags });
+        console.log(`Preference set: ${pref.title}`);
+        console.log(`  Key:   ${pref.key}`);
+        console.log(`  Value: ${pref.value}`);
+        console.log(`\nRun 'gnosys sync' to update agent rules files.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}
+export async function runPrefGetCommand(key, opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available (better-sqlite3 missing).");
+            process.exitCode = 1;
+            return;
+        }
+        if (key) {
+            const pref = getPreference(centralDb, key);
+            if (!pref) {
+                console.log(`No preference found for key "${key}".`);
+                return;
+            }
+            outputPrefResult(!!opts.json, pref, () => {
+                console.log(`${pref.title} (${pref.key})\n`);
+                console.log(pref.value);
+                console.log(`\nConfidence: ${pref.confidence}`);
+                console.log(`Modified: ${pref.modified}`);
+            });
+        }
+        else {
+            const prefs = getAllPreferences(centralDb);
+            if (prefs.length === 0) {
+                outputPrefResult(!!opts.json, { preferences: [] }, () => {
+                    console.log("No preferences set. Use 'gnosys pref set <key> <value>' to add some.");
+                });
+                return;
+            }
+            outputPrefResult(!!opts.json, { count: prefs.length, preferences: prefs }, () => {
+                console.log(`${prefs.length} user preference(s):\n`);
+                for (const p of prefs) {
+                    console.log(`  ${p.title} (${p.key})`);
+                    console.log(`    ${p.value.split("\n")[0]}`);
+                    console.log();
+                }
+            });
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}
+export async function runPrefDeleteCommand(key) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available (better-sqlite3 missing).");
+            process.exitCode = 1;
+            return;
+        }
+        const deleted = deletePreference(centralDb, key);
+        if (!deleted) {
+            console.log(`No preference found for key "${key}".`);
+            return;
+        }
+        console.log(`Preference "${key}" deleted.`);
+        console.log(`Run 'gnosys sync' to update agent rules files.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/projectsCommand.d.ts

@@ -0,0 +1,8 @@
+export type ProjectsCommandOptions = {
+    json?: boolean;
+    all?: boolean;
+    prune?: boolean;
+    dryRun?: boolean;
+    yes?: boolean;
+};
+export declare function runProjectsCommand(opts: ProjectsCommandOptions): Promise<void>;

package/dist/lib/projectsCommand.js

@@ -0,0 +1,131 @@
+import { existsSync } from "fs";
+import { GnosysDB } from "./db.js";
+function isDeadProjectDir(dir) {
+    return !existsSync(dir);
+}
+function outputProjectsResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runProjectsCommand(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 allProjects = centralDb.getAllProjects();
+        const { readMachineConfig } = await import("./machineConfig.js");
+        const { effectiveProjectPath } = await import("./projectPaths.js");
+        const machine = readMachineConfig();
+        const resolvedDirOf = (p) => effectiveProjectPath(centralDb, p, machine);
+        const isNotHere = (p) => {
+            const ep = resolvedDirOf(p);
+            return ep === null || !existsSync(ep);
+        };
+        if (opts.prune) {
+            const deadProjects = allProjects.filter((p) => isDeadProjectDir(p.working_directory));
+            if (deadProjects.length === 0) {
+                console.log("No dead projects to prune.");
+                return;
+            }
+            const DIM = "\x1b[2m";
+            const RESET = "\x1b[0m";
+            console.log(`Found ${deadProjects.length} dead project(s):\n`);
+            for (const p of deadProjects) {
+                const memCount = centralDb.getMemoriesByProject(p.id, true).length;
+                console.log(`  ${p.name}  ${DIM}${p.working_directory}${RESET}  (${memCount} memorie(s))`);
+            }
+            console.log();
+            if (opts.dryRun) {
+                console.log("[dry-run] No changes made. Re-run without --dry-run to delete.");
+                return;
+            }
+            if (!opts.yes) {
+                const readline = await import("readline/promises");
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                let answer = "";
+                try {
+                    answer = (await rl.question(`Delete these ${deadProjects.length} project registry entries? [y/N] `)).trim().toLowerCase();
+                }
+                finally {
+                    rl.close();
+                }
+                if (answer !== "y" && answer !== "yes") {
+                    console.log("Cancelled.");
+                    return;
+                }
+            }
+            for (const p of deadProjects) {
+                centralDb.deleteProject(p.id);
+            }
+            outputProjectsResult(!!opts.json, {
+                deleted: deadProjects.length,
+                remaining: allProjects.length - deadProjects.length,
+                deletedProjects: deadProjects.map((p) => ({ id: p.id, name: p.name, directory: p.working_directory })),
+            }, () => {
+                console.log(`✓ Pruned ${deadProjects.length} project(s). ${allProjects.length - deadProjects.length} remain.`);
+            });
+            return;
+        }
+        const visibleProjects = opts.all
+            ? allProjects
+            : allProjects.filter((p) => !isNotHere(p));
+        if (visibleProjects.length === 0) {
+            const deadCount = allProjects.length;
+            outputProjectsResult(!!opts.json, {
+                count: 0,
+                totalRegistered: deadCount,
+                deadCount,
+                projects: [],
+            }, () => {
+                if (deadCount === 0) {
+                    console.log("No projects registered. Run 'gnosys init' in a project directory.");
+                }
+                else {
+                    console.log(`No live projects (${deadCount} dead — run 'gnosys projects --all' to see them or 'gnosys projects --prune' to remove them).`);
+                }
+            });
+            return;
+        }
+        const projectData = visibleProjects.map((p) => ({
+            ...p,
+            resolvedDir: resolvedDirOf(p) ?? "(not on this machine)",
+            memoryCount: centralDb.getMemoriesByProject(p.id).length,
+        }));
+        const deadCount = allProjects.length - visibleProjects.length;
+        outputProjectsResult(!!opts.json, {
+            count: visibleProjects.length,
+            totalRegistered: allProjects.length,
+            deadCount,
+            projects: projectData,
+        }, () => {
+            const header = deadCount > 0 && !opts.all
+                ? `${visibleProjects.length} live project(s) (${deadCount} dead hidden — use --all or --prune):\n`
+                : `${visibleProjects.length} registered project(s):\n`;
+            console.log(header);
+            for (const p of projectData) {
+                console.log(`  ${p.name}`);
+                console.log(`    ID:        ${p.id}`);
+                console.log(`    Directory: ${p.resolvedDir}`);
+                console.log(`    Memories:  ${p.memoryCount}`);
+                console.log(`    Created:   ${p.created}`);
+                console.log();
+            }
+        });
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/readCommand.d.ts

@@ -0,0 +1,7 @@
+import type { GnosysResolver } from "./resolver.js";
+export type ReadCommandOptions = {
+    json?: boolean;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runReadCommand(getResolver: GetResolver, memoryPath: string, opts: ReadCommandOptions): Promise<void>;
+export {};

package/dist/lib/readCommand.js

@@ -0,0 +1,63 @@
+import fs from "fs/promises";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runReadCommand(getResolver, memoryPath, opts) {
+    // v13 client read path: master/snapshot routing + pending-offline-adds overlay,
+    // so `gnosys read <id>` sees the same memories as list/discover/search.
+    const { resolveClientRead, getMemoryWithOverlay } = await import("./clientReadResolve.js");
+    const resolved = resolveClientRead();
+    if (resolved) {
+        try {
+            const dbMem = getMemoryWithOverlay(resolved, memoryPath);
+            if (dbMem) {
+                const tags = dbMem.tags || "[]";
+                const headerLines = [
+                    `---`,
+                    `id: ${dbMem.id}`,
+                    `title: '${dbMem.title}'`,
+                    `category: ${dbMem.category}`,
+                    `tags: ${tags}`,
+                    `relevance: ${dbMem.relevance}`,
+                    `author: ${dbMem.author}`,
+                    `authority: ${dbMem.authority}`,
+                    `confidence: ${dbMem.confidence}`,
+                    `status: ${dbMem.status}`,
+                    `tier: ${dbMem.tier}`,
+                    `created: '${dbMem.created}'`,
+                    `modified: '${dbMem.modified}'`,
+                ];
+                if (dbMem.source_file) {
+                    headerLines.push(`source_file: ${dbMem.source_file}${dbMem.source_page != null ? ` (page ${Number(dbMem.source_page)})` : ""}`);
+                }
+                if (dbMem.source_path)
+                    headerLines.push(`source_path: ${dbMem.source_path}`);
+                headerLines.push(`---`);
+                const raw = `[Source: gnosys.db]\n\n${headerLines.join("\n")}\n\n${dbMem.content}`;
+                outputResult(!!opts.json, { path: memoryPath, source: "gnosys.db", content: raw, memory: dbMem }, () => {
+                    console.log(raw);
+                });
+                return;
+            }
+        }
+        finally {
+            resolved.release();
+        }
+    }
+    const resolver = await getResolver();
+    const memory = await resolver.readMemory(memoryPath);
+    if (!memory) {
+        console.error(`Memory not found: ${memoryPath}`);
+        process.exit(1);
+    }
+    const raw = await fs.readFile(memory.filePath, "utf-8");
+    outputResult(!!opts.json, { path: memoryPath, source: memory.sourceLabel, content: raw }, () => {
+        console.log(`[Source: ${memory.sourceLabel}]\n`);
+        console.log(raw);
+    });
+}

package/dist/lib/recall.d.ts

@@ -23,6 +23,7 @@
 import type { GnosysSearch } from "./search.js";
 import type { GnosysResolver } from "./resolver.js";
 import type { GnosysDB } from "./db.js";
+import { type PendingAddRow } from "./clientReadOverlay.js";
 import type { RecallConfig } from "./config.js";
 export interface RecallResult {
     memories: RecallMemory[];
@@ -68,6 +69,8 @@ export declare function recall(query: string, options: {
     recallConfig?: RecallConfig;
     /** v2.0: When provided, recall uses SQLite directly — no filesystem reads */
     gnosysDb?: GnosysDB;
+    /** v13: Pending offline adds to merge into recall results */
+    pendingOverlay?: PendingAddRow[];
 }): Promise<RecallResult>;
 /**
  * Format recall results as a host-friendly <gnosys-recall> block.

package/dist/lib/recall.js

@@ -21,6 +21,7 @@
  * No LLM calls. No embeddings. Pure index lookup. Sub-50ms.
  */
 import { GnosysArchive } from "./archive.js";
+import { mergeOverlayDiscoverResults, pendingAddToDbMemory, } from "./clientReadOverlay.js";
 import { auditLog } from "./audit.js";
 /** Default recall config */
 const DEFAULT_RECALL_CONFIG = {
@@ -67,7 +68,7 @@ export async function recall(query, options) {
     const limit = options.limit || cfg.maxMemories;
     // ─── v2.0 DB-backed fast path ──────────────────────────────────────
     if (options.gnosysDb?.isAvailable() && options.gnosysDb?.isMigrated()) {
-        return recallFromDb(query, options.gnosysDb, limit, cfg, options.traceId);
+        return recallFromDb(query, options.gnosysDb, limit, cfg, options.traceId, options.pendingOverlay);
     }
     // ─── v1.x legacy path (filesystem + search.db) ────────────────────
     const memories = [];
@@ -144,15 +145,29 @@ export async function recall(query, options) {
  * v2.0 DB-backed recall — runs entirely from gnosys.db.
  * No filesystem reads. No separate search.db. Sub-10ms target.
  */
-function recallFromDb(query, db, limit, cfg, traceId) {
+function recallFromDb(query, db, limit, cfg, traceId, pendingOverlay) {
     const start = performance.now();
     const memories = [];
     // Step 1: FTS5 discover on gnosys.db
     const fetchLimit = Math.max(limit * 2, 15);
-    const dbResults = db.discoverFts(query, fetchLimit);
+    let dbResults = db.discoverFts(query, fetchLimit);
+    if (pendingOverlay?.length) {
+        dbResults = mergeOverlayDiscoverResults(dbResults, pendingOverlay, query, fetchLimit, (p) => ({
+            id: p.id,
+            title: p.title,
+            relevance: "",
+            rank: 0,
+            project_id: p.project_id,
+        }));
+    }
     const allRanks = dbResults.map((r) => r.rank);
     for (const r of dbResults) {
-        const mem = db.getMemory(r.id);
+        let mem = db.getMemory(r.id);
+        if (!mem && pendingOverlay?.length) {
+            const pending = pendingOverlay.find((p) => p.id === r.id);
+            if (pending)
+                mem = pendingAddToDbMemory(pending);
+        }
         if (mem && mem.tier === "active" && mem.status === "active") {
             const relevanceScore = normalizeRank(r.rank, allRanks);
             memories.push({

package/dist/lib/recallCommand.d.ts

@@ -0,0 +1,11 @@
+export type RecallCommandOptions = {
+    limit?: string;
+    aggressive?: boolean;
+    traceId?: string;
+    json?: boolean;
+    host?: boolean;
+    federated?: boolean;
+    scope?: string;
+    directory?: string;
+};
+export declare function runRecallCommand(query: string, opts: RecallCommandOptions): Promise<void>;

package/dist/lib/recallCommand.js

@@ -0,0 +1,112 @@
+import { loadConfig } from "./config.js";
+import { GnosysResolver } from "./resolver.js";
+import { GnosysSearch } from "./search.js";
+export async function runRecallCommand(query, opts) {
+    // Federated recall path — returns tier-boosted results from central DB
+    if (opts.federated || opts.scope) {
+        const { resolveClientRead } = await import("./clientReadResolve.js");
+        const resolved = resolveClientRead();
+        if (!resolved) {
+            console.error("Central DB not available.");
+            process.exit(1);
+        }
+        try {
+            const { federatedSearch, detectCurrentProject } = await import("./federated.js");
+            const projectId = await detectCurrentProject(resolved.db, opts.directory || undefined);
+            const scopeFilter = opts.scope ? opts.scope.split(",").map(s => s.trim()) : undefined;
+            const limit = opts.limit ? parseInt(opts.limit, 10) : 10;
+            const results = federatedSearch(resolved.db, query, { limit, projectId, scopeFilter });
+            // Format as recall-like output with scope info
+            const recallResult = {
+                query,
+                projectId,
+                mode: "federated",
+                count: results.length,
+                memories: results.map(r => ({
+                    id: r.id,
+                    title: r.title,
+                    category: r.category,
+                    scope: r.scope,
+                    score: r.score,
+                    boosts: r.boosts,
+                    snippet: r.snippet,
+                    projectName: r.projectName,
+                })),
+            };
+            if (opts.json) {
+                console.log(JSON.stringify(recallResult, null, 2));
+            }
+            else if (opts.host) {
+                const lines = [`<gnosys-recall query="${query}" mode="federated" count="${results.length}">`];
+                for (const r of results) {
+                    lines.push(`  <memory id="${r.id}" scope="${r.scope}" score="${r.score.toFixed(4)}">`);
+                    lines.push(`    ${r.title}: ${r.snippet?.substring(0, 200) || ""}`);
+                    lines.push(`  </memory>`);
+                }
+                lines.push(`</gnosys-recall>`);
+                console.log(lines.join("\n"));
+            }
+            else {
+                if (results.length === 0) {
+                    console.log(`No memories found for "${query}".`);
+                }
+                else {
+                    console.log(`Recall: ${results.length} memories for "${query}" (federated)\n`);
+                    for (const r of results) {
+                        const proj = r.projectName ? ` [${r.projectName}]` : "";
+                        console.log(`  ${r.title}${proj} (${r.scope}, ${r.score.toFixed(4)})`);
+                        if (r.snippet)
+                            console.log(`    ${r.snippet.substring(0, 100)}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+        finally {
+            resolved.release();
+        }
+        return;
+    }
+    // Legacy file-based recall
+    const resolver = new GnosysResolver();
+    await resolver.resolve();
+    const stores = resolver.getStores();
+    if (stores.length === 0) {
+        console.error("No Gnosys stores found. Run 'gnosys init' first.");
+        process.exit(1);
+    }
+    const { recall, formatRecall, formatRecallCLI } = await import("./recall.js");
+    const { initAudit, closeAudit } = await import("./audit.js");
+    const storePath = stores[0].path;
+    initAudit(storePath);
+    // Load config for recall settings
+    const cfg = await loadConfig(storePath);
+    const recallConfig = {
+        ...cfg.recall,
+        ...(opts.aggressive !== undefined ? { aggressive: opts.aggressive } : {}),
+    };
+    // Build search index
+    const search = new GnosysSearch(storePath);
+    await search.addStoreMemories(stores[0].store);
+    const result = await recall(query, {
+        limit: opts.limit ? parseInt(opts.limit, 10) : undefined,
+        search,
+        resolver,
+        storePath,
+        traceId: opts.traceId,
+        recallConfig,
+    });
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (opts.host) {
+        console.log(formatRecall(result));
+    }
+    else {
+        console.log(formatRecallCLI(result));
+    }
+    closeAudit();
+}

package/dist/lib/reflectCommand.d.ts

@@ -0,0 +1,8 @@
+export type ReflectCommandOptions = {
+    memoryIds?: string;
+    failure?: boolean;
+    notes?: string;
+    confidenceDelta?: string;
+    json?: boolean;
+};
+export declare function runReflectCommand(outcome: string, opts: ReflectCommandOptions): Promise<void>;

package/dist/lib/reflectCommand.js

@@ -0,0 +1,61 @@
+export async function runReflectCommand(outcome, opts) {
+    let db;
+    try {
+        const { GnosysDB: GnosysDBClass } = await import("./db.js");
+        const { handleRequest } = await import("../sandbox/server.js");
+        const dbDir = GnosysDBClass.getCentralDbDir();
+        db = new GnosysDBClass(dbDir);
+        if (!db.isAvailable()) {
+            console.error("Error: GnosysDB not available. Install it with: npm install better-sqlite3");
+            process.exit(1);
+        }
+        const params = {
+            outcome,
+            success: !opts.failure,
+        };
+        if (opts.memoryIds)
+            params.memory_ids = opts.memoryIds.split(",").map((s) => s.trim());
+        if (opts.notes)
+            params.notes = opts.notes;
+        if (opts.confidenceDelta)
+            params.confidence_delta = parseFloat(opts.confidenceDelta);
+        const res = handleRequest(db, {
+            id: "cli-reflect",
+            method: "reflect",
+            params,
+        });
+        if (!res.ok) {
+            if (opts.json) {
+                console.log(JSON.stringify({ ok: false, error: res.error }));
+            }
+            else {
+                console.error(`Reflect failed: ${res.error}`);
+            }
+            process.exit(1);
+        }
+        const result = res.result;
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Reflection recorded:`);
+            console.log(`  ID:                    ${result.reflection_id}`);
+            console.log(`  Outcome:               ${result.outcome}`);
+            console.log(`  Memories updated:      ${result.memories_updated.length}`);
+            console.log(`  Relationships created: ${result.relationships_created}`);
+            console.log(`  Confidence delta:      ${result.confidence_delta > 0 ? "+" : ""}${result.confidence_delta.toFixed(2)}`);
+        }
+    }
+    catch (err) {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, error: err instanceof Error ? err.message : String(err) }));
+        }
+        else {
+            console.error(`Reflect failed: ${err instanceof Error ? err.message : err}`);
+        }
+        process.exit(1);
+    }
+    finally {
+        db?.close();
+    }
+}

package/dist/lib/reindexCommand.d.ts

@@ -0,0 +1,4 @@
+import type { GnosysResolver } from "./resolver.js";
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runReindexCommand(getResolver: GetResolver): Promise<void>;
+export {};

package/dist/lib/reindexCommand.js

@@ -0,0 +1,34 @@
+import { GnosysSearch } from "./search.js";
+export async function runReindexCommand(getResolver) {
+    let search;
+    let embeddings;
+    try {
+        const resolver = await getResolver();
+        const stores = resolver.getStores();
+        if (stores.length === 0) {
+            console.error("No stores found. Run gnosys init first.");
+            process.exitCode = 1;
+            return;
+        }
+        const storePath = stores[0].path;
+        search = new GnosysSearch(storePath);
+        search.clearIndex();
+        for (const s of stores) {
+            await search.addStoreMemories(s.store, s.label);
+        }
+        const { GnosysEmbeddings } = await import("./embeddings.js");
+        const { GnosysHybridSearch } = await import("./hybridSearch.js");
+        embeddings = new GnosysEmbeddings(storePath);
+        const hybridSearch = new GnosysHybridSearch(search, embeddings, resolver, storePath);
+        console.log("Building semantic embeddings (downloading model on first run)...");
+        const count = await hybridSearch.reindex((current, total, filePath) => {
+            process.stdout.write(`\r  Indexing: ${current}/${total} — ${filePath.substring(0, 60)}`);
+        });
+        console.log(`\n\nReindex complete: ${count} memories embedded.`);
+        console.log("Hybrid and semantic search are now available.");
+    }
+    finally {
+        search?.close();
+        embeddings?.close();
+    }
+}

package/dist/lib/reindexGraphCommand.d.ts

@@ -0,0 +1,4 @@
+import type { GnosysResolver } from "./resolver.js";
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runReindexGraphCommand(getResolver: GetResolver): Promise<void>;
+export {};

package/dist/lib/reindexGraphCommand.js

@@ -0,0 +1,12 @@
+export async function runReindexGraphCommand(getResolver) {
+    const { reindexGraph, formatGraphStats } = await import("./graph.js");
+    const resolver = await getResolver();
+    const stores = resolver.getStores();
+    if (stores.length === 0) {
+        console.error("No Gnosys stores found. Run gnosys init first.");
+        process.exit(1);
+    }
+    const stats = await reindexGraph(resolver, (msg) => console.log(msg));
+    console.log("");
+    console.log(formatGraphStats(stats));
+}

package/dist/lib/reinforceCommand.d.ts

@@ -0,0 +1,8 @@
+import type { GnosysResolver } from "./resolver.js";
+export type ReinforceCommandOptions = {
+    signal: string;
+    context?: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runReinforceCommand(getResolver: GetResolver, memoryId: string, opts: ReinforceCommandOptions): Promise<void>;
+export {};