gnosys 5.11.3 → 5.12.0

package/dist/lib/ideMcpInstall.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared stdio MCP install helpers for IDE setup (`gnosys setup ides`).
+ */
+/** IDE keys handled by `setupIDE()`. */
+export declare const SUPPORTED_IDE_KEYS: readonly ["claude", "claude-desktop", "cursor", "codex", "gemini-cli", "antigravity", "grok-build"];
+export type SupportedIde = (typeof SUPPORTED_IDE_KEYS)[number];
+/** User-facing aliases → canonical IDE key. */
+export declare const IDE_ALIASES: Record<string, SupportedIde>;
+export declare function normalizeIdeKey(ide: string): SupportedIde | null;
+/** Absolute path to `gnosys-mcp` when on PATH, else bare name. */
+export declare function resolveGnosysMcpCommand(): string;
+export declare function gnosysStdioMcpEntry(): {
+    command: string;
+    args: string[];
+};
+/** True when an existing JSON MCP entry still points at broken `gnosys serve`. */
+export declare function isStaleGnosysMcpEntry(entry: unknown): boolean;
+/** Merge (or replace) the gnosys stdio entry in a JSON MCP config file. */
+export declare function installStdioMcpJson(file: string): Promise<void>;
+/** Project + user-global Cursor MCP paths. */
+export declare function cursorMcpPaths(projectDir: string): {
+    project: string;
+    user: string;
+};
+/** Run a CLI with argv (safe for paths containing spaces). */
+export declare function runCli(command: string, args: string[], opts?: {
+    allowFailure?: boolean;
+}): string;
+/** Remove a `[section]` block from hand-rolled TOML text. */
+export declare function removeTomlSection(existing: string, sectionHeader: string): string;

package/dist/lib/ideMcpInstall.js

@@ -0,0 +1,102 @@
+/**
+ * Shared stdio MCP install helpers for IDE setup (`gnosys setup ides`).
+ */
+import { execFileSync, execSync } from "child_process";
+import path from "path";
+import os from "os";
+import { mergeJsonMcpServer } from "./mcpClientConfig.js";
+/** IDE keys handled by `setupIDE()`. */
+export const SUPPORTED_IDE_KEYS = [
+    "claude",
+    "claude-desktop",
+    "cursor",
+    "codex",
+    "gemini-cli",
+    "antigravity",
+    "grok-build",
+];
+/** User-facing aliases → canonical IDE key. */
+export const IDE_ALIASES = {
+    grok: "grok-build",
+    "grok-build": "grok-build",
+};
+export function normalizeIdeKey(ide) {
+    const key = ide.toLowerCase();
+    if (SUPPORTED_IDE_KEYS.includes(key)) {
+        return key;
+    }
+    return IDE_ALIASES[key] ?? null;
+}
+/** Absolute path to `gnosys-mcp` when on PATH, else bare name. */
+export function resolveGnosysMcpCommand() {
+    try {
+        const p = execSync("command -v gnosys-mcp", { encoding: "utf-8" }).trim();
+        if (p)
+            return p;
+    }
+    catch {
+        // Fall back to bare name on PATH.
+    }
+    return "gnosys-mcp";
+}
+export function gnosysStdioMcpEntry() {
+    return { command: resolveGnosysMcpCommand(), args: [] };
+}
+/** True when an existing JSON MCP entry still points at broken `gnosys serve`. */
+export function isStaleGnosysMcpEntry(entry) {
+    if (!entry || typeof entry !== "object")
+        return false;
+    const e = entry;
+    const cmd = String(e.command ?? "");
+    const args = Array.isArray(e.args) ? e.args.map(String) : [];
+    if (cmd.includes("gnosys-mcp"))
+        return false;
+    if (cmd.endsWith("/gnosys") || cmd === "gnosys") {
+        return args.includes("serve") || args.length === 0;
+    }
+    return false;
+}
+/** Merge (or replace) the gnosys stdio entry in a JSON MCP config file. */
+export async function installStdioMcpJson(file) {
+    await mergeJsonMcpServer(file, gnosysStdioMcpEntry());
+}
+/** Project + user-global Cursor MCP paths. */
+export function cursorMcpPaths(projectDir) {
+    return {
+        project: path.join(projectDir, ".cursor", "mcp.json"),
+        user: path.join(os.homedir(), ".cursor", "mcp.json"),
+    };
+}
+/** Run a CLI with argv (safe for paths containing spaces). */
+export function runCli(command, args, opts) {
+    try {
+        return execFileSync(command, args, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        if (opts?.allowFailure) {
+            return err instanceof Error && "stdout" in err ? String(err.stdout ?? "") : "";
+        }
+        throw err;
+    }
+}
+/** Remove a `[section]` block from hand-rolled TOML text. */
+export function removeTomlSection(existing, sectionHeader) {
+    const lines = existing.split("\n");
+    const headerIdx = lines.findIndex((line) => line.trim() === sectionHeader);
+    if (headerIdx === -1)
+        return existing;
+    let endIdx = lines.length;
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        if (/^\s*\[/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, headerIdx).join("\n");
+    const after = lines.slice(endIdx).join("\n");
+    const merged = [before, after].filter((s) => s.length > 0).join("\n");
+    return merged.length > 0 ? `${merged.replace(/\n{3,}/g, "\n\n")}\n` : "";
+}

package/dist/lib/importCommand.d.ts

@@ -0,0 +1,16 @@
+import type { GnosysResolver } from "./resolver.js";
+export type ImportCommandOptions = {
+    format?: string;
+    mapping?: string;
+    mode: string;
+    limit?: number;
+    offset?: number;
+    skipExisting?: boolean;
+    batchCommit: boolean;
+    concurrency?: number;
+    dryRun?: boolean;
+    store: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runImportCommand(getResolver: GetResolver, fileOrUrl: string | undefined, opts: ImportCommandOptions): Promise<void>;
+export {};

package/dist/lib/importCommand.js

@@ -0,0 +1,89 @@
+import { GnosysTagRegistry } from "./tags.js";
+export async function runImportCommand(getResolver, fileOrUrl, opts) {
+    if (!fileOrUrl) {
+        console.error("Usage:");
+        console.error("  gnosys import <file> --format csv|json|jsonl --mapping '{...}'   (bulk)");
+        console.error("  gnosys import project <bundle.json.gz>                            (project bundle)");
+        process.exit(1);
+    }
+    if (!opts.format || !opts.mapping) {
+        console.error("Error: --format and --mapping are required for bulk imports.");
+        console.error("       For project bundles, use 'gnosys import project <bundle>'.");
+        process.exit(1);
+    }
+    // Parse mapping JSON
+    let mapping;
+    try {
+        mapping = JSON.parse(opts.mapping);
+    }
+    catch {
+        console.error("Error: --mapping must be valid JSON. Example: '{\"name\":\"title\",\"group\":\"category\"}'");
+        process.exit(1);
+    }
+    const resolver = await getResolver();
+    const writeTarget = resolver.getWriteTarget(opts.store);
+    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 { performImport, formatImportSummary } = await import("./import.js");
+    const ingestion = new GnosysIngestion(writeTarget.store, tagRegistry);
+    const format = opts.format;
+    const mode = opts.mode;
+    const concurrency = opts.concurrency || 5;
+    // Show estimate for LLM mode
+    if (mode === "llm") {
+        console.error(`Mode: LLM (concurrency: ${concurrency})`);
+    }
+    else {
+        console.error("Mode: structured (no LLM calls)");
+    }
+    if (opts.dryRun) {
+        console.error("DRY RUN — no files will be written\n");
+    }
+    // Progress tracking
+    let lastLine = "";
+    const onProgress = (p) => {
+        const pct = p.total > 0 ? Math.round((p.processed / p.total) * 100) : 0;
+        const bar = "█".repeat(Math.floor(pct / 5)) +
+            "░".repeat(20 - Math.floor(pct / 5));
+        const line = `[${bar}] ${p.processed}/${p.total} | ${p.current.substring(0, 40)}`;
+        if (line !== lastLine) {
+            process.stderr.write(`\r${line}`);
+            lastLine = line;
+        }
+    };
+    try {
+        const result = await performImport(writeTarget.store, ingestion, {
+            format,
+            data: fileOrUrl,
+            mapping,
+            mode,
+            limit: opts.limit,
+            offset: opts.offset,
+            dryRun: opts.dryRun,
+            skipExisting: opts.skipExisting,
+            batchCommit: opts.batchCommit,
+            concurrency,
+            onProgress,
+        });
+        // Clear progress line
+        process.stderr.write("\r" + " ".repeat(80) + "\r");
+        // Reindex search after import
+        if (!opts.dryRun && result.imported.length > 0) {
+            const search = new (await import("./search.js")).GnosysSearch(writeTarget.store.getStorePath());
+            for (const s of resolver.getStores()) {
+                await search.addStoreMemories(s.store, s.label);
+            }
+        }
+        console.log((opts.dryRun ? "DRY RUN — " : "✓ ") +
+            formatImportSummary(result));
+    }
+    catch (err) {
+        console.error(`\nImport failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}

package/dist/lib/importProjectCommand.d.ts

@@ -0,0 +1,6 @@
+export type ImportProjectCommandOptions = {
+    strategy: string;
+    workingDirectory?: string;
+    json?: boolean;
+};
+export declare function runImportProjectCommand(bundlePath: string, opts: ImportProjectCommandOptions): Promise<void>;

package/dist/lib/importProjectCommand.js

@@ -0,0 +1,43 @@
+import path from "path";
+const validStrategies = ["merge", "replace", "new-id"];
+export async function runImportProjectCommand(bundlePath, opts) {
+    if (!validStrategies.includes(opts.strategy)) {
+        console.error(`Invalid strategy: ${opts.strategy}. Use one of: ${validStrategies.join(", ")}`);
+        process.exitCode = 1;
+        return;
+    }
+    let centralDb = null;
+    try {
+        const { GnosysDB: DbClass } = await import("./db.js");
+        const { importProject } = await import("./importProject.js");
+        centralDb = DbClass.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB unavailable.");
+            process.exitCode = 1;
+            return;
+        }
+        const result = importProject(centralDb, {
+            bundlePath: path.resolve(bundlePath),
+            strategy: opts.strategy,
+            workingDirectoryOverride: opts.workingDirectory,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(`Imported project ${result.projectName} (${result.projectId})`);
+            console.log(`  Strategy:        ${result.strategy}`);
+            console.log(`  Memories:        ${result.memoriesInserted} inserted, ${result.memoriesSkipped} skipped, ${result.memoriesReplaced} replaced`);
+            console.log(`  Relationships:   ${result.relationshipsInserted}`);
+            console.log(`  Audit entries:   ${result.auditEntriesInserted}`);
+        }
+    }
+    catch (err) {
+        console.error(`Import failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+        return;
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/ingestCommand.d.ts

@@ -0,0 +1,13 @@
+import type { GnosysResolver } from "./resolver.js";
+export type IngestCommandOptions = {
+    mode: string;
+    store?: string;
+    author: string;
+    authority: string;
+    dryRun?: boolean;
+    listAttachments?: boolean;
+    directory?: string;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runIngestCommand(getResolver: GetResolver, fileOrGlob: string, opts: IngestCommandOptions): Promise<void>;
+export {};

package/dist/lib/ingestCommand.js

@@ -0,0 +1,95 @@
+import path from "path";
+import fs from "fs/promises";
+export async function runIngestCommand(getResolver, fileOrGlob, opts) {
+    // List attachments mode
+    if (opts.listAttachments) {
+        const { listAttachments } = await import("./attachments.js");
+        const resolver = await getResolver();
+        const writeTarget = resolver.getWriteTarget(opts.store || undefined);
+        if (!writeTarget) {
+            console.error("No writable store found.");
+            process.exit(1);
+        }
+        const attachments = await listAttachments(writeTarget.store.getStorePath());
+        if (attachments.length === 0) {
+            console.log("No attachments found.");
+            return;
+        }
+        console.log(`Found ${attachments.length} attachment(s):\n`);
+        for (const a of attachments) {
+            const sizeMb = (a.sizeBytes / (1024 * 1024)).toFixed(2);
+            console.log(`  ${a.originalName} (${sizeMb}MB, ${a.extension})`);
+            console.log(`    UUID: ${a.uuid}`);
+            console.log(`    Hash: ${a.contentHash.slice(0, 16)}...`);
+            console.log(`    Memories: ${a.memoryIds.length > 0 ? a.memoryIds.join(", ") : "none"}`);
+            console.log(`    Created: ${a.createdAt}\n`);
+        }
+        return;
+    }
+    // Resolve the file path
+    const resolvedPath = path.resolve(opts.directory || process.cwd(), fileOrGlob);
+    // Check the file exists
+    try {
+        await fs.access(resolvedPath);
+    }
+    catch {
+        console.error(`File not found: ${resolvedPath}`);
+        process.exit(1);
+    }
+    // Resolve the store
+    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);
+    }
+    const storePath = writeTarget.store.getStorePath();
+    // Run ingestion
+    const { ingestFile } = await import("./multimodalIngest.js");
+    console.log(`Ingesting: ${path.basename(resolvedPath)}`);
+    if (opts.dryRun) {
+        console.log("(dry run — no files will be written)\n");
+    }
+    try {
+        const result = await ingestFile({
+            filePath: resolvedPath,
+            storePath,
+            mode: opts.mode,
+            store: opts.store || undefined,
+            author: opts.author,
+            authority: opts.authority,
+            dryRun: opts.dryRun,
+            projectRoot: opts.directory,
+            onProgress: (p) => {
+                process.stdout.write(`\r  Processing chunk ${p.current}/${p.total}...`);
+            },
+        });
+        // Clear the progress line
+        if (result.memories.length > 0) {
+            process.stdout.write("\r" + " ".repeat(60) + "\r");
+        }
+        // Print results
+        console.log(`\nFile type: ${result.fileType}`);
+        console.log(`Attachment: ${result.attachment.originalName} (${result.attachment.uuid.slice(0, 8)}...)`);
+        console.log(`Duration: ${(result.duration / 1000).toFixed(1)}s`);
+        console.log(`Memories created: ${result.memories.length}`);
+        if (result.memories.length > 0) {
+            console.log("\nMemories:");
+            for (const m of result.memories) {
+                const extra = m.page ? ` [page ${m.page}]` : "";
+                console.log(`  ${m.id}: ${m.title}${extra}`);
+                console.log(`    Path: ${m.path}`);
+            }
+        }
+        if (result.errors.length > 0) {
+            console.log(`\nErrors (${result.errors.length}):`);
+            for (const e of result.errors) {
+                console.log(`  Chunk ${e.chunk}: ${e.error}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error(`\nIngestion failed: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}

package/dist/lib/installOutput.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Filter for the npm output that `gnosys upgrade` streams to the user.
+ *
+ * `npm install -g gnosys@latest` prints two deprecation warnings that we can
+ * do nothing about and that are harmless:
+ *
+ *   npm warn deprecated prebuild-install@7.1.3: No longer maintained ...
+ *   npm warn deprecated boolean@3.2.0: Package no longer supported ...
+ *
+ * Both come from OPTIONAL native dependencies, and both packages are deprecated
+ * at their latest published version with no non-deprecated successor:
+ *   - prebuild-install  ← better-sqlite3 (the SQLite engine; even the newest
+ *                         better-sqlite3 still depends on prebuild-install)
+ *   - boolean           ← global-agent ← onnxruntime-node ← @huggingface/transformers
+ *
+ * Since there's no version we can move to, we strip exactly these two lines
+ * from the upgrade output so it stays clean. We deliberately match the specific
+ * package names: any OTHER deprecation (a genuinely new one we'd want to act
+ * on) still passes through untouched.
+ */
+/** Transitive packages whose deprecation warning we knowingly suppress. */
+export declare const SUPPRESSED_DEPRECATED_PACKAGES: string[];
+/** True if `line` is one of the known-benign npm deprecation warnings. */
+export declare function isSuppressedNpmLine(line: string): boolean;
+export interface NpmStderrFilter {
+    /** Feed a raw stderr chunk; complete non-suppressed lines are written out. */
+    feed(chunk: string): void;
+    /** Flush any trailing partial line at process end. */
+    end(): void;
+}
+/**
+ * Line-buffered stderr filter. npm streams warnings as it resolves the tree, so
+ * we buffer partial lines across chunks, drop the suppressed ones, and forward
+ * everything else immediately (no waiting for the whole install to finish).
+ */
+export declare function makeNpmStderrFilter(write: (text: string) => void): NpmStderrFilter;

package/dist/lib/installOutput.js

@@ -0,0 +1,55 @@
+/**
+ * Filter for the npm output that `gnosys upgrade` streams to the user.
+ *
+ * `npm install -g gnosys@latest` prints two deprecation warnings that we can
+ * do nothing about and that are harmless:
+ *
+ *   npm warn deprecated prebuild-install@7.1.3: No longer maintained ...
+ *   npm warn deprecated boolean@3.2.0: Package no longer supported ...
+ *
+ * Both come from OPTIONAL native dependencies, and both packages are deprecated
+ * at their latest published version with no non-deprecated successor:
+ *   - prebuild-install  ← better-sqlite3 (the SQLite engine; even the newest
+ *                         better-sqlite3 still depends on prebuild-install)
+ *   - boolean           ← global-agent ← onnxruntime-node ← @huggingface/transformers
+ *
+ * Since there's no version we can move to, we strip exactly these two lines
+ * from the upgrade output so it stays clean. We deliberately match the specific
+ * package names: any OTHER deprecation (a genuinely new one we'd want to act
+ * on) still passes through untouched.
+ */
+/** Transitive packages whose deprecation warning we knowingly suppress. */
+export const SUPPRESSED_DEPRECATED_PACKAGES = ["prebuild-install", "boolean"];
+/** True if `line` is one of the known-benign npm deprecation warnings. */
+export function isSuppressedNpmLine(line) {
+    if (!/npm warn deprecated/i.test(line))
+        return false;
+    return SUPPRESSED_DEPRECATED_PACKAGES.some((pkg) => line.includes(`deprecated ${pkg}@`));
+}
+/**
+ * Line-buffered stderr filter. npm streams warnings as it resolves the tree, so
+ * we buffer partial lines across chunks, drop the suppressed ones, and forward
+ * everything else immediately (no waiting for the whole install to finish).
+ */
+export function makeNpmStderrFilter(write) {
+    let leftover = "";
+    return {
+        feed(chunk) {
+            leftover += chunk;
+            const lines = leftover.split("\n");
+            // The last element is an incomplete line (no trailing newline yet).
+            leftover = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!isSuppressedNpmLine(line))
+                    write(`${line}\n`);
+            }
+        },
+        end() {
+            if (leftover.length > 0) {
+                if (!isSuppressedNpmLine(leftover))
+                    write(leftover);
+                leftover = "";
+            }
+        },
+    };
+}

package/dist/lib/lensCommand.d.ts

@@ -0,0 +1,20 @@
+import type { GnosysResolver } from "./resolver.js";
+export type LensCommandOptions = {
+    category?: string;
+    tag?: string[];
+    match: string;
+    status?: string[];
+    author?: string[];
+    authority?: string[];
+    minConfidence?: string;
+    maxConfidence?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+    modifiedAfter?: string;
+    modifiedBefore?: string;
+    or?: boolean;
+    json?: boolean;
+};
+type GetResolver = () => Promise<GnosysResolver>;
+export declare function runLensCommand(getResolver: GetResolver, opts: LensCommandOptions): Promise<void>;
+export {};

package/dist/lib/lensCommand.js

@@ -0,0 +1,61 @@
+import { applyLens } from "./lensing.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runLensCommand(getResolver, opts) {
+    const resolver = await getResolver();
+    const allMemories = await resolver.getAllMemories();
+    const lens = {};
+    if (opts.or)
+        lens.operator = "OR";
+    if (opts.category)
+        lens.category = opts.category;
+    if (opts.tag) {
+        lens.tags = opts.tag;
+        lens.tagMatchMode = opts.match;
+    }
+    if (opts.status)
+        lens.status = opts.status;
+    if (opts.author)
+        lens.author = opts.author;
+    if (opts.authority)
+        lens.authority = opts.authority;
+    if (opts.minConfidence)
+        lens.minConfidence = parseFloat(opts.minConfidence);
+    if (opts.maxConfidence)
+        lens.maxConfidence = parseFloat(opts.maxConfidence);
+    if (opts.createdAfter)
+        lens.createdAfter = opts.createdAfter;
+    if (opts.createdBefore)
+        lens.createdBefore = opts.createdBefore;
+    if (opts.modifiedAfter)
+        lens.modifiedAfter = opts.modifiedAfter;
+    if (opts.modifiedBefore)
+        lens.modifiedBefore = opts.modifiedBefore;
+    const result = applyLens(allMemories, lens);
+    const items = result.map((m) => ({
+        title: m.frontmatter.title,
+        status: m.frontmatter.status,
+        confidence: m.frontmatter.confidence,
+        sourceLabel: m.sourceLabel || "",
+        relativePath: m.relativePath,
+    }));
+    outputResult(!!opts.json, { count: items.length, items }, () => {
+        if (result.length === 0) {
+            console.log("No memories match the lens filter.");
+            return;
+        }
+        console.log(`${result.length} memories match:\n`);
+        for (const m of result) {
+            const src = m.sourceLabel || "";
+            console.log(`  [${m.frontmatter.status}] ${m.frontmatter.title} (${m.frontmatter.confidence})`);
+            console.log(`    ${src ? src + ":" : ""}${m.relativePath}`);
+            console.log();
+        }
+    });
+}

package/dist/lib/lensing.d.ts

@@ -6,6 +6,7 @@
  */
 import type { Memory } from "./store.js";
 export interface LensFilter {
+    operator?: "AND" | "OR";
     category?: string;
     tags?: string[];
     tagMatchMode?: "any" | "all";