monomind 1.18.11 → 1.18.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.18.11",
+  "version": "1.18.12",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/mcp-tools/monograph-tools.js

@@ -1809,6 +1809,207 @@ const monographSuggestAutoTool = {
     },
 };
 // ── Export all tools ──────────────────────────────────────────────────────────
+// ── monograph_dead_code ──────────────────────────────────────────────────────
+const monographDeadCodeTool = {
+    name: 'monograph_dead_code',
+    description: 'Detect dead code: exported functions with zero inbound references, files with no importers, and stale dist build artifacts. Returns structured JSON with candidates grouped by category. Always verify candidates with grep before deleting.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'Absolute path to the repo (defaults to project cwd)' },
+            categories: {
+                type: 'array',
+                items: { type: 'string', enum: ['dead-functions', 'orphan-files', 'stale-dist'] },
+                description: 'Which categories to check (default: all three)',
+            },
+        },
+    },
+    handler: async (input) => {
+        const { openDb } = await import('@monoes/monograph');
+        const repoPath = input.path ?? getProjectCwd();
+        const cats = input.categories ?? ['dead-functions', 'orphan-files', 'stale-dist'];
+        const result = {};
+        const dbPath = join(repoPath, '.monomind', 'monograph.db');
+        let db = null;
+        try {
+            db = openDb(dbPath);
+        }
+        catch {
+            return text(JSON.stringify({ error: 'No monograph index found. Run monograph_build first.' }));
+        }
+        try {
+            if (cats.includes('dead-functions')) {
+                const { detectDeadCodeNodes } = await import('@monoes/monograph');
+                const { readFileSync } = await import('fs');
+                const nodes = detectDeadCodeNodes(db);
+                // Filter out stale graph nodes: verify the function name actually appears in the source file
+                const verified = nodes.filter(n => {
+                    if (!n.filePath)
+                        return false;
+                    try {
+                        const content = readFileSync(join(repoPath, n.filePath), 'utf-8');
+                        return content.includes(n.name);
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                const staleCount = nodes.length - verified.length;
+                result['dead-functions'] = {
+                    count: verified.length,
+                    candidates: verified.map(n => ({
+                        name: n.name,
+                        location: n.filePath ? (n.startLine ? `${n.filePath}:${n.startLine}` : n.filePath) : null,
+                    })),
+                    ...(staleCount > 0 ? { staleIndexEntries: staleCount, note: 'Some graph entries reference deleted functions. Rebuild the index with monograph_build to clean up.' } : {}),
+                };
+            }
+            if (cats.includes('orphan-files')) {
+                const rows = db.prepare(`
+          SELECT n.name, n.file_path,
+            (SELECT COUNT(*) FROM edges e WHERE e.source_id = n.id AND e.relation = 'IMPORTS') as imports_out,
+            (SELECT COUNT(*) FROM edges e WHERE e.target_id = n.id AND e.relation = 'IMPORTS') as imported_by
+          FROM nodes n
+          WHERE n.label = 'File'
+            AND (SELECT COUNT(*) FROM edges e WHERE e.target_id = n.id AND e.relation = 'IMPORTS') = 0
+            AND n.file_path NOT LIKE '%test%'
+            AND n.file_path NOT LIKE '%__tests__%'
+            AND n.file_path NOT LIKE '%spec%'
+            AND n.file_path NOT LIKE '%/index.%'
+            AND n.file_path NOT LIKE 'bin/%'
+            AND n.file_path NOT LIKE 'scripts/%'
+            AND n.file_path NOT LIKE '%/cli.ts'
+            AND n.file_path NOT LIKE '%/cli.js'
+            AND n.file_path NOT LIKE '%/main.ts'
+            AND n.file_path NOT LIKE '%/main.js'
+            AND n.file_path NOT LIKE '%/dist/%'
+            AND n.file_path NOT LIKE '%node_modules%'
+          ORDER BY n.file_path
+        `).all();
+                const withOutbound = rows.filter((r) => r.imports_out > 0);
+                const isolated = rows.filter((r) => r.imports_out === 0);
+                result['orphan-files'] = {
+                    count: withOutbound.length,
+                    note: 'Files that import other modules but nothing imports them. May be lazy-loaded or dynamically imported — verify with grep.',
+                    candidates: withOutbound.map((r) => ({ file: r.file_path, outboundImports: r.imports_out })),
+                    ...(isolated.length > 0 ? {
+                        isolated: {
+                            count: isolated.length,
+                            note: 'Files with zero edges in either direction — likely standalone scripts or entry points.',
+                            files: isolated.map((r) => r.file_path),
+                        },
+                    } : {}),
+                };
+            }
+            if (cats.includes('stale-dist')) {
+                result['stale-dist'] = findStaleDist(repoPath);
+            }
+            return text(JSON.stringify(result, null, 2));
+        }
+        finally {
+            db.close();
+        }
+    },
+};
+function findStaleDist(repoPath) {
+    const { readdirSync, existsSync } = require('fs');
+    const distSrc = join(repoPath, 'dist', 'src');
+    const src = join(repoPath, 'src');
+    // Scan a single package for stale dist artifacts
+    const scanPkg = (pkgPath, pkgName) => {
+        const pkgDistSrc = join(pkgPath, 'dist', 'src');
+        const pkgSrc = join(pkgPath, 'src');
+        if (!existsSync(pkgDistSrc) || !existsSync(pkgSrc))
+            return null;
+        const staleDirs = [];
+        const staleFiles = [];
+        let resourceForks = 0;
+        try {
+            const distDirs = readdirSync(pkgDistSrc, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.') && !d.name.startsWith('._'));
+            const srcDirs = new Set(readdirSync(pkgSrc, { withFileTypes: true })
+                .filter(d => d.isDirectory() && !d.name.startsWith('.'))
+                .map(d => d.name));
+            for (const d of distDirs) {
+                if (!srcDirs.has(d.name))
+                    staleDirs.push(d.name);
+            }
+        }
+        catch { /* skip */ }
+        try {
+            const distFiles = readdirSync(pkgDistSrc)
+                .filter(f => f.endsWith('.js') && !f.startsWith('.') && !f.startsWith('._'));
+            for (const f of distFiles) {
+                const tsName = f.replace(/\.js$/, '.ts');
+                if (!existsSync(join(pkgSrc, tsName)))
+                    staleFiles.push(f);
+            }
+        }
+        catch { /* skip */ }
+        // Count macOS resource fork files
+        const countRF = (dir) => {
+            try {
+                for (const entry of readdirSync(dir, { withFileTypes: true })) {
+                    if (entry.name.startsWith('._'))
+                        resourceForks++;
+                    else if (entry.isDirectory())
+                        countRF(join(dir, entry.name));
+                }
+            }
+            catch { /* skip */ }
+        };
+        countRF(pkgDistSrc);
+        if (staleDirs.length === 0 && staleFiles.length === 0 && resourceForks === 0)
+            return null;
+        return {
+            package: pkgName,
+            staleDirs,
+            staleFiles,
+            ...(resourceForks > 0 ? { macosResourceForks: resourceForks } : {}),
+        };
+    };
+    // Single-package repo
+    if (existsSync(distSrc) && existsSync(src)) {
+        const finding = scanPkg(repoPath, '.');
+        return {
+            count: finding ? finding.staleDirs.length + finding.staleFiles.length : 0,
+            note: 'Directories/files in dist/src/ with no corresponding source. Fix: rm -rf dist && npm run build.',
+            ...(finding ? { findings: [finding] } : {}),
+        };
+    }
+    // Monorepo: scan all packages
+    const packagesDir = join(repoPath, 'packages');
+    if (!existsSync(packagesDir))
+        return { count: 0, note: 'No dist/src or packages/ found' };
+    const findings = [];
+    try {
+        for (const scope of readdirSync(packagesDir, { withFileTypes: true })) {
+            if (!scope.isDirectory())
+                continue;
+            const scopeDir = join(packagesDir, scope.name);
+            if (scope.name.startsWith('@')) {
+                for (const pkg of readdirSync(scopeDir, { withFileTypes: true })) {
+                    if (!pkg.isDirectory())
+                        continue;
+                    const f = scanPkg(join(scopeDir, pkg.name), `${scope.name}/${pkg.name}`);
+                    if (f)
+                        findings.push(f);
+                }
+            }
+            else {
+                const f = scanPkg(scopeDir, scope.name);
+                if (f)
+                    findings.push(f);
+            }
+        }
+    }
+    catch { /* skip */ }
+    return {
+        count: findings.reduce((s, f) => s + (f.staleDirs?.length ?? 0) + (f.staleFiles?.length ?? 0), 0),
+        note: 'Directories/files in dist/src/ with no corresponding source. Fix: rm -rf dist && npm run build.',
+        findings,
+    };
+}
 export const monographTools = [
     monographBuildTool,
     monographQueryTool,
@@ -1854,5 +2055,6 @@ export const monographTools = [
     monographListReposTool,
     monographGroupContractsTool,
     monographGroupStatusTool,
+    monographDeadCodeTool,
 ];
 //# sourceMappingURL=monograph-tools.js.map

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.18.11",
+  "version": "1.18.12",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",