gnosys 5.11.3 → 5.12.0

package/dist/lib/maintainCommand.js

@@ -0,0 +1,34 @@
+import { loadConfig } from "./config.js";
+export async function runMaintainCommand(getResolver, opts) {
+    const { GnosysMaintenanceEngine, formatMaintenanceReport } = await import("./maintenance.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 cfg = await loadConfig(stores[0].path);
+    const engine = new GnosysMaintenanceEngine(resolver, cfg);
+    const report = await engine.maintain({
+        dryRun: opts.dryRun,
+        autoApply: opts.autoApply,
+        onLog: (level, message) => {
+            if (level === "warn") {
+                console.error(`⚠ ${message}`);
+            }
+            else if (level === "action") {
+                console.log(`→ ${message}`);
+            }
+            else {
+                console.log(message);
+            }
+        },
+        onProgress: (step, current, total) => {
+            process.stdout.write(`\r[${current}/${total}] ${step}...`);
+            if (current === total)
+                process.stdout.write("\n");
+        },
+    });
+    console.log("");
+    console.log(formatMaintenanceReport(report));
+}

package/dist/lib/masterLease.d.ts

@@ -0,0 +1,20 @@
+/**
+ * v13 master.json ownership marker — epoch-fenced lease on the master folder.
+ */
+export declare const MASTER_MARKER_FILE = "master.json";
+export interface MasterMarker {
+    epoch: number;
+    holderMachineId: string;
+    hostname: string;
+    updatedAt: string;
+}
+export declare function masterMarkerPath(masterPath: string): string;
+export declare function readMasterMarker(masterPath: string): MasterMarker | null;
+/** Bump epoch when claiming; reuse epoch+1 on stale takeover. */
+export declare function writeMasterMarker(masterPath: string, machineId: string, opts?: {
+    previousEpoch?: number;
+}): MasterMarker;
+/** Heartbeat refresh — same epoch, new updatedAt (transient write failures must not demote). */
+export declare function touchMasterMarkerHeartbeat(masterPath: string): MasterMarker | null;
+export declare function assertMasterLeaseHeld(masterPath: string, machineId: string): void;
+export declare function validateLeaseEpochBeforeWrite(masterPath: string, expectedEpoch: number, machineId: string): void;

package/dist/lib/masterLease.js

@@ -0,0 +1,68 @@
+/**
+ * v13 master.json ownership marker — epoch-fenced lease on the master folder.
+ */
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { atomicWriteFileSync } from "./atomicWrite.js";
+import { ensureMachineConfig } from "./machineConfig.js";
+export const MASTER_MARKER_FILE = "master.json";
+export function masterMarkerPath(masterPath) {
+    return path.join(masterPath, MASTER_MARKER_FILE);
+}
+export function readMasterMarker(masterPath) {
+    const p = masterMarkerPath(masterPath);
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = readFileSync(p, "utf-8");
+        const o = JSON.parse(raw);
+        if (typeof o.epoch !== "number" || !o.holderMachineId)
+            return null;
+        return {
+            epoch: o.epoch,
+            holderMachineId: o.holderMachineId,
+            hostname: String(o.hostname ?? ""),
+            updatedAt: String(o.updatedAt ?? ""),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Bump epoch when claiming; reuse epoch+1 on stale takeover. */
+export function writeMasterMarker(masterPath, machineId, opts) {
+    const nextEpoch = (opts?.previousEpoch ?? 0) + 1;
+    const marker = {
+        epoch: nextEpoch,
+        holderMachineId: machineId,
+        hostname: ensureMachineConfig().config.hostname,
+        updatedAt: new Date().toISOString(),
+    };
+    atomicWriteFileSync(masterMarkerPath(masterPath), JSON.stringify(marker, null, 2) + "\n");
+    return marker;
+}
+/** Heartbeat refresh — same epoch, new updatedAt (transient write failures must not demote). */
+export function touchMasterMarkerHeartbeat(masterPath) {
+    const existing = readMasterMarker(masterPath);
+    if (!existing)
+        return null;
+    const refreshed = { ...existing, updatedAt: new Date().toISOString() };
+    atomicWriteFileSync(masterMarkerPath(masterPath), JSON.stringify(refreshed, null, 2) + "\n");
+    return refreshed;
+}
+export function assertMasterLeaseHeld(masterPath, machineId) {
+    const marker = readMasterMarker(masterPath);
+    if (!marker) {
+        throw new Error("master.json missing — this folder is not an active master");
+    }
+    if (marker.holderMachineId !== machineId) {
+        throw new Error(`master lease held by ${marker.holderMachineId} (epoch ${marker.epoch}), not this machine`);
+    }
+}
+export function validateLeaseEpochBeforeWrite(masterPath, expectedEpoch, machineId) {
+    assertMasterLeaseHeld(masterPath, machineId);
+    const marker = readMasterMarker(masterPath);
+    if (!marker || marker.epoch !== expectedEpoch) {
+        throw new Error("master lease epoch changed — aborting write");
+    }
+}

package/dist/lib/migrateCommand.d.ts

@@ -0,0 +1,7 @@
+export type MigrateCommandOptions = {
+    from?: string;
+    to?: string;
+    name?: string;
+    yes?: boolean;
+};
+export declare function runMigrateCommand(opts: MigrateCommandOptions): Promise<void>;

package/dist/lib/migrateCommand.js

@@ -0,0 +1,158 @@
+import fs from "fs/promises";
+import path from "path";
+import { GnosysDB } from "./db.js";
+import { findProjectIdentity, readProjectIdentity, migrateProject } from "./projectIdentity.js";
+export async function runMigrateCommand(opts) {
+    const { createInterface } = await import("readline/promises");
+    const rl = opts.yes ? null : createInterface({ input: process.stdin, output: process.stdout });
+    let centralDb = null;
+    const ask = async (question, defaultValue) => {
+        if (!rl)
+            return defaultValue || "";
+        const suffix = defaultValue ? ` (${defaultValue})` : "";
+        const answer = (await rl.question(`${question}${suffix}: `)).trim();
+        return answer || defaultValue || "";
+    };
+    const fail = (message) => {
+        console.error(message);
+        process.exitCode = 1;
+    };
+    try {
+        console.log("\n── Gnosys Project Migration ──\n");
+        let sourceDir;
+        if (opts.from) {
+            sourceDir = path.resolve(opts.from);
+        }
+        else {
+            const found = await findProjectIdentity(process.cwd());
+            const defaultSource = found ? found.projectRoot : "";
+            const sourceInput = await ask("Source directory (contains .gnosys/)", defaultSource);
+            if (!sourceInput) {
+                fail("No source directory provided.");
+                return;
+            }
+            sourceDir = path.resolve(sourceInput);
+        }
+        const storePath = path.join(sourceDir, ".gnosys");
+        try {
+            await fs.stat(storePath);
+        }
+        catch {
+            fail(`No .gnosys/ directory found at ${sourceDir}`);
+            return;
+        }
+        const identity = await readProjectIdentity(sourceDir);
+        const { glob } = await import("glob");
+        const memFiles = await glob("**/*.md", {
+            cwd: storePath,
+            ignore: ["**/CHANGELOG.md", "**/MANIFEST.md", "**/.git/**", "**/.obsidian/**"],
+        });
+        console.log("\nSource project:");
+        if (identity) {
+            console.log(`  Name:      ${identity.projectName}`);
+            console.log(`  ID:        ${identity.projectId}`);
+        }
+        else {
+            console.log(`  Name:      (unregistered — pre-v3 store)`);
+        }
+        console.log(`  Directory: ${sourceDir}`);
+        console.log(`  Memories:  ${memFiles.length} markdown files`);
+        let targetDir;
+        if (opts.to) {
+            targetDir = path.resolve(opts.to);
+        }
+        else {
+            const targetInput = await ask("\nTarget directory (where .gnosys/ should live)");
+            if (!targetInput) {
+                fail("No target directory provided.");
+                return;
+            }
+            targetDir = path.resolve(targetInput);
+        }
+        const defaultName = opts.name || path.basename(targetDir);
+        const newName = opts.yes
+            ? defaultName
+            : await ask("Project name", defaultName);
+        let doSync = true;
+        let doDelete = true;
+        if (!opts.yes) {
+            const syncAnswer = await ask("\nSync memories to central DB?", "Y");
+            doSync = syncAnswer.toLowerCase() !== "n" && syncAnswer.toLowerCase() !== "no";
+            const deleteAnswer = await ask("Delete old .gnosys/ after migration?", "Y");
+            doDelete = deleteAnswer.toLowerCase() !== "n" && deleteAnswer.toLowerCase() !== "no";
+        }
+        console.log("\n── Migration Summary ──");
+        console.log(`  From:       ${sourceDir}/.gnosys/`);
+        console.log(`  To:         ${targetDir}/.gnosys/`);
+        console.log(`  Name:       ${identity?.projectName || "(new)"} → ${newName}`);
+        console.log(`  Memories:   ${memFiles.length} files`);
+        console.log(`  Sync to DB: ${doSync ? "yes" : "no"}`);
+        console.log(`  Delete old: ${doDelete ? "yes" : "no"}`);
+        if (!opts.yes) {
+            const confirm = await ask("\nProceed?", "Y");
+            if (confirm.toLowerCase() === "n" || confirm.toLowerCase() === "no") {
+                console.log("Aborted.");
+                return;
+            }
+        }
+        try {
+            centralDb = GnosysDB.openCentral();
+            if (!centralDb.isAvailable())
+                centralDb = null;
+        }
+        catch {
+            centralDb = null;
+        }
+        console.log("\nMigrating...");
+        const result = await migrateProject({
+            sourcePath: sourceDir,
+            targetPath: targetDir,
+            newName,
+            deleteSource: doDelete,
+            centralDb: centralDb || undefined,
+        });
+        console.log(`  Copied ${result.memoryFileCount} memory files`);
+        console.log(`  Project: ${result.newIdentity.projectName} (${result.newIdentity.projectId})`);
+        console.log(`  Path:    ${result.newIdentity.workingDirectory}`);
+        console.log(`  Central DB: ${centralDb ? "updated ✓" : "not available"}`);
+        if (doSync && centralDb) {
+            console.log("\nSyncing memories to central DB...");
+            const matter = (await import("gray-matter")).default;
+            const { syncMemoryToDb } = await import("./dbWrite.js");
+            const newStorePath = path.join(targetDir, ".gnosys");
+            const mdFiles = await glob("**/*.md", {
+                cwd: newStorePath,
+                ignore: ["**/CHANGELOG.md", "**/MANIFEST.md", "**/.git/**", "**/.obsidian/**"],
+            });
+            let synced = 0;
+            for (const file of mdFiles) {
+                try {
+                    const filePath = path.join(newStorePath, file);
+                    const raw = await fs.readFile(filePath, "utf-8");
+                    const parsed = matter(raw);
+                    if (parsed.data?.id) {
+                        syncMemoryToDb(centralDb, parsed.data, parsed.content, filePath, result.newIdentity.projectId, "project");
+                        synced++;
+                    }
+                }
+                catch {
+                    // Skip files that fail to parse
+                }
+            }
+            console.log(`  Synced ${synced} memories to central DB`);
+        }
+        if (doDelete) {
+            console.log(`\nOld .gnosys/ at ${sourceDir} removed.`);
+        }
+        console.log(`\nMigration complete! Run 'gnosys projects' to verify.`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`\nMigration failed: ${msg}`);
+        process.exitCode = 1;
+    }
+    finally {
+        rl?.close();
+        centralDb?.close();
+    }
+}

package/dist/lib/migrateDbCommand.d.ts

@@ -0,0 +1,9 @@
+import type { GnosysResolver } from "./resolver.js";
+export type MigrateDbCommandOptions = {
+    toCentral?: boolean;
+    verbose?: boolean;
+};
+export type MigrateDbCommandContext = {
+    getResolver: () => Promise<GnosysResolver>;
+};
+export declare function runMigrateDbCommand(opts: MigrateDbCommandOptions, context: MigrateDbCommandContext): Promise<void>;

package/dist/lib/migrateDbCommand.js

@@ -0,0 +1,94 @@
+import path from "path";
+import { GnosysDB } from "./db.js";
+import { createProjectIdentity } from "./projectIdentity.js";
+export async function runMigrateDbCommand(opts, context) {
+    if (!opts.toCentral) {
+        const resolver = await context.getResolver();
+        const writeTarget = resolver.getWriteTarget();
+        if (!writeTarget) {
+            console.error("No writable store found. Run 'gnosys init' first.");
+            process.exitCode = 1;
+            return;
+        }
+        const { migrate, formatMigrationReport } = await import("./migrate.js");
+        const stats = await migrate(writeTarget.store.getStorePath(), { verbose: opts.verbose });
+        console.log(formatMigrationReport(stats));
+        return;
+    }
+    console.log("Migrating per-project stores to central DB (~/.gnosys/gnosys.db)...\n");
+    let centralDb = null;
+    try {
+        try {
+            centralDb = GnosysDB.openCentral();
+            if (!centralDb.isAvailable()) {
+                console.error("Central DB not available (better-sqlite3 missing).");
+                process.exitCode = 1;
+                return;
+            }
+        }
+        catch (err) {
+            console.error(`Cannot open central DB: ${err instanceof Error ? err.message : err}`);
+            process.exitCode = 1;
+            return;
+        }
+        const resolver = await context.getResolver();
+        const detectedStores = await resolver.detectAllStores();
+        const projectDirs = detectedStores
+            .filter(s => s.hasGnosys)
+            .map(s => s.path);
+        if (projectDirs.length === 0) {
+            console.log("No per-project stores found to migrate.");
+            return;
+        }
+        console.log(`Found ${projectDirs.length} project store(s) to migrate:\n`);
+        let totalMemories = 0;
+        let totalProjects = 0;
+        for (const projectDir of projectDirs) {
+            const storePath = path.join(projectDir, ".gnosys");
+            const log = opts.verbose ? console.log : () => { };
+            let projectDb = null;
+            try {
+                const identity = await createProjectIdentity(projectDir, {
+                    centralDb: centralDb,
+                });
+                log(`  [${identity.projectName}] ID: ${identity.projectId}`);
+                projectDb = new GnosysDB(storePath);
+                if (!projectDb.isAvailable() || !projectDb.isMigrated()) {
+                    log(`  [${identity.projectName}] No migrated gnosys.db — skipping`);
+                    continue;
+                }
+                const memories = projectDb.getAllMemories();
+                let count = 0;
+                centralDb.transaction(() => {
+                    for (const mem of memories) {
+                        centralDb.insertMemory({
+                            ...mem,
+                            project_id: identity.projectId,
+                            scope: "project",
+                        });
+                        count++;
+                    }
+                });
+                totalMemories += count;
+                totalProjects++;
+                console.log(`  ✓ ${identity.projectName}: ${count} memories migrated`);
+            }
+            catch (err) {
+                console.error(`  ✗ ${projectDir}: ${err instanceof Error ? err.message : err}`);
+            }
+            finally {
+                projectDb?.close();
+            }
+        }
+        console.log(`\n╔════════════════════════════════════════╗`);
+        console.log(`║  Central Migration Complete            ║`);
+        console.log(`╚════════════════════════════════════════╝`);
+        console.log(`  Projects migrated: ${totalProjects}`);
+        console.log(`  Memories imported:  ${totalMemories}`);
+        console.log(`\n  Per-project gnosys.db files are untouched.`);
+        console.log(`  Central DB: ${GnosysDB.getCentralDbPath()}`);
+    }
+    finally {
+        centralDb?.close();
+    }
+}

package/dist/lib/modelValidation.d.ts

@@ -11,6 +11,11 @@ export interface ValidationResult {
     error?: string;
     latencyMs?: number;
 }
+/**
+ * True when a validation error likely means the API key is wrong or expired
+ * (as opposed to model name, network, or rate-limit issues).
+ */
+export declare function isApiKeyValidationError(error?: string): boolean;
 /**
  * Validate a provider/model/key combo by sending a tiny test request.
  * Times out after 15 seconds.

package/dist/lib/modelValidation.js

@@ -6,6 +6,22 @@
  * model names, expired keys, and reachability problems before the user
  * finishes setup.
  */
+/**
+ * True when a validation error likely means the API key is wrong or expired
+ * (as opposed to model name, network, or rate-limit issues).
+ */
+export function isApiKeyValidationError(error) {
+    if (!error)
+        return false;
+    const lower = error.toLowerCase();
+    if (/http\s+(401|403)\b/i.test(error))
+        return true;
+    if (/incorrect\s+api\s+key|invalid\s+api\s+key|invalid_api_key|authentication\s+failed|unauthorized|permission\s+denied/.test(lower)) {
+        return true;
+    }
+    // Some providers (e.g. xAI) return HTTP 400 with an API-key message.
+    return /http\s+400\b/.test(error) && /api\s+key/.test(lower);
+}
 /**
  * Build a provider-specific minimal chat request.
  * Returns null for providers we can't validate (e.g. "custom" without baseUrl).
@@ -68,6 +84,17 @@ function buildRequest(provider, model, apiKey, customBaseUrl) {
                 },
                 body: openaiBody,
             };
+        case "openrouter":
+            return {
+                url: "https://openrouter.ai/api/v1/chat/completions",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${apiKey}`,
+                    "HTTP-Referer": "https://github.com/proticom/gnosys",
+                    "X-Title": "Gnosys",
+                },
+                body: openaiBody,
+            };
         case "ollama":
             return {
                 url: "http://localhost:11434/api/chat",

package/dist/lib/openrouterTiers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Build setup-wizard model tiers from the OpenRouter catalog.
+ * Includes :free models (excluded from other provider tier builders).
+ */
+export interface OpenRouterCatalogModel {
+    id: string;
+    name?: string;
+    pricing?: {
+        prompt?: string;
+        completion?: string;
+    };
+    context_length?: number;
+    created?: number;
+}
+export interface OpenRouterModelTier {
+    name: string;
+    model: string;
+    input: number;
+    output: number;
+    recommended: boolean;
+}
+/** Default recommended free model on OpenRouter. */
+export declare const OPENROUTER_DEFAULT_MODEL = "nvidia/nemotron-3-super-120b-a12b:free";
+export declare const OPENROUTER_STATIC_TIERS: OpenRouterModelTier[];
+/**
+ * Turn OpenRouter /models JSON into wizard tiers: free models first, then
+ * a few paid budget/balanced/premium picks.
+ */
+export declare function buildOpenRouterTiers(catalog: OpenRouterCatalogModel[]): OpenRouterModelTier[];

package/dist/lib/openrouterTiers.js

@@ -0,0 +1,113 @@
+/**
+ * Build setup-wizard model tiers from the OpenRouter catalog.
+ * Includes :free models (excluded from other provider tier builders).
+ */
+const SKIP_ID = /guard|embed|tts|audio|vision|image|code-|router/i;
+/** Default recommended free model on OpenRouter. */
+export const OPENROUTER_DEFAULT_MODEL = "nvidia/nemotron-3-super-120b-a12b:free";
+export const OPENROUTER_STATIC_TIERS = [
+    {
+        name: "Free · Nemotron 3 Super",
+        model: OPENROUTER_DEFAULT_MODEL,
+        input: 0,
+        output: 0,
+        recommended: true,
+    },
+    {
+        name: "Free · Devstral Small",
+        model: "mistralai/devstral-small-2505:free",
+        input: 0,
+        output: 0,
+        recommended: false,
+    },
+    {
+        name: "Free · Llama 3.3 70B",
+        model: "meta-llama/llama-3.3-70b-instruct:free",
+        input: 0,
+        output: 0,
+        recommended: false,
+    },
+];
+function tierLabel(m) {
+    const raw = m.name?.trim() || m.id.split("/").pop() || m.id;
+    const short = raw.length > 48 ? `${raw.slice(0, 45)}…` : raw;
+    return m.isFree ? `Free · ${short}` : short;
+}
+/**
+ * Turn OpenRouter /models JSON into wizard tiers: free models first, then
+ * a few paid budget/balanced/premium picks.
+ */
+export function buildOpenRouterTiers(catalog) {
+    const parsed = catalog
+        .filter((m) => m.id.includes("/") && !SKIP_ID.test(m.id))
+        .map((m) => {
+        const input = parseFloat(m.pricing?.prompt ?? "0") * 1e6;
+        const output = parseFloat(m.pricing?.completion ?? "0") * 1e6;
+        const isFree = m.id.includes(":free") || (input === 0 && output === 0);
+        return {
+            id: m.id,
+            name: m.name,
+            input,
+            output,
+            isFree,
+            created: m.created ?? 0,
+        };
+    });
+    const free = parsed
+        .filter((m) => m.isFree)
+        .sort((a, b) => b.created - a.created);
+    const paid = parsed
+        .filter((m) => !m.isFree && m.input > 0)
+        .filter((m) => !/preview|beta/i.test(m.id))
+        .sort((a, b) => b.created - a.created);
+    const tiers = [];
+    const seen = new Set();
+    const recommendedFree = free.find((m) => m.id === OPENROUTER_DEFAULT_MODEL) ??
+        free.find((m) => m.id.includes("nemotron-3-super")) ??
+        free[0];
+    for (const m of free.slice(0, 8)) {
+        if (seen.has(m.id))
+            continue;
+        seen.add(m.id);
+        tiers.push({
+            name: tierLabel(m),
+            model: m.id,
+            input: 0,
+            output: 0,
+            recommended: recommendedFree?.id === m.id,
+        });
+    }
+    const BUDGET_MAX = 1.5;
+    const BALANCED_MAX = 6;
+    const budget = paid.find((m) => m.input <= BUDGET_MAX);
+    const balanced = paid.find((m) => m.input > BUDGET_MAX && m.input <= BALANCED_MAX);
+    const premium = paid.find((m) => m.input > BALANCED_MAX);
+    for (const [m, label] of [
+        [budget, "Paid · Budget"],
+        [balanced, "Paid · Balanced"],
+        [premium, "Paid · Premium"],
+    ]) {
+        if (!m || seen.has(m.id))
+            continue;
+        seen.add(m.id);
+        tiers.push({
+            name: label,
+            model: m.id,
+            input: Math.round(m.input * 100) / 100,
+            output: Math.round(m.output * 100) / 100,
+            recommended: false,
+        });
+    }
+    if (tiers.length === 0) {
+        return [...OPENROUTER_STATIC_TIERS];
+    }
+    if (!tiers.some((t) => t.recommended)) {
+        tiers[0].recommended = true;
+    }
+    // Ensure the canonical Nemotron free tier is always listed.
+    if (!seen.has(OPENROUTER_DEFAULT_MODEL)) {
+        const nemotron = OPENROUTER_STATIC_TIERS[0];
+        tiers.unshift({ ...nemotron, recommended: !tiers.some((t) => t.recommended) });
+    }
+    return tiers;
+}

package/dist/lib/prefCommand.d.ts

@@ -0,0 +1,10 @@
+export type PrefSetCommandOptions = {
+    title?: string;
+    tags?: string;
+};
+export type PrefGetCommandOptions = {
+    json?: boolean;
+};
+export declare function runPrefSetCommand(key: string, value: string, opts: PrefSetCommandOptions): Promise<void>;
+export declare function runPrefGetCommand(key: string | undefined, opts: PrefGetCommandOptions): Promise<void>;
+export declare function runPrefDeleteCommand(key: string): Promise<void>;