gnosys 5.11.4 → 5.12.2

package/dist/lib/addCommand.d.ts

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

package/dist/lib/addCommand.js

@@ -0,0 +1,102 @@
+import path from "path";
+import { existsSync } from "fs";
+import { GnosysTagRegistry } from "./tags.js";
+import { GnosysDB } from "./db.js";
+export async function runAddCommand(getResolver, input, opts, resolveProjectId) {
+    const resolver = await getResolver();
+    const writeTarget = resolver.getWriteTarget(opts.store || undefined);
+    if (!writeTarget) {
+        console.error("No writable store found. Create a .gnosys/ directory or set GNOSYS_PERSONAL.");
+        process.exit(1);
+    }
+    // Check if input is a file path — if so, route through multimodal ingestion
+    if (existsSync(input)) {
+        const { ingestFile } = await import("./multimodalIngest.js");
+        const storePath = writeTarget.store.getStorePath();
+        console.log(`Detected file: ${input}`);
+        console.log("Ingesting via multimodal pipeline...");
+        const result = await ingestFile({
+            filePath: path.resolve(input),
+            storePath,
+            mode: "llm",
+            author: opts.author,
+            authority: opts.authority,
+            onProgress: (p) => {
+                console.log(`  [${p.current}/${p.total}] ${p.title || "Processing..."}`);
+            },
+        });
+        console.log(`\nFile type: ${result.fileType}`);
+        console.log(`Memories created: ${result.memories.length}`);
+        console.log(`Duration: ${(result.duration / 1000).toFixed(1)}s`);
+        for (const mem of result.memories) {
+            console.log(`  ${mem.id}: ${mem.title}`);
+        }
+        if (result.errors.length > 0) {
+            console.error(`\nErrors (${result.errors.length}):`);
+            for (const err of result.errors) {
+                console.error(`  Chunk ${err.chunk}: ${err.error}`);
+            }
+        }
+        return;
+    }
+    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);
+    }
+    console.log("Structuring memory via LLM...");
+    const result = await ingestion.ingest(input);
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        const projectId = await resolveProjectId();
+        const id = centralDb.getNextId(result.category, projectId || undefined);
+        const now = new Date().toISOString();
+        const content = `# ${result.title}\n\n${result.content}`;
+        const tags = result.tags;
+        const tagsJson = Array.isArray(tags)
+            ? JSON.stringify(tags)
+            : JSON.stringify(Object.values(tags).flat());
+        centralDb.insertMemory({
+            id,
+            title: result.title,
+            category: result.category,
+            content,
+            summary: null,
+            tags: tagsJson,
+            relevance: result.relevance,
+            author: opts.author,
+            authority: opts.authority,
+            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(`\nMemory added to [${writeTarget.label}]: ${result.title}`);
+        console.log(`ID: ${id}`);
+        console.log(`Category: ${result.category}`);
+        console.log(`Confidence: ${result.confidence}`);
+    }
+    finally {
+        centralDb?.close();
+    }
+    if (result.proposedNewTags && result.proposedNewTags.length > 0) {
+        console.log("\nProposed new tags (not yet in registry):");
+        for (const t of result.proposedNewTags) {
+            console.log(`  ${t.category}:${t.tag}`);
+        }
+    }
+}

package/dist/lib/addStructuredCommand.d.ts

@@ -0,0 +1,16 @@
+export type AddStructuredOptions = {
+    title: string;
+    category: string;
+    content: string;
+    tags: string;
+    relevance: string;
+    author: string;
+    authority: string;
+    confidence: string;
+    store?: string;
+    user?: boolean;
+    global?: boolean;
+};
+type ResolveProjectId = (dir?: string) => Promise<string | null>;
+export declare function runAddStructuredCommand(opts: AddStructuredOptions, resolveProjectId: ResolveProjectId): Promise<void>;
+export {};

package/dist/lib/addStructuredCommand.js

@@ -0,0 +1,103 @@
+import { GnosysDB } from "./db.js";
+export async function runAddStructuredCommand(opts, resolveProjectId) {
+    // ─── Phase 9b: --user / --global route through central DB ─────
+    if (opts.user || opts.global) {
+        let centralDb = null;
+        try {
+            centralDb = GnosysDB.openCentral();
+            if (!centralDb.isAvailable()) {
+                console.error("Central DB not available.");
+                process.exit(1);
+            }
+            const scope = opts.global ? "global" : "user";
+            const now = new Date().toISOString();
+            const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const projectId = opts.global ? null : await resolveProjectId();
+            centralDb.insertMemory({
+                id,
+                title: opts.title,
+                category: opts.category,
+                content: `# ${opts.title}\n\n${opts.content}`,
+                summary: null,
+                tags: opts.tags,
+                relevance: opts.relevance || opts.content.slice(0, 200),
+                author: opts.author,
+                authority: opts.authority,
+                confidence: parseFloat(opts.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,
+            });
+            console.log(`Memory added (scope: ${scope}): ${opts.title}`);
+            console.log(`ID: ${id}`);
+            return;
+        }
+        catch (err) {
+            console.error(`Error: ${err instanceof Error ? err.message : err}`);
+            process.exit(1);
+        }
+        finally {
+            centralDb?.close();
+        }
+    }
+    // ─── DB-only write ────────────────────────────────────────────
+    let tags;
+    try {
+        tags = JSON.parse(opts.tags);
+    }
+    catch {
+        console.error("Invalid --tags JSON. Example: '{\"domain\":[\"auth\"],\"type\":[\"decision\"]}'");
+        process.exit(1);
+    }
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        const projectId = await resolveProjectId();
+        const id = centralDb.getNextId(opts.category, projectId || undefined);
+        const now = new Date().toISOString();
+        const content = `# ${opts.title}\n\n${opts.content}`;
+        const tagsJson = Array.isArray(tags)
+            ? JSON.stringify(tags)
+            : JSON.stringify(Object.values(tags).flat());
+        centralDb.insertMemory({
+            id,
+            title: opts.title,
+            category: opts.category,
+            content,
+            summary: null,
+            tags: tagsJson,
+            relevance: opts.relevance || opts.content.slice(0, 200),
+            author: opts.author,
+            authority: opts.authority,
+            confidence: parseFloat(opts.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(`Memory added: ${opts.title}`);
+        console.log(`ID: ${id}`);
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/ambiguityCommand.d.ts

@@ -0,0 +1,4 @@
+export type AmbiguityCommandOptions = {
+    json: boolean;
+};
+export declare function runAmbiguityCommand(query: string, opts: AmbiguityCommandOptions): Promise<void>;

package/dist/lib/ambiguityCommand.js

@@ -0,0 +1,36 @@
+import { GnosysDB } from "./db.js";
+export async function runAmbiguityCommand(query, opts) {
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exitCode = 1;
+            return;
+        }
+        const { detectAmbiguity } = await import("./federated.js");
+        const ambiguity = detectAmbiguity(centralDb, query);
+        if (opts.json) {
+            console.log(JSON.stringify({ query, ambiguous: !!ambiguity, ...(ambiguity || {}) }, null, 2));
+        }
+        else if (!ambiguity) {
+            console.log(`No ambiguity for "${query}" — matches at most one project.`);
+        }
+        else {
+            console.log(ambiguity.message);
+            for (const c of ambiguity.candidates) {
+                console.log(`\n  ${c.projectName} (${c.projectId})`);
+                console.log(`    Dir: ${c.workingDirectory}`);
+                console.log(`    Matching memories: ${c.memoryCount}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`Error: ${err instanceof Error ? err.message : err}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/apiKeyVault.d.ts

@@ -0,0 +1,78 @@
+/**
+ * API key storage and resolution for Gnosys LLM providers.
+ *
+ * Keychain / env service names (also used as GNOSYS_*_KEY env vars):
+ *   - Global:    GNOSYS_GLOBAL_<PROVIDER>_KEY    (one key for all tasks using that provider)
+ *   - Provider:  GNOSYS_<PROVIDER>_KEY           (legacy default / fallback)
+ */
+import type { Interface as ReadlineInterface } from "readline/promises";
+import { type GnosysConfig, type LLMProviderName } from "./config.js";
+export type ApiKeyScope = "global" | "provider";
+export type RoutableTask = "structuring" | "synthesis" | "vision" | "transcription" | "chat";
+export type LlmTaskName = RoutableTask | "dream";
+export interface ApiKeyRequirement {
+    provider: LLMProviderName;
+    scope: ApiKeyScope;
+}
+export declare function providerNeedsApiKey(provider: string): boolean;
+/** Keychain service / env var name for a specific scope. */
+export declare function apiKeyServiceName(provider: LLMProviderName, scope: ApiKeyScope): string;
+/** Lookup order: global → provider default (legacy/generic via readFirstInChain). */
+export declare function apiKeyLookupChain(provider: LLMProviderName): string[];
+/** Read a secret directly from the secure store, ignoring env vars. */
+export declare function readSecureStoreSecret(service: string): string | undefined;
+/** Read a secret from env or secure store by service name. */
+export declare function readStoredSecret(service: string): string | undefined;
+export declare function detectKeyLocation(provider: string): {
+    found: boolean;
+    location: "keychain" | "env" | "dotenv" | "none";
+    serviceName?: string;
+    envVarName?: string;
+    lastFour?: string;
+};
+/** First non-empty secret in the lookup chain. */
+export declare function readFirstInChain(provider: LLMProviderName): string | undefined;
+/** Mask for display: first 4 + ellipsis + last 4 characters. */
+export declare function maskKeySnippet(key: string): string;
+/**
+ * Where a secret is stored (Keychain, env var name, gnosys.json, or .env file).
+ */
+export declare function detectSecretSource(service: string, legacyEnv?: string): string;
+export interface StoredKeySlot {
+    service: string;
+    scope: ApiKeyScope;
+    source: string;
+    /** Present only when a value exists at this slot */
+    preview?: string;
+}
+/**
+ * List every key slot for a provider that currently holds a value.
+ */
+export declare function listStoredKeySlots(config: GnosysConfig, provider: LLMProviderName): StoredKeySlot[];
+/** Delete a secret from Keychain / GNOME Keyring (not process env). */
+export declare function deleteStoredSecret(service: string): boolean;
+/** Resolve API key for a provider. */
+export declare function getApiKeyForProviderFromConfig(config: GnosysConfig, provider: LLMProviderName): string | undefined;
+export declare function writeApiKeyToKeychain(service: string, key: string): boolean;
+export declare function writeApiKeyToSecretTool(service: string, key: string, label: string): boolean;
+export declare function storeApiKeySecret(service: string, key: string, provider: string): boolean;
+/**
+ * Build key requirements from effective routing — one global key per cloud provider in use.
+ */
+export declare function buildApiKeyRequirementsFromConfig(config: GnosysConfig): ApiKeyRequirement[];
+/**
+ * Prompt for missing keys and store in Keychain / GNOME Keyring.
+ */
+export declare function ensureApiKeys(rl: ReadlineInterface, requirements: ApiKeyRequirement[], askInput: (rl: ReadlineInterface, prompt: string) => Promise<string>, opts?: {
+    maskKey?: (key: string) => string;
+    warn?: string;
+    check?: string;
+    cross?: string;
+    dim?: string;
+    reset?: string;
+}): Promise<number>;
+/** Effective routing map used for key collection. */
+export declare function buildEffectiveRouting(config: GnosysConfig): Record<string, {
+    provider: LLMProviderName;
+    model: string;
+}>;