devsmind-mcp 4.1.0 → 4.2.0

package/dist/db/database.js

@@ -381,7 +381,7 @@ class DevMindDatabase {
                 /* istanbul ignore next -- every call site here is a `SELECT COUNT(*) AS c FROM ...`,
                    which always returns exactly one row; `row` can only be undefined if this helper is
                    ever repurposed for a query that can return zero rows. Kept as a real guard, not
-                   because today's three call sites can hit it. */
+                   because today's call sites can hit it. */
                 return row ? row.c : 0;
             }
             catch {
@@ -392,6 +392,8 @@ class DevMindDatabase {
             nodes: one('SELECT COUNT(*) AS c FROM nodes WHERE deprecated = 0'),
             connections: one('SELECT COUNT(*) AS c FROM node_connections'),
             history: one('SELECT COUNT(*) AS c FROM history'),
+            vectors: one('SELECT COUNT(*) AS c FROM node_vectors'),
+            workflows: one('SELECT COUNT(*) AS c FROM workflows'),
         };
     }
     vacuum() {
@@ -2797,9 +2799,21 @@ class DevMindDatabase {
             if (node.file_path) {
                 const paths = node.file_path.split(',').map(p => p.trim()).filter(Boolean);
                 if (paths.length > 0) {
+                    // "Missing" also covers a file_path that resolves to a DIRECTORY rather than a real
+                    // file — plain fs.existsSync() alone says a directory "exists", so a node corrupted
+                    // this way (its file_path IS a repo or workspace root, from some earlier bug) sailed
+                    // through this check indefinitely; it only ever surfaced as an EISDIR crash when
+                    // writeGraphToDisk/writeVectorsToDisk later tried to write a JSON file at that same
+                    // path. statSync().isFile() catches both "doesn't exist" and "exists but isn't a file"
+                    // in one check — a node deprecated for either reason has no real source to hold anyway.
                     const allMissing = paths.every(p => {
                         const resolvedPath = path.isAbsolute(p) ? p : path.resolve(workspaceRoot, p);
-                        return !fs.existsSync(resolvedPath);
+                        try {
+                            return !fs.statSync(resolvedPath).isFile();
+                        }
+                        catch {
+                            return true;
+                        }
                     });
                     if (allMissing)
                         missingFile.push(node);
@@ -2808,6 +2822,58 @@ class DevMindDatabase {
         }
         return { spurious, missingFile };
     }
+    /**
+     * Finds `.devmind/graph`/`.devmind/vectors` JSON output paths that a live node's file_path
+     * still maps to, but that are occupied by a stray DIRECTORY instead of a file — the case
+     * `isDegenerateDiskJsonPath`'s existsSync+isDirectory branch refuses to write over. Left
+     * behind by some earlier node whose file_path once collapsed onto that exact path (see that
+     * method's comment for how); once the directory exists, `writeGraphToDisk`/`writeVectorsToDisk`
+     * can only skip-and-warn forever, since neither one ever deletes anything. This is what
+     * `devsmind analyze --fix` uses to actually remove the blocker and re-trigger the write, so a
+     * perfectly healthy node's file stops being warned about on every future sync.
+     *
+     * Deliberately mirrors ONLY the third of `isDegenerateDiskJsonPath`'s three checks (never the
+     * first two — an empty/trailing-slash/`..`-collapsing diskRelPath means the node's OWN
+     * file_path is degenerate, already covered by `missingFile` above and fixed by deprecating the
+     * node, not by deleting anything on disk). Skipping those here is required for safety: a
+     * collapsed diskRelPath would make `targetPath` resolve to `graphDir`/`vectorsDir` itself (or
+     * an ancestor of it), and blindly reporting that as "stray" would recommend deleting the whole
+     * output tree.
+     */
+    findStrayOutputDirs() {
+        const rows = this.db.prepare('SELECT DISTINCT file_path FROM nodes').all();
+        const filePaths = new Set();
+        for (const row of rows) {
+            if (row.file_path) {
+                for (const p of row.file_path.split(',').map(s => s.trim()).filter(Boolean)) {
+                    filePaths.add(p);
+                }
+            }
+        }
+        const workspaceRoot = (0, config_1.canonicalizePath)(path.dirname(this.dbPath));
+        const dirsByKind = [
+            { dir: path.join(workspaceRoot, 'graph'), kind: 'graph' },
+            { dir: path.join(workspaceRoot, 'vectors'), kind: 'vectors' },
+        ];
+        const results = [];
+        for (const filePath of filePaths) {
+            const absPath = (0, config_1.canonicalizePath)(filePath);
+            const repoRelPath = this.toRepoRelativePath(absPath);
+            const diskRelPath = repoRelPath.replace(/^\{([^}]+)\}/, '$1').replace(/\.[^/.]+$/, '.json');
+            if (!diskRelPath || diskRelPath.endsWith('/') || diskRelPath.endsWith('\\'))
+                continue;
+            for (const { dir, kind } of dirsByKind) {
+                const targetPath = path.join(dir, diskRelPath);
+                const relToContainer = path.relative(dir, targetPath);
+                if (relToContainer === '' || relToContainer.startsWith('..'))
+                    continue;
+                if (fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory()) {
+                    results.push({ file_path: filePath, target: targetPath, kind });
+                }
+            }
+        }
+        return results;
+    }
     pruneSpuriousNodes(workspaceRoot) {
         const { spurious, missingFile } = this.findSpuriousAndMissingFileNodes(workspaceRoot);
         const candidates = [...spurious, ...missingFile];
@@ -3351,6 +3417,56 @@ class DevMindDatabase {
     likeEscape(s) {
         return s.replace(/[\\%_]/g, ch => '\\' + ch);
     }
+    /**
+     * True when `targetPath` (a computed `graph/`/`vectors/` JSON path) does NOT land strictly
+     * inside `containerDir` as a real file — i.e. writing there would be writing to a directory,
+     * not a file inside one. Guards `writeGraphToDisk`/`writeVectorsToDisk` against a malformed
+     * node whose `file_path` IS a directory (the workspace root, or a repo root itself): observed
+     * in production as an EISDIR crash on `devsmind sync`, because `toRepoRelativePath` collapses
+     * to `''` (workspace root) or `'{repo}/'` (a repo root) for those, which `diskRelPath` then
+     * turns into `''`/a trailing-slash string/`'..'` depending on which branch collapsed — every
+     * one of which makes `path.join(containerDir, diskRelPath)` resolve to `containerDir` itself
+     * or some directory already inside it, never a fresh `.json` file. Multiple checks on purpose:
+     * the empty/trailing-slash/`..`-relative cases catch it structurally (works even on a brand
+     * new brain where nothing exists on disk yet, where an EISDIR would instead be a silent
+     * file-where-directory-belongs corruption); the existsSync+isDirectory check is a catch-all
+     * for any other collapse shape not foreseen above (existsSync is checked first specifically so
+     * a normal not-yet-written target — the common case — never reaches statSync at all). Callers
+     * already wrap their whole body in a try/catch that logs and returns, so nothing extra is
+     * needed here for a statSync that throws for some other reason (a permission error, a race).
+     * `devsmind analyze --fix` deprecates the node actually causing this; this only ever refuses
+     * the write, never touches the node.
+     */
+    isDegenerateDiskJsonPath(containerDir, diskRelPath, targetPath) {
+        if (!diskRelPath || diskRelPath.endsWith('/') || diskRelPath.endsWith('\\'))
+            return true;
+        const relToContainer = path.relative(containerDir, targetPath);
+        if (relToContainer === '' || relToContainer.startsWith('..'))
+            return true;
+        return fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory();
+    }
+    /**
+     * True when `filePath` ITSELF can never resolve to a valid `graph/`/`vectors/` JSON target —
+     * i.e. `isDegenerateDiskJsonPath`'s first two checks (empty/trailing-slash/`..`-collapsing
+     * `diskRelPath`), never its third (existsSync+isDirectory, which is about a stray directory
+     * left on disk, not about the file_path being bad — that case is exactly what
+     * `findStrayOutputDirs` fixes, and can legitimately happen for a perfectly healthy file_path,
+     * so it must NOT be treated as permanent here). Deliberately does no filesystem I/O — pure
+     * string logic, cheap enough to call for every distinct file_path a full `syncToDisk` touches.
+     * Used to recognize a file_path that's structurally unfixable no matter how many times a write
+     * is retried, as opposed to one that's merely blocked by removable disk cruft.
+     */
+    isFilePathStructurallyDegenerate(filePath) {
+        const workspaceRoot = (0, config_1.canonicalizePath)(path.dirname(this.dbPath));
+        const absPath = (0, config_1.canonicalizePath)(filePath);
+        const repoRelPath = this.toRepoRelativePath(absPath);
+        const diskRelPath = repoRelPath.replace(/^\{([^}]+)\}/, '$1').replace(/\.[^/.]+$/, '.json');
+        if (!diskRelPath || diskRelPath.endsWith('/') || diskRelPath.endsWith('\\'))
+            return true;
+        const graphDir = path.join(workspaceRoot, 'graph');
+        const relToContainer = path.relative(graphDir, path.join(graphDir, diskRelPath));
+        return relToContainer === '' || relToContainer.startsWith('..');
+    }
     writeGraphToDisk(filePath) {
         try {
             if (!filePath)
@@ -3361,7 +3477,12 @@ class DevMindDatabase {
             const repoRelPath = this.toRepoRelativePath(absPath);
             // E.g., "{harrir-web}/app/page.tsx" -> "graph/harrir-web/app/page.json"
             const diskRelPath = repoRelPath.replace(/^\{([^}]+)\}/, '$1').replace(/\.[^/.]+$/, '.json');
-            const graphJsonPath = path.join(workspaceRoot, 'graph', diskRelPath);
+            const graphDir = path.join(workspaceRoot, 'graph');
+            const graphJsonPath = path.join(graphDir, diskRelPath);
+            if (this.isDegenerateDiskJsonPath(graphDir, diskRelPath, graphJsonPath)) {
+                console.warn(`⚠️ Skipped writing graph JSON: a node's file_path resolves to a directory, not a file (${absPath}) — run \`devsmind analyze --fix\` to clean it up.`);
+                return;
+            }
             // Get all nodes in this file (active AND deprecated). A node's file_path is either
             // exactly this absolute path, or (for the rare node spanning multiple files) a ", "-joined
             // list containing it. We anchor on the FULL absolute path with ", " boundaries and escape
@@ -3442,7 +3563,14 @@ class DevMindDatabase {
             const absPath = (0, config_1.canonicalizePath)(filePath);
             const repoRelPath = this.toRepoRelativePath(absPath);
             const diskRelPath = repoRelPath.replace(/^\{([^}]+)\}/, '$1').replace(/\.[^/.]+$/, '.json');
-            const vectorsJsonPath = path.join(workspaceRoot, 'vectors', diskRelPath);
+            const vectorsDir = path.join(workspaceRoot, 'vectors');
+            const vectorsJsonPath = path.join(vectorsDir, diskRelPath);
+            // Same guard as writeGraphToDisk — see isDegenerateDiskJsonPath's comment for why this
+            // happens and what it means.
+            if (this.isDegenerateDiskJsonPath(vectorsDir, diskRelPath, vectorsJsonPath)) {
+                console.warn(`⚠️ Skipped writing vectors JSON: a node's file_path resolves to a directory, not a file (${absPath}) — run \`devsmind analyze --fix\` to clean it up.`);
+                return;
+            }
             const absLower = absPath.toLowerCase();
             const absEscLower = this.likeEscape(absPath).toLowerCase();
             const stmt = this.db.prepare(`
@@ -3474,20 +3602,50 @@ class DevMindDatabase {
             console.warn('⚠️ SQLite warning: Failed to write vectors JSON to disk:', err);
         }
     }
-    /** Force-syncs all database nodes and workflows to disk JSON files. */
+    /**
+     * Force-syncs all database nodes, vectors, and workflows to disk JSON files. This is the
+     * write-back half of `devsmind sync` (paired with `syncFromDisk`, which reads `vectors/*.json`
+     * into `node_vectors` — see its comment). Vectors are re-written here for the same reason
+     * graph JSON is: normal operation already keeps `vectors/` current (`writeVectorsToDisk` runs
+     * immediately alongside every embedding write), but `sync` exists precisely for the abnormal
+     * case — recovering a `.devmind` after `vectors/*.json` was deleted/corrupted independently of
+     * the DB, or after a past write silently failed (e.g. the directory-typed file_path bug
+     * `isDegenerateDiskJsonPath` now catches) — so leaving vectors out of the force-resync
+     * defeated half the point of running it.
+     *
+     * A file_path shared by at least one ACTIVE node is always re-attempted, deprecated or not —
+     * a deprecated node sharing a real file with a live one still needs its `deprecated:1` flag
+     * kept current on disk. A file_path held ONLY by deprecated nodes is skipped when it's also
+     * `isFilePathStructurallyDegenerate` (a directory rather than a file — `deprecateNode` already
+     * wrote it once, at the moment it was deprecated, so nothing new would come of retrying):
+     * without this, a node deprecated for exactly this reason produced the identical "Skipped
+     * writing graph JSON" warning on every single future `sync`, forever, since deprecating a node
+     * never clears its (already-garbage) file_path — indistinguishable from the bug never having
+     * been fixed at all.
+     */
     syncToDisk() {
         try {
-            const rows = this.db.prepare('SELECT DISTINCT file_path FROM nodes').all();
-            const filePaths = new Set();
+            const rows = this.db.prepare('SELECT DISTINCT file_path, deprecated FROM nodes').all();
+            const activeFilePaths = new Set();
+            const allFilePaths = new Set();
             for (const row of rows) {
-                if (row.file_path) {
-                    for (const p of row.file_path.split(',').map(s => s.trim()).filter(Boolean)) {
-                        filePaths.add(p);
-                    }
+                if (!row.file_path)
+                    continue;
+                for (const p of row.file_path.split(',').map(s => s.trim()).filter(Boolean)) {
+                    allFilePaths.add(p);
+                    if (!row.deprecated)
+                        activeFilePaths.add(p);
+                }
+            }
+            const filePaths = new Set();
+            for (const p of allFilePaths) {
+                if (activeFilePaths.has(p) || !this.isFilePathStructurallyDegenerate(p)) {
+                    filePaths.add(p);
                 }
             }
             for (const filePath of filePaths) {
                 this.writeGraphToDisk(filePath);
+                this.writeVectorsToDisk(filePath);
             }
             const workflowRows = this.db.prepare('SELECT id FROM workflows').all();
             for (const row of workflowRows) {