gnosys 5.11.4 → 5.12.0

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";

package/dist/lib/lensing.js

@@ -8,37 +8,33 @@
  * Apply a single lens filter to an array of memories.
  */
 export function applyLens(memories, lens) {
-    return memories.filter((m) => matchesLens(m, lens));
+    return memories.filter((m) => (lens.operator ?? "AND") === "OR"
+        ? matchesAnyLensCriterion(m, lens)
+        : matchesLens(m, lens));
 }
 /**
- * Check if a single memory matches a lens filter.
+ * Check if a single memory matches a lens filter (AND semantics).
  */
 function matchesLens(m, lens) {
     const fm = m.frontmatter;
-    // Category filter
     if (lens.category && fm.category !== lens.category)
         return false;
-    // Status filter (array — memory must match one of the listed statuses)
     if (lens.status && lens.status.length > 0) {
         if (!lens.status.includes(fm.status))
             return false;
     }
-    // Author filter
     if (lens.author && lens.author.length > 0) {
         if (!lens.author.includes(fm.author))
             return false;
     }
-    // Authority filter
     if (lens.authority && lens.authority.length > 0) {
         if (!lens.authority.includes(fm.authority))
             return false;
     }
-    // Confidence range
     if (lens.minConfidence !== undefined && fm.confidence < lens.minConfidence)
         return false;
     if (lens.maxConfidence !== undefined && fm.confidence > lens.maxConfidence)
         return false;
-    // Tag matching
     if (lens.tags && lens.tags.length > 0) {
         const memTags = flattenTags(fm.tags);
         const mode = lens.tagMatchMode ?? "any";
@@ -48,7 +44,6 @@ function matchesLens(m, lens) {
         if (mode === "any" && matches.length === 0)
             return false;
     }
-    // Date filters
     if (lens.createdAfter && fm.created < lens.createdAfter)
         return false;
     if (lens.createdBefore && fm.created > lens.createdBefore)
@@ -59,6 +54,52 @@ function matchesLens(m, lens) {
         return false;
     return true;
 }
+/**
+ * Check if a memory matches any active lens criterion (OR semantics).
+ */
+function matchesAnyLensCriterion(m, lens) {
+    const fm = m.frontmatter;
+    const checks = [];
+    if (lens.category) {
+        checks.push(fm.category === lens.category);
+    }
+    if (lens.status && lens.status.length > 0) {
+        checks.push(lens.status.includes(fm.status));
+    }
+    if (lens.author && lens.author.length > 0) {
+        checks.push(lens.author.includes(fm.author));
+    }
+    if (lens.authority && lens.authority.length > 0) {
+        checks.push(lens.authority.includes(fm.authority));
+    }
+    if (lens.minConfidence !== undefined) {
+        checks.push(fm.confidence >= lens.minConfidence);
+    }
+    if (lens.maxConfidence !== undefined) {
+        checks.push(fm.confidence <= lens.maxConfidence);
+    }
+    if (lens.tags && lens.tags.length > 0) {
+        const memTags = flattenTags(fm.tags);
+        const mode = lens.tagMatchMode ?? "any";
+        const matches = lens.tags.filter((t) => memTags.includes(t));
+        checks.push(mode === "all" ? matches.length === lens.tags.length : matches.length > 0);
+    }
+    if (lens.createdAfter) {
+        checks.push(fm.created >= lens.createdAfter);
+    }
+    if (lens.createdBefore) {
+        checks.push(fm.created <= lens.createdBefore);
+    }
+    if (lens.modifiedAfter) {
+        checks.push(fm.modified >= lens.modifiedAfter);
+    }
+    if (lens.modifiedBefore) {
+        checks.push(fm.modified <= lens.modifiedBefore);
+    }
+    if (checks.length === 0)
+        return true;
+    return checks.some(Boolean);
+}
 /**
  * Flatten tags from either format to a simple string array.
  */

package/dist/lib/linksCommand.d.ts

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

package/dist/lib/linksCommand.js

@@ -0,0 +1,48 @@
+import { getBacklinks, getOutgoingLinks } from "./wikilinks.js";
+function outputResult(json, data, humanFn) {
+    if (json) {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        humanFn();
+    }
+}
+export async function runLinksCommand(getResolver, memoryPath, opts) {
+    const resolver = await getResolver();
+    const memory = await resolver.readMemory(memoryPath);
+    if (!memory) {
+        console.error(`Memory not found: ${memoryPath}`);
+        process.exit(1);
+    }
+    const allMemories = await resolver.getAllMemories();
+    const outgoing = getOutgoingLinks(allMemories, memory.relativePath);
+    const backlinks = getBacklinks(allMemories, memory.relativePath);
+    outputResult(!!opts.json, {
+        memoryPath,
+        title: memory.frontmatter.title,
+        outgoing,
+        backlinks,
+    }, () => {
+        console.log(`Links for ${memory.frontmatter.title}:\n`);
+        if (outgoing.length > 0) {
+            console.log(`  Outgoing (${outgoing.length}):`);
+            for (const link of outgoing) {
+                const display = link.displayText ? ` (${link.displayText})` : "";
+                console.log(`    → [[${link.target}]]${display}`);
+            }
+        }
+        else {
+            console.log("  No outgoing links.");
+        }
+        console.log();
+        if (backlinks.length > 0) {
+            console.log(`  Backlinks (${backlinks.length}):`);
+            for (const link of backlinks) {
+                console.log(`    ← ${link.sourceTitle} (${link.sourcePath})`);
+            }
+        }
+        else {
+            console.log("  No backlinks.");
+        }
+    });
+}

package/dist/lib/listCommand.d.ts

@@ -0,0 +1,8 @@
+export type ListCommandOptions = {
+    category?: string;
+    tag?: string;
+    store?: string;
+    json?: boolean;
+    idFormat?: string;
+};
+export declare function runListCommand(opts: ListCommandOptions): Promise<void>;