gnosys 5.3.3 → 5.4.1

package/README.md

@@ -24,7 +24,7 @@
 
 Gnosys is **sandbox-first**: a persistent background process holds the database connection while agents import a tiny helper library and call memory operations like normal code — no MCP schemas, no round-trips, near-zero context cost. The central brain at `~/.gnosys/gnosys.db` unifies all projects, user preferences, and global knowledge. Federated search ranks results across scopes with tier boosting and recency awareness. The **Web Knowledge Base** turns any website into a searchable knowledge base for serverless chatbots — pre-computed JSON index, zero runtime dependencies. **Multimodal ingestion** handles PDFs, images, audio, and video. **Portfolio Dashboard** gives a bird's-eye view of all projects. Process tracing builds call chains from source code. Dream Mode consolidates knowledge during idle time. One-command export regenerates a full Obsidian vault.
 
-It also runs as a CLI and a complete MCP server that drops straight into Cursor, Claude Desktop, Claude Code, Cowork, Codex, or any MCP client.
+It also runs as a CLI and a complete MCP server that drops straight into Cursor, Claude Desktop (Chat / Cowork / Code), Claude Code, Codex, Gemini CLI, Antigravity, or any MCP client.
 
 No vector DBs. No black boxes. No external services. Just SQLite and optional Obsidian export — the way knowledge should be.
 
@@ -53,7 +53,7 @@ Gnosys takes a different approach: the central brain is a single SQLite database
 - **Bulk import** — CSV, JSON, JSONL. Import entire datasets in seconds.
 - **Obsidian-native** — `gnosys export` generates a full vault with YAML frontmatter, `[[wikilinks]]`, summaries, and graph data.
 - **Multi-machine sync (v5.3.0)** — share your `gnosys.db` across machines via NAS or shared drive. Local cache for speed, remote source of truth for consistency. Built-in conflict detection with skip-and-flag resolution. Run `gnosys remote configure` to set up.
-- **MCP-compatible** — also runs as a full MCP server that drops into Cursor, Claude Desktop, Claude Code, Cowork, Codex, or any MCP client.
+- **MCP-compatible** — also runs as a full MCP server that drops into Cursor, Claude Desktop (Chat / Cowork / Code), Claude Code, Codex, Gemini CLI, Antigravity, or any MCP client.
 - **Zero infrastructure** — no external databases, no Docker (unless you want it), no cloud services. Just `npm install`.
 
 > For the complete CLI reference and detailed guides, see the **[User Guide](https://gnosys.ai/guide.html)**.
@@ -235,9 +235,47 @@ This improves your site's visibility in AI-powered search results and enables LL
 
 ## MCP Server Setup
 
-### Claude Desktop
+The fastest way to wire gnosys into any supported client is to run `gnosys init <ide>` from the project directory you want memory-enabled. Examples:
 
-Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+```bash
+gnosys init claude-desktop   # Claude Desktop (covers Chat, Cowork, and Code)
+gnosys init claude           # Claude Code CLI
+gnosys init cursor           # Cursor
+gnosys init codex            # Codex
+gnosys init gemini-cli       # Gemini CLI
+gnosys init antigravity      # Google Antigravity
+```
+
+This does two things at once:
+1. Wires gnosys into the IDE's MCP config (idempotent — safe to re-run).
+2. Initializes the current directory as a gnosys project (creates `.gnosys/gnosys.json`, registers it in the central DB) so your memories can be scoped to it.
+
+### One-time vs. per-project
+
+The IDE wiring writes to a **user-level** config file, so it only needs to happen **once**. Re-running it in another project just re-merges the same `mcpServers.gnosys` entry — harmless.
+
+The project registration is **per-directory**: every codebase you want to be memory-aware of needs its own `gnosys init`. From then on, agents pass `projectRoot: "/path/to/project"` to gnosys MCP tools to scope memory to that codebase.
+
+```bash
+# Once, anywhere — wires Claude Desktop's MCP config:
+gnosys init claude-desktop
+
+# Once per project — registers the codebase in the central DB:
+cd /path/to/project-a && gnosys init
+cd /path/to/project-b && gnosys init
+```
+
+> **Cowork users:** Cowork sessions don't have a working directory like a CLI does. The agent in Cowork uses whichever `projectRoot` it's told to use (typically auto-detected from open files or set via the system prompt). The "every working directory" question doesn't apply to Cowork itself — only to the projects you want memory-enabled. Run `gnosys init claude-desktop` once globally; run `gnosys init` per project.
+
+---
+
+### Manual config (if you prefer)
+
+If you'd rather edit configs by hand, here's where each client looks for MCP servers.
+
+#### Claude Desktop (Chat, Cowork, and Code share the same config)
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS), `%APPDATA%\Claude\claude_desktop_config.json` (Windows), or `~/.config/Claude/claude_desktop_config.json` (Linux):
 
 ```json
 {
@@ -250,9 +288,11 @@ Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
 }
 ```
 
-### Cursor
+Restart Claude Desktop after editing.
+
+#### Cursor
 
-Add to `.cursor/mcp.json`:
+Add to `.cursor/mcp.json` in your project:
 
 ```json
 {
@@ -265,13 +305,13 @@ Add to `.cursor/mcp.json`:
 }
 ```
 
-### Claude Code
+#### Claude Code
 
 ```bash
 claude mcp add gnosys gnosys serve
 ```
 
-### Codex
+#### Codex
 
 Add to `.codex/config.toml`:
 
@@ -281,6 +321,38 @@ type = "local"
 command = ["gnosys", "serve"]
 ```
 
+#### Gemini CLI
+
+Add to `~/.gemini/settings.json` (preserves any existing settings):
+
+```json
+{
+  "mcpServers": {
+    "gnosys": {
+      "command": "gnosys",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+#### Antigravity
+
+Add to `~/.gemini/antigravity/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "gnosys": {
+      "command": "gnosys",
+      "args": ["serve"]
+    }
+  }
+}
+```
+
+Antigravity reloads MCP servers automatically when you save the file.
+
 > **Note:** API keys are configured via `gnosys setup` (macOS Keychain, environment variable, or `~/.config/gnosys/.env`). See [LLM Provider Setup](https://gnosys.ai/guide.html#guide-llm-provider-setup) in the User Guide.
 
 ---

package/dist/cli.js

@@ -11,6 +11,7 @@ import { fileURLToPath } from "url";
 import dotenv from "dotenv";
 import { readFileSync, existsSync, copyFileSync } from "fs";
 import { GnosysResolver } from "./lib/resolver.js";
+import { getGnosysHome } from "./lib/paths.js";
 import { GnosysSearch } from "./lib/search.js";
 import { GnosysTagRegistry } from "./lib/tags.js";
 import { GnosysIngestion } from "./lib/ingest.js";
@@ -469,10 +470,12 @@ program
         }
     }
 });
-// ─── gnosys setup ───────────────────────────────────────────────────────
-program
+// ─── gnosys setup (parent command) ──────────────────────────────────────
+const setupCmd = program
     .command("setup")
-    .description("Interactive setup wizard — configure LLM provider, API key, model, and IDE integration in one step")
+    .description("Configure Gnosys — LLM provider, models, remote sync, and IDE integration");
+// Bare `gnosys setup` runs the full interactive wizard
+setupCmd
     .option("--non-interactive", "Skip prompts, use defaults (for CI/scripting)")
     .action(async (opts) => {
     const { runSetup } = await import("./lib/setup.js");
@@ -481,10 +484,65 @@ program
         nonInteractive: opts.nonInteractive,
     });
 });
+// `gnosys setup models` — just configure LLM provider/model/key
+setupCmd
+    .command("models")
+    .description("Update LLM provider and model configuration")
+    .option("-p, --provider <name>", "Set provider directly (anthropic, openai, xai, groq, mistral, ollama, lmstudio, custom)")
+    .option("-m, --model <name>", "Set model name directly")
+    .option("--no-validate", "Skip the test API call")
+    .action(async (opts) => {
+    const { runModelsSetup } = await import("./lib/setup.js");
+    await runModelsSetup({
+        directory: process.cwd(),
+        provider: opts.provider,
+        model: opts.model,
+        validate: opts.validate,
+    });
+});
+// `gnosys setup remote` — configure remote sync (alias for `gnosys remote configure`)
+setupCmd
+    .command("remote")
+    .description("Configure multi-machine sync (alias for 'gnosys remote configure')")
+    .option("--path <path>", "Set remote path directly (non-interactive)")
+    .action(async (opts) => {
+    const { GnosysDB } = await import("./lib/db.js");
+    // Sync configuration needs explicit local DB access (not auto-routed remote).
+    const db = GnosysDB.openLocal();
+    if (!db.isAvailable()) {
+        console.error("Central DB not available.");
+        db.close();
+        process.exit(1);
+    }
+    try {
+        if (opts.path) {
+            const { configureFromPath } = await import("./lib/remoteWizard.js");
+            await configureFromPath(db, opts.path);
+        }
+        else {
+            const { runConfigureWizard } = await import("./lib/remoteWizard.js");
+            await runConfigureWizard(db);
+        }
+    }
+    finally {
+        db.close();
+    }
+});
+// ─── gnosys models (top-level shortcut) ─────────────────────────────────
+program
+    .command("models")
+    .description("Quick model operations — list available, refresh cache, or set the default")
+    .option("--list", "List available models for the current provider")
+    .option("--refresh", "Refresh model list from OpenRouter (clears the cache)")
+    .option("--set <model>", "Set the default model for the current provider")
+    .action(async (opts) => {
+    const { runModelsCommand } = await import("./lib/setup.js");
+    await runModelsCommand(opts);
+});
 // ─── gnosys init ─────────────────────────────────────────────────────────
 program
     .command("init [ide]")
-    .description("Initialize Gnosys in the current directory. Optionally specify IDE: cursor, claude, or codex to force IDE setup.")
+    .description("Initialize Gnosys in the current directory. Optionally specify IDE: cursor, claude, claude-desktop, codex, gemini-cli, or antigravity to force IDE setup.")
     .option("-d, --directory <dir>", "Target directory (default: cwd)")
     .option("-n, --name <name>", "Project name (default: directory basename)")
     .action(async (ide, opts) => {
@@ -591,13 +649,15 @@ program
     }
     // If a specific IDE was requested, force-create its config
     if (ide) {
-        const validIdes = ["cursor", "claude", "codex"];
+        const validIdes = ["cursor", "claude", "claude-desktop", "codex", "gemini-cli", "antigravity"];
         const normalizedIde = ide.toLowerCase();
         if (!validIdes.includes(normalizedIde)) {
             console.log(`\nUnknown IDE: "${ide}". Valid options: ${validIdes.join(", ")}`);
         }
         else {
             const { configureCursor, configureClaudeCode, configureCodex } = await import("./lib/projectIdentity.js");
+            // Cursor/Claude/Codex have IDE-specific session hooks. Gemini CLI and
+            // Antigravity don't yet, so we skip the hook step for them.
             let result;
             switch (normalizedIde) {
                 case "cursor":
@@ -615,28 +675,30 @@ program
                 console.log(`  ${result.details}`);
                 console.log(`  File: ${result.filePath}`);
             }
-            // Also set up MCP config for the IDE
+            // Set up MCP config for the IDE
             const { setupIDE } = await import("./lib/setup.js");
             const mcp = await setupIDE(normalizedIde, targetDir);
             if (mcp.success) {
                 console.log(`  MCP: ${mcp.message}`);
             }
-            // Update agentRulesTarget in gnosys.json
-            const identityPath = path.join(storePath, "gnosys.json");
-            try {
-                const identityContent = await fs.readFile(identityPath, "utf-8");
-                const identity = JSON.parse(identityContent);
-                const targetMap = {
-                    cursor: ".cursor/rules/gnosys.mdc",
-                    claude: "CLAUDE.md",
-                    codex: "CODEX.md",
-                };
-                identity.agentRulesTarget = targetMap[normalizedIde] || null;
-                await fs.writeFile(identityPath, JSON.stringify(identity, null, 2) + "\n", "utf-8");
-                console.log(`  Config: agentRulesTarget → ${identity.agentRulesTarget}`);
-            }
-            catch {
-                // Non-critical
+            // Update agentRulesTarget in gnosys.json (only for IDEs with rules files)
+            const targetMap = {
+                cursor: ".cursor/rules/gnosys.mdc",
+                claude: "CLAUDE.md",
+                codex: "CODEX.md",
+            };
+            if (targetMap[normalizedIde]) {
+                const identityPath = path.join(storePath, "gnosys.json");
+                try {
+                    const identityContent = await fs.readFile(identityPath, "utf-8");
+                    const identity = JSON.parse(identityContent);
+                    identity.agentRulesTarget = targetMap[normalizedIde];
+                    await fs.writeFile(identityPath, JSON.stringify(identity, null, 2) + "\n", "utf-8");
+                    console.log(`  Config: agentRulesTarget → ${identity.agentRulesTarget}`);
+                }
+                catch {
+                    // Non-critical
+                }
             }
         }
     }
@@ -1652,14 +1714,60 @@ program
     .command("graph")
     .description("Show the full cross-reference graph across all memories")
     .action(async () => {
-    const resolver = await getResolver();
-    const allMemories = await resolver.getAllMemories();
-    if (allMemories.length === 0) {
-        console.log("No memories found.");
-        return;
+    // v5.4.1: Query the central DB directly. Previously this used the
+    // filesystem resolver, which returns nothing in v5.x DB-only mode
+    // because memories no longer live as markdown files.
+    let centralDb = null;
+    try {
+        centralDb = GnosysDB.openCentral();
+        if (!centralDb.isAvailable()) {
+            console.error("Central DB not available.");
+            process.exit(1);
+        }
+        const dbMemories = centralDb.getAllMemories();
+        if (dbMemories.length === 0) {
+            console.log("No memories found.");
+            return;
+        }
+        // Adapt DbMemory → legacy Memory shape that buildLinkGraph expects.
+        // The graph builder only reads id, title, content, and synthesises
+        // a filesystem-style path for display.
+        const adapted = dbMemories.map((m) => {
+            let parsedTags = [];
+            try {
+                parsedTags = JSON.parse(m.tags);
+            }
+            catch {
+                parsedTags = [];
+            }
+            const relativePath = `${m.category}/${m.id}.md`;
+            return {
+                frontmatter: {
+                    id: m.id,
+                    title: m.title,
+                    category: m.category,
+                    tags: parsedTags,
+                    relevance: m.relevance,
+                    author: m.author,
+                    authority: m.authority,
+                    confidence: m.confidence,
+                    created: m.created,
+                    modified: m.modified,
+                    last_reviewed: m.modified,
+                    status: m.status,
+                    supersedes: m.supersedes,
+                },
+                content: m.content,
+                filePath: relativePath,
+                relativePath,
+            };
+        });
+        const graph = buildLinkGraph(adapted);
+        console.log(formatGraphSummary(graph));
+    }
+    finally {
+        centralDb?.close();
     }
-    const graph = buildLinkGraph(allMemories);
-    console.log(formatGraphSummary(graph));
 });
 // ─── gnosys bootstrap <sourceDir> ────────────────────────────────────────
 program
@@ -2480,7 +2588,8 @@ remoteCmd
     .action(async (opts) => {
     let centralDb = null;
     try {
-        centralDb = GnosysDB.openCentral();
+        // Sync operations need explicit local DB access (not auto-routed remote).
+        centralDb = GnosysDB.openLocal();
         if (!centralDb.isAvailable()) {
             console.error("Central DB not available.");
             process.exit(1);
@@ -2531,7 +2640,7 @@ remoteCmd
     .action(async (opts) => {
     let centralDb = null;
     try {
-        centralDb = GnosysDB.openCentral();
+        centralDb = GnosysDB.openLocal();
         if (!centralDb.isAvailable()) {
             console.error("Central DB not available.");
             process.exit(1);
@@ -2545,7 +2654,8 @@ remoteCmd
         const sync = new RemoteSync(centralDb, remotePath);
         const result = await sync.push({ strategy: opts.newerWins ? "newer-wins" : "skip-and-flag" });
         sync.closeRemote();
-        console.log(`Pushed: ${result.pushed} | Skipped: ${result.skipped} | Conflicts: ${result.conflicts.length}`);
+        const projParts = (result.projectsPushed || 0) > 0 ? ` | Projects pushed: ${result.projectsPushed}` : "";
+        console.log(`Pushed: ${result.pushed} | Skipped: ${result.skipped} | Conflicts: ${result.conflicts.length}${projParts}`);
         if (result.errors.length > 0) {
             console.log("\nErrors:");
             for (const e of result.errors)
@@ -2572,7 +2682,7 @@ remoteCmd
     .action(async (opts) => {
     let centralDb = null;
     try {
-        centralDb = GnosysDB.openCentral();
+        centralDb = GnosysDB.openLocal();
         if (!centralDb.isAvailable()) {
             console.error("Central DB not available.");
             process.exit(1);
@@ -2586,7 +2696,8 @@ remoteCmd
         const sync = new RemoteSync(centralDb, remotePath);
         const result = await sync.pull({ strategy: opts.newerWins ? "newer-wins" : "skip-and-flag" });
         sync.closeRemote();
-        console.log(`Pulled: ${result.pulled} | Skipped: ${result.skipped} | Conflicts: ${result.conflicts.length}`);
+        const projParts = (result.projectsPulled || 0) > 0 ? ` | Projects pulled: ${result.projectsPulled}` : "";
+        console.log(`Pulled: ${result.pulled} | Skipped: ${result.skipped} | Conflicts: ${result.conflicts.length}${projParts}`);
         if (result.errors.length > 0) {
             console.log("\nErrors:");
             for (const e of result.errors)
@@ -2609,7 +2720,7 @@ remoteCmd
     .action(async (opts) => {
     let centralDb = null;
     try {
-        centralDb = GnosysDB.openCentral();
+        centralDb = GnosysDB.openLocal();
         if (!centralDb.isAvailable()) {
             if (!opts.auto)
                 console.error("Central DB not available.");
@@ -2629,7 +2740,10 @@ remoteCmd
         });
         sync.closeRemote();
         if (!opts.auto || result.conflicts.length > 0 || result.errors.length > 0) {
-            console.log(`Pushed: ${result.pushed} | Pulled: ${result.pulled} | Conflicts: ${result.conflicts.length}`);
+            const pp = result.projectsPushed || 0;
+            const pl = result.projectsPulled || 0;
+            const projParts = (pp + pl) > 0 ? ` | Projects: ↑${pp}/↓${pl}` : "";
+            console.log(`Pushed: ${result.pushed} | Pulled: ${result.pulled} | Conflicts: ${result.conflicts.length}${projParts}`);
             if (result.errors.length > 0) {
                 console.log("\nErrors:");
                 for (const e of result.errors)
@@ -2656,7 +2770,7 @@ remoteCmd
     .action(async (memoryId, opts) => {
     let centralDb = null;
     try {
-        centralDb = GnosysDB.openCentral();
+        centralDb = GnosysDB.openLocal();
         if (!centralDb.isAvailable()) {
             console.error("Central DB not available.");
             process.exit(1);
@@ -2698,7 +2812,7 @@ remoteCmd
     .action(async (opts) => {
     let centralDb = null;
     try {
-        centralDb = GnosysDB.openCentral();
+        centralDb = GnosysDB.openLocal();
         if (!centralDb.isAvailable()) {
             console.error("Central DB not available.");
             process.exit(1);
@@ -3103,7 +3217,7 @@ program
     .action(async (opts) => {
     const projectDir = opts.directory ? path.resolve(opts.directory) : process.cwd();
     const storePath = path.join(projectDir, ".gnosys");
-    const globalStorePath = path.join(os.homedir(), ".gnosys");
+    const globalStorePath = getGnosysHome();
     // Load config: try project-level first, fall back to global ~/.gnosys/
     let cfg;
     let configSource;
@@ -3685,10 +3799,22 @@ program
     console.log(`  Central DB: ${GnosysDB.getCentralDbPath()}`);
 });
 // ─── gnosys projects ────────────────────────────────────────────────────
+/**
+ * Returns true if a project's working directory no longer exists on disk.
+ * Used by `gnosys projects` to filter dead entries by default and by
+ * `gnosys projects --prune` to delete them. We deliberately do NOT pattern-
+ * match on tmp paths — active test fixtures live in /var/folders/ and
+ * /tmp/ and we want them visible while they're in use.
+ */
+function isDeadProjectDir(dir) {
+    return !existsSync(dir);
+}
 program
     .command("projects")
-    .description("List all registered projects in the central DB")
+    .description("List registered projects from the central DB")
     .option("--json", "Output as JSON")
+    .option("--all", "Include dead projects (deleted directories, /tmp/ paths)")
+    .option("--prune", "Delete registry entries whose directory no longer exists or is a tmp path")
     .action(async (opts) => {
     let centralDb = null;
     try {
@@ -3697,18 +3823,71 @@ program
             console.error("Central DB not available (better-sqlite3 missing).");
             process.exit(1);
         }
-        const projects = centralDb.getAllProjects();
-        if (projects.length === 0) {
-            console.log("No projects registered. Run 'gnosys init' in a project directory.");
+        const allProjects = centralDb.getAllProjects();
+        if (opts.prune) {
+            // Find and delete dead projects
+            const deadProjects = allProjects.filter((p) => isDeadProjectDir(p.working_directory));
+            for (const p of deadProjects) {
+                centralDb.deleteProject(p.id);
+            }
+            outputResult(!!opts.json, {
+                deleted: deadProjects.length,
+                remaining: allProjects.length - deadProjects.length,
+                deletedProjects: deadProjects.map((p) => ({ id: p.id, name: p.name, directory: p.working_directory })),
+            }, () => {
+                if (deadProjects.length === 0) {
+                    console.log("No dead projects to prune.");
+                }
+                else {
+                    const DIM = "\x1b[2m";
+                    const RESET = "\x1b[0m";
+                    console.log(`Pruned ${deadProjects.length} dead project(s):\n`);
+                    for (const p of deadProjects) {
+                        console.log(`  ${p.name}  ${DIM}${p.working_directory}${RESET}`);
+                    }
+                    console.log();
+                    console.log(`${allProjects.length - deadProjects.length} project(s) remain.`);
+                }
+            });
+            return;
+        }
+        // Normal listing — filter dead projects by default
+        const visibleProjects = opts.all
+            ? allProjects
+            : allProjects.filter((p) => !isDeadProjectDir(p.working_directory));
+        if (visibleProjects.length === 0) {
+            const deadCount = allProjects.length;
+            outputResult(!!opts.json, {
+                count: 0,
+                totalRegistered: deadCount,
+                deadCount,
+                projects: [],
+            }, () => {
+                if (deadCount === 0) {
+                    console.log("No projects registered. Run 'gnosys init' in a project directory.");
+                }
+                else {
+                    console.log(`No live projects (${deadCount} dead — run 'gnosys projects --all' to see them or 'gnosys projects --prune' to remove them).`);
+                }
+            });
             centralDb.close();
             return;
         }
-        const projectData = projects.map((p) => ({
+        const projectData = visibleProjects.map((p) => ({
             ...p,
             memoryCount: centralDb.getMemoriesByProject(p.id).length,
         }));
-        outputResult(!!opts.json, { count: projects.length, projects: projectData }, () => {
-            console.log(`${projects.length} registered project(s):\n`);
+        const deadCount = allProjects.length - visibleProjects.length;
+        outputResult(!!opts.json, {
+            count: visibleProjects.length,
+            totalRegistered: allProjects.length,
+            deadCount,
+            projects: projectData,
+        }, () => {
+            const header = deadCount > 0 && !opts.all
+                ? `${visibleProjects.length} live project(s) (${deadCount} dead hidden — use --all or --prune):\n`
+                : `${visibleProjects.length} registered project(s):\n`;
+            console.log(header);
             for (const p of projectData) {
                 console.log(`  ${p.name}`);
                 console.log(`    ID:        ${p.id}`);