gnosys 5.11.4 → 5.12.2

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,76 @@
+/**
+ * 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,
+        attachment_data: null,
+        attachment_mime: null,
+        attachment_name: 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 {};

package/dist/lib/commitContextCommand.js

@@ -0,0 +1,142 @@
+import { GnosysTagRegistry } from "./tags.js";
+import { GnosysSearch } from "./search.js";
+import { loadConfig } from "./config.js";
+import { getLLMProvider } from "./llm.js";
+import { GnosysDB } from "./db.js";
+export async function runCommitContextCommand(getResolver, resolveProjectId, context, opts) {
+    const resolver = await getResolver();
+    const writeTarget = resolver.getWriteTarget(opts.store || undefined);
+    if (!writeTarget) {
+        console.error("No writable store found.");
+        process.exit(1);
+    }
+    const tagRegistry = new GnosysTagRegistry(writeTarget.store.getStorePath());
+    await tagRegistry.load();
+    const { GnosysIngestion } = await import("./ingest.js");
+    const ingestion = new GnosysIngestion(writeTarget.store, tagRegistry);
+    if (!ingestion.isLLMAvailable) {
+        console.error("Error: No LLM provider available. Add an API key to ~/.config/gnosys/.env or use a local model: gnosys config set provider ollama");
+        process.exit(1);
+    }
+    // Build search index
+    const stores = resolver.getStores();
+    const search = new GnosysSearch(stores[0].path);
+    search.clearIndex();
+    for (const s of stores) {
+        await search.addStoreMemories(s.store, s.label);
+    }
+    // Step 1: Extract candidates via LLM abstraction
+    console.log("Extracting knowledge candidates from context...");
+    // Load config for the write target store
+    const ccConfig = await loadConfig(writeTarget.store.getStorePath());
+    let extractProvider;
+    try {
+        extractProvider = getLLMProvider(ccConfig, "structuring");
+    }
+    catch (err) {
+        console.error(`LLM not available: ${err instanceof Error ? err.message : String(err)}`);
+        search.close();
+        process.exit(1);
+    }
+    const extractText = await extractProvider.generate(`Extract atomic knowledge items from this context:\n\n${context}`, {
+        system: `You extract atomic knowledge items from conversations. Each item should be ONE decision, fact, insight, or observation — not compound.
+  
+  Output a JSON array of objects, each with:
+  - summary: One-sentence description of the knowledge
+  - type: "decision" | "insight" | "fact" | "observation" | "requirement"
+  - search_terms: 3-5 keywords someone would search for to find if this already exists
+  
+  Be selective. Only extract things worth remembering long-term. Skip small talk, debugging steps, and transient details. Focus on decisions made, architecture choices, requirements established, and insights gained.
+  
+  Output ONLY the JSON array, no markdown fences.`,
+        maxTokens: 4000,
+    });
+    let candidates;
+    try {
+        const jsonMatch = extractText.match(/```json\s*([\s\S]*?)```/) ||
+            extractText.match(/```\s*([\s\S]*?)```/) || [null, extractText];
+        candidates = JSON.parse(jsonMatch[1] || extractText);
+    }
+    catch {
+        console.error("Failed to extract candidates — LLM output was not valid JSON.");
+        search.close();
+        process.exit(1);
+    }
+    if (!Array.isArray(candidates) || candidates.length === 0) {
+        console.log("No extractable knowledge found in the provided context.");
+        search.close();
+        return;
+    }
+    console.log(`Found ${candidates.length} candidates. Checking novelty...\n`);
+    // Step 2: Check novelty and commit
+    let added = 0;
+    let skipped = 0;
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        const projectId = await resolveProjectId();
+        for (const candidate of candidates) {
+            const searchTerms = candidate.search_terms.join(" ");
+            const existing = search.discover(searchTerms, 3);
+            if (existing.length > 0) {
+                console.log(`  ⏭ SKIP: "${candidate.summary}"`);
+                console.log(`    Overlaps with: ${existing[0].title}`);
+                skipped++;
+            }
+            else if (opts.dryRun) {
+                console.log(`  ➕ WOULD ADD: "${candidate.summary}" [${candidate.type}]`);
+                added++;
+            }
+            else {
+                try {
+                    const result = await ingestion.ingest(candidate.summary);
+                    const id = centralDb.getNextId(result.category, projectId || undefined);
+                    const now = new Date().toISOString();
+                    const content = `# ${result.title}\n\n${result.content}`;
+                    const resultTags = result.tags;
+                    const tagsJson = Array.isArray(resultTags)
+                        ? JSON.stringify(resultTags)
+                        : JSON.stringify(Object.values(resultTags).flat());
+                    centralDb.insertMemory({
+                        id,
+                        title: result.title,
+                        category: result.category,
+                        content,
+                        summary: null,
+                        tags: tagsJson,
+                        relevance: result.relevance,
+                        author: "ai",
+                        authority: "observed",
+                        confidence: result.confidence,
+                        reinforcement_count: 0,
+                        content_hash: "",
+                        status: "active",
+                        tier: "active",
+                        supersedes: null,
+                        superseded_by: null,
+                        last_reinforced: null,
+                        created: now,
+                        modified: now,
+                        embedding: null,
+                        source_path: null,
+                        project_id: projectId,
+                        scope: "project",
+                    });
+                    console.log(`  ➕ ADDED: "${result.title}"`);
+                    console.log(`    ID: ${id}`);
+                    added++;
+                }
+                catch (err) {
+                    console.error(`  ❌ FAILED: "${candidate.summary}": ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            console.log();
+        }
+    }
+    finally {
+        centralDb?.close();
+    }
+    search.close();
+    const mode = opts.dryRun ? "DRY RUN" : "COMMITTED";
+    console.log(`\n${mode}: ${candidates.length} candidates, ${added} ${opts.dryRun ? "would be added" : "added"}, ${skipped} duplicates skipped.`);
+}