gnosys 5.0.0 → 5.1.0

package/dist/index.js

@@ -311,6 +311,53 @@ server.tool("gnosys_list", "List memories across all stores, optionally filtered
     projectRoot: projectRootParam,
 }, async ({ category, tag, store: storeFilter, status, projectRoot }) => {
     const ctx = await resolveToolContext(projectRoot);
+    // DB-first: read from central DB instead of scanning markdown files
+    const db = ctx.centralDb;
+    if (db?.isAvailable()) {
+        let dbMemories = status === "active" || !status
+            ? db.getActiveMemories()
+            : db.getAllMemories();
+        // Apply filters on DB results
+        if (status && status !== "active") {
+            dbMemories = dbMemories.filter((m) => m.status === status);
+        }
+        if (storeFilter) {
+            dbMemories = dbMemories.filter((m) => m.scope === storeFilter);
+        }
+        if (category) {
+            dbMemories = dbMemories.filter((m) => m.category === category);
+        }
+        if (tag) {
+            dbMemories = dbMemories.filter((m) => {
+                try {
+                    const parsed = JSON.parse(m.tags || "[]");
+                    const tagList = Array.isArray(parsed)
+                        ? parsed
+                        : Object.values(parsed).flat();
+                    return tagList.includes(tag);
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        // Filter by project if we have a project ID (so scoped queries only see their project)
+        if (ctx.projectId && !storeFilter) {
+            dbMemories = dbMemories.filter((m) => m.project_id === ctx.projectId || m.scope !== "project");
+        }
+        const lines = dbMemories.map((m) => `- [${m.scope}] **${m.title}** (${m.category}/${m.id}) [${m.status}]`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: lines.length > 0
+                        ? `${lines.length} memories:\n\n${lines.join("\n")}`
+                        : "No memories match the filter.",
+                },
+            ],
+        };
+    }
+    // Fallback: read from markdown files if central DB unavailable
     let memories = await ctx.resolver.getAllMemories();
     if (storeFilter) {
         memories = memories.filter((m) => m.sourceLayer === storeFilter || m.sourceLabel === storeFilter);
@@ -384,7 +431,13 @@ server.tool("gnosys_add", "Add a new memory. Accepts raw text — an LLM structu
     }
     try {
         const result = await ingestion.ingest(input);
-        const id = await writeTarget.store.generateId(result.category);
+        if (!ctx.gnosysDb?.isAvailable()) {
+            return {
+                content: [{ type: "text", text: "Database not available. Cannot write memory." }],
+                isError: true,
+            };
+        }
+        const id = ctx.gnosysDb.getNextId(result.category, ctx.projectId ?? undefined);
         const today = new Date().toISOString().split("T")[0];
         const frontmatter = {
             id,
@@ -401,19 +454,15 @@ server.tool("gnosys_add", "Add a new memory. Accepts raw text — an LLM structu
             status: "active",
             supersedes: null,
         };
-        const filename = `${result.filename}.md`;
         const content = `# ${result.title}\n\n${result.content}`;
-        const relativePath = await writeTarget.store.writeMemory(result.category, filename, frontmatter, content);
-        // v2.0: Dual-write to gnosys.db
-        if (ctx.gnosysDb?.isAvailable()) {
-            syncMemoryToDb(ctx.gnosysDb, frontmatter, content, relativePath);
-            auditToDb(ctx.gnosysDb, "write", id, { tool: "gnosys_add", category: result.category });
-        }
+        // Write to DB only (SQLite is sole source of truth)
+        syncMemoryToDb(ctx.gnosysDb, frontmatter, content, undefined, ctx.projectId, "project");
+        auditToDb(ctx.gnosysDb, "write", id, { tool: "gnosys_add", category: result.category });
         // Rebuild search index across all stores
         if (ctx.search) {
             await reindexAllStores();
         }
-        let response = `Memory added to [${writeTarget.label}]: **${result.title}**\nPath: ${writeTarget.label}:${relativePath}\nCategory: ${result.category}\nConfidence: ${result.confidence}`;
+        let response = `Memory added to [${writeTarget.label}]: **${result.title}**\nID: ${id}\nCategory: ${result.category}\nConfidence: ${result.confidence}`;
         if (result.proposedNewTags && result.proposedNewTags.length > 0) {
             const proposed = result.proposedNewTags
                 .map((t) => `${t.category}:${t.tag}`)
@@ -424,7 +473,7 @@ server.tool("gnosys_add", "Add a new memory. Accepts raw text — an LLM structu
         if (ctx.search && result.relevance) {
             const related = ctx.search.discover(result.relevance.split(" ").slice(0, 5).join(" "), 5);
             // Filter out the memory we just added
-            const overlaps = related.filter((r) => !r.relative_path.endsWith(filename));
+            const overlaps = related.filter((r) => r.title !== result.title);
             if (overlaps.length > 0) {
                 response += `\n\n⚠️ Potential overlaps detected — review these for contradictions:`;
                 for (const o of overlaps.slice(0, 3)) {
@@ -475,12 +524,13 @@ server.tool("gnosys_add_structured", "Add a memory with structured input (no LLM
             isError: true,
         };
     }
-    const id = await writeTarget.store.generateId(category);
-    const slug = title
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "")
-        .substring(0, 60);
+    if (!ctx.gnosysDb?.isAvailable()) {
+        return {
+            content: [{ type: "text", text: "Database not available. Cannot write memory." }],
+            isError: true,
+        };
+    }
+    const id = ctx.gnosysDb.getNextId(category, ctx.projectId ?? undefined);
     const today = new Date().toISOString().split("T")[0];
     const frontmatter = {
         id,
@@ -498,19 +548,16 @@ server.tool("gnosys_add_structured", "Add a memory with structured input (no LLM
         supersedes: null,
     };
     const fullContent = `# ${title}\n\n${content}`;
-    const relativePath = await writeTarget.store.writeMemory(category, `${slug}.md`, frontmatter, fullContent);
-    // v2.0: Dual-write to gnosys.db
-    if (ctx.gnosysDb?.isAvailable()) {
-        syncMemoryToDb(ctx.gnosysDb, frontmatter, fullContent, relativePath);
-        auditToDb(ctx.gnosysDb, "write", id, { tool: "gnosys_add_structured", category });
-    }
+    // Write to DB only (SQLite is sole source of truth)
+    syncMemoryToDb(ctx.gnosysDb, frontmatter, fullContent, undefined, ctx.projectId, "project");
+    auditToDb(ctx.gnosysDb, "write", id, { tool: "gnosys_add_structured", category });
     if (ctx.search)
         await reindexAllStores();
     return {
         content: [
             {
                 type: "text",
-                text: `Memory added to [${writeTarget.label}]: **${title}**\nPath: ${writeTarget.label}:${relativePath}`,
+                text: `Memory added to [${writeTarget.label}]: **${title}**\nID: ${id}`,
             },
         ],
     };
@@ -580,14 +627,9 @@ server.tool("gnosys_reinforce", "Signal whether a memory was useful. 'useful' re
             const sourceStore = ctx.resolver
                 .getStores()
                 .find((s) => s.label === memory.sourceLabel);
-            if (sourceStore?.writable) {
+            if (sourceStore) {
                 const count = (memory.frontmatter.reinforcement_count || 0) + 1;
-                await sourceStore.store.updateMemory(memory.relativePath, {
-                    modified: new Date().toISOString().split("T")[0],
-                    reinforcement_count: count,
-                    last_reinforced: new Date().toISOString().split("T")[0],
-                });
-                // v2.0: Sync reinforcement to gnosys.db
+                // Write reinforcement to DB only (SQLite is sole source of truth)
                 if (ctx.gnosysDb?.isAvailable()) {
                     syncReinforcementToDb(ctx.gnosysDb, memory_id, count);
                     auditToDb(ctx.gnosysDb, "reinforce", memory_id, { signal, context });
@@ -603,7 +645,7 @@ server.tool("gnosys_reinforce", "Signal whether a memory was useful. 'useful' re
     return { content: [{ type: "text", text: messages[signal] }] };
 });
 // ─── Tool: gnosys_init ───────────────────────────────────────────────────
-server.tool("gnosys_init", "Initialize Gnosys in a project directory. Creates .gnosys/ with project identity (gnosys.json), registers the project in the central DB (~/.gnosys/gnosys.db), and sets up tag registry + git. You MUST run this before any other Gnosys tool in a new project. Pass the full absolute path to the project root.", {
+server.tool("gnosys_init", "Initialize Gnosys in a project directory. Creates .gnosys/ with project identity (gnosys.json), registers the project in the central DB (~/.gnosys/gnosys.db), and sets up tag registry. You MUST run this before any other Gnosys tool in a new project. Pass the full absolute path to the project root.", {
     directory: z
         .string()
         .describe("Absolute path to the project directory to initialize. Required."),
@@ -623,7 +665,7 @@ server.tool("gnosys_init", "Initialize Gnosys in a project directory. Creates .g
         // Good — doesn't exist yet
     }
     if (!isResync) {
-        // Create directory structure
+        // Create directory structure (DB is sole source of truth — no category folders or changelog)
         await fs.mkdir(storePath, { recursive: true });
         await fs.mkdir(path.join(storePath, ".config"), { recursive: true });
         // Seed default tag registry
@@ -640,22 +682,6 @@ server.tool("gnosys_init", "Initialize Gnosys in a project directory. Creates .g
             status_tag: ["draft", "stable", "deprecated", "experimental"],
         };
         await fs.writeFile(path.join(storePath, ".config", "tags.json"), JSON.stringify(defaultRegistry, null, 2), "utf-8");
-        // Seed changelog
-        const changelog = `# Gnosys Changelog\n\n## ${new Date().toISOString().split("T")[0]}\n\n- Store initialized\n`;
-        await fs.writeFile(path.join(storePath, "CHANGELOG.md"), changelog, "utf-8");
-        // Init git
-        try {
-            const { execSync } = await import("child_process");
-            execSync("git init", { cwd: storePath, stdio: "pipe" });
-            execSync("git add -A", { cwd: storePath, stdio: "pipe" });
-            execSync('git commit -m "Initialize Gnosys store"', {
-                cwd: storePath,
-                stdio: "pipe",
-            });
-        }
-        catch {
-            // Git not available — that's fine
-        }
     }
     // v3.0: Create/update project identity and register in central DB
     const identity = await createProjectIdentity(targetDir, {
@@ -680,11 +706,82 @@ server.tool("gnosys_init", "Initialize Gnosys in a project directory. Creates .g
         content: [
             {
                 type: "text",
-                text: `Gnosys store ${action} at ${storePath}\n\nProject Identity:\n- ID: ${identity.projectId}\n- Name: ${identity.projectName}\n- Directory: ${identity.workingDirectory}\n- Agent rules target: ${identity.agentRulesTarget || "none detected"}\n- Central DB: ${centralDb?.isAvailable() ? "registered ✓" : "not available"}\n\n${isResync ? "Identity re-synced." : "Created:\n- gnosys.json (project identity)\n- .config/ (internal config)\n- tags.json (tag registry)\n- CHANGELOG.md\n- git repo"}\n\nThe store is ready. Use gnosys_discover to find existing memories or gnosys_add to create new ones.`,
+                text: `Gnosys store ${action} at ${storePath}\n\nProject Identity:\n- ID: ${identity.projectId}\n- Name: ${identity.projectName}\n- Directory: ${identity.workingDirectory}\n- Agent rules target: ${identity.agentRulesTarget || "none detected"}\n- Central DB: ${centralDb?.isAvailable() ? "registered ✓" : "not available"}\n\n${isResync ? "Identity re-synced." : "Created:\n- gnosys.json (project identity)\n- .config/ (internal config)\n- tags.json (tag registry)"}\n\nThe store is ready. Use gnosys_discover to find existing memories or gnosys_add to create new ones.`,
             },
         ],
     };
 });
+// ─── Tool: gnosys_migrate ────────────────────────────────────────────────
+server.tool("gnosys_migrate", "Migrate a Gnosys store (.gnosys/) from one directory to another. Updates the project name, working directory, and central DB registration. Use this when a project has moved or you want to consolidate stores.", {
+    sourcePath: z.string().describe("Directory that currently contains .gnosys/ (absolute path)"),
+    targetPath: z.string().describe("Directory to move .gnosys/ into (absolute path)"),
+    newName: z.string().optional().describe("New project name (default: basename of target directory)"),
+    syncMemories: z.boolean().optional().default(false).describe("Sync markdown memories into central DB after migration"),
+    deleteOld: z.boolean().optional().default(false).describe("Delete the old .gnosys/ directory after successful migration"),
+}, async ({ sourcePath, targetPath, newName, syncMemories, deleteOld }) => {
+    try {
+        const { migrateProject } = await import("./lib/projectIdentity.js");
+        const result = await migrateProject({
+            sourcePath,
+            targetPath,
+            newName,
+            deleteSource: deleteOld,
+            centralDb: centralDb || undefined,
+        });
+        const resolvedTargetPath = path.resolve(targetPath);
+        const newStorePath = path.join(resolvedTargetPath, ".gnosys");
+        let summary = `Migration complete!\n\n`;
+        summary += `Project: ${result.oldIdentity.projectName} → ${result.newIdentity.projectName}\n`;
+        summary += `Path: ${result.oldIdentity.workingDirectory} → ${result.newIdentity.workingDirectory}\n`;
+        summary += `Memory files: ${result.memoryFileCount}\n`;
+        summary += `Central DB: ${centralDb?.isAvailable() ? "updated ✓" : "not available"}`;
+        // Sync memories to central DB if requested
+        if (syncMemories && centralDb?.isAvailable()) {
+            const matter = (await import("gray-matter")).default;
+            const { syncMemoryToDb } = await import("./lib/dbWrite.js");
+            const { glob } = await import("glob");
+            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
+                }
+            }
+            summary += `\n\nSynced ${synced} memories to central DB.`;
+        }
+        if (deleteOld) {
+            summary += `\n\nOld .gnosys/ at ${sourcePath} has been removed.`;
+        }
+        // Add the new store location to the resolver so future tool calls find it
+        await resolver.registerProject(resolvedTargetPath);
+        await resolver.addProjectStore(newStorePath);
+        const writeTarget = resolver.getWriteTarget();
+        if (writeTarget) {
+            search = new GnosysSearch(writeTarget.store.getStorePath());
+            tagRegistry = new GnosysTagRegistry(writeTarget.store.getStorePath());
+            await tagRegistry.load();
+            ingestion = new GnosysIngestion(writeTarget.store, tagRegistry);
+            await reindexAllStores();
+        }
+        return { content: [{ type: "text", text: summary }] };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Migration failed: ${msg}` }], isError: true };
+    }
+});
 // ─── Tool: gnosys_update ─────────────────────────────────────────────────
 server.tool("gnosys_update", "Update an existing memory's frontmatter and/or content. Specify the memory path and the fields to change.", {
     path: z
@@ -758,37 +855,25 @@ server.tool("gnosys_update", "Update an existing memory's frontmatter and/or con
     if (superseded_by !== undefined)
         updates.superseded_by = superseded_by;
     const fullContent = newContent ? `# ${title || memory.frontmatter.title}\n\n${newContent}` : undefined;
-    const updated = await sourceStore.store.updateMemory(memory.relativePath, updates, fullContent);
-    if (!updated) {
+    const memoryId = memory.frontmatter.id;
+    if (!memoryId) {
         return {
-            content: [{ type: "text", text: `Failed to update: ${memPath}` }],
+            content: [{ type: "text", text: `Memory has no ID: ${memPath}` }],
             isError: true,
         };
     }
-    // Supersession cross-linking: if A supersedes B, mark B as superseded_by A
-    if (supersedes && updated.frontmatter.id) {
-        const allMemories = await ctx.resolver.getAllMemories();
-        const supersededMemory = allMemories.find((m) => m.frontmatter.id === supersedes);
-        if (supersededMemory) {
-            const supersededStore = ctx.resolver
-                .getStores()
-                .find((s) => s.label === supersededMemory.sourceLabel);
-            if (supersededStore?.writable) {
-                await supersededStore.store.updateMemory(supersededMemory.relativePath, {
-                    superseded_by: updated.frontmatter.id,
-                    status: "superseded",
-                });
-            }
-        }
+    if (!ctx.gnosysDb?.isAvailable()) {
+        return {
+            content: [{ type: "text", text: "Database not available. Cannot update memory." }],
+            isError: true,
+        };
     }
-    // v2.0: Dual-write update to gnosys.db
-    if (ctx.gnosysDb?.isAvailable() && updated.frontmatter.id) {
-        syncUpdateToDb(ctx.gnosysDb, updated.frontmatter.id, updates, fullContent);
-        auditToDb(ctx.gnosysDb, "write", updated.frontmatter.id, { tool: "gnosys_update", changed: Object.keys(updates) });
-        // Cross-link supersession in db too
-        if (supersedes) {
-            syncUpdateToDb(ctx.gnosysDb, supersedes, { superseded_by: updated.frontmatter.id, status: "superseded" });
-        }
+    // Write update to DB only (SQLite is sole source of truth)
+    syncUpdateToDb(ctx.gnosysDb, memoryId, updates, fullContent);
+    auditToDb(ctx.gnosysDb, "write", memoryId, { tool: "gnosys_update", changed: Object.keys(updates) });
+    // Supersession cross-linking: if A supersedes B, mark B as superseded_by A
+    if (supersedes) {
+        syncUpdateToDb(ctx.gnosysDb, supersedes, { superseded_by: memoryId, status: "superseded" });
     }
     // Rebuild search index
     if (ctx.search)
@@ -796,11 +881,12 @@ server.tool("gnosys_update", "Update an existing memory's frontmatter and/or con
     const changedFields = Object.keys(updates);
     if (newContent)
         changedFields.push("content");
+    const updatedTitle = title || memory.frontmatter.title;
     return {
         content: [
             {
                 type: "text",
-                text: `Memory updated: **${updated.frontmatter.title}**\nPath: ${memory.sourceLabel}:${memory.relativePath}\nChanged: ${changedFields.join(", ")}`,
+                text: `Memory updated: **${updatedTitle}**\nID: ${memoryId}\nChanged: ${changedFields.join(", ")}`,
             },
         ],
     };
@@ -958,8 +1044,12 @@ Output ONLY the JSON array, no markdown fences.`,
             else {
                 // Actually add via ingestion
                 try {
+                    if (!ctx.gnosysDb?.isAvailable()) {
+                        results.push(`❌ FAILED: "${candidate.summary}": Database not available`);
+                        continue;
+                    }
                     const result = await ingestion.ingest(candidate.summary);
-                    const id = await writeTarget.store.generateId(result.category);
+                    const id = ctx.gnosysDb.getNextId(result.category, ctx.projectId ?? undefined);
                     const today = new Date().toISOString().split("T")[0];
                     const frontmatter = {
                         id,
@@ -976,10 +1066,11 @@ Output ONLY the JSON array, no markdown fences.`,
                         status: "active",
                         supersedes: null,
                     };
-                    const filename = `${result.filename}.md`;
                     const content = `# ${result.title}\n\n${result.content}`;
-                    const relPath = await writeTarget.store.writeMemory(result.category, filename, frontmatter, content);
-                    results.push(`➕ ADDED: "${result.title}"\n  Path: ${writeTarget.label}:${relPath}`);
+                    // Write to DB only (SQLite is sole source of truth)
+                    syncMemoryToDb(ctx.gnosysDb, frontmatter, content, undefined, ctx.projectId, "project");
+                    auditToDb(ctx.gnosysDb, "write", id, { tool: "gnosys_commit_context", category: result.category });
+                    results.push(`➕ ADDED: "${result.title}"\n  ID: ${id}`);
                     added++;
                 }
                 catch (err) {
@@ -1766,6 +1857,13 @@ async function reindexAllStores() {
     if (!search)
         return;
     search.clearIndex();
+    // DB-first: read from central DB instead of scanning markdown files
+    if (centralDb?.isAvailable()) {
+        const memories = centralDb.getActiveMemories();
+        search.addDbMemories(memories);
+        return;
+    }
+    // Fallback: read from markdown files if central DB unavailable
     const allStores = resolver.getStores();
     for (const s of allStores) {
         await search.addStoreMemories(s.store, s.label);