monomind 1.11.5 → 1.11.7

package/packages/@monomind/cli/dist/src/routing/llm-caller.js

@@ -0,0 +1,109 @@
+/**
+ * Claude Code (headless) LLM caller for semantic-routing fallback.
+ *
+ * Monomind always runs on top of Claude Code, so low-confidence route
+ * classification is delegated to the local `claude` CLI in headless print
+ * mode — NOT to the Anthropic API with a managed key. There is no
+ * `@anthropic-ai/sdk` dependency and no `ANTHROPIC_API_KEY` requirement: the
+ * host's existing Claude Code auth is reused.
+ *
+ * The returned function matches `LLMFallbackConfig.llmCaller` from
+ * `@monomind/routing` — `(prompt: string) => Promise<string>`. When the
+ * `claude` CLI is unavailable it throws, which the routing layer already
+ * catches and degrades to the best semantic match.
+ */
+import { spawn, execSync } from 'child_process';
+import { tmpdir } from 'os';
+/** Default model for routing fallback — Haiku is fast and cheap for slug classification. */
+const DEFAULT_ROUTING_MODEL = 'haiku';
+/**
+ * Max time to wait for a single classification before giving up.
+ * `claude --print` is a full headless session (cold start ~10s, can spike),
+ * so this is generous; the routing layer degrades to the best semantic match
+ * on timeout rather than blocking the caller.
+ */
+const DEFAULT_TIMEOUT_MS = 45_000;
+let claudeAvailable = null;
+/** Cheap, cached check that the `claude` CLI is installed and on PATH. */
+export function isClaudeCodeAvailable() {
+    if (claudeAvailable !== null)
+        return claudeAvailable;
+    try {
+        execSync('claude --version', { encoding: 'utf-8', stdio: 'pipe', timeout: 5000, windowsHide: true });
+        claudeAvailable = true;
+    }
+    catch {
+        claudeAvailable = false;
+    }
+    return claudeAvailable;
+}
+/**
+ * Build an `llmCaller` that delegates a classification prompt to a headless
+ * Claude Code agent (`claude --print --model <model> -- <prompt>`).
+ *
+ * Returns `null` when the `claude` CLI is not available, so callers can omit
+ * `llmFallback` entirely and let routing run keyword + semantic only.
+ */
+export function createClaudeLLMCaller(options = {}) {
+    if (!isClaudeCodeAvailable())
+        return null;
+    const model = options.model ?? DEFAULT_ROUTING_MODEL;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const cwd = options.cwd ?? tmpdir();
+    return (prompt) => new Promise((resolve, reject) => {
+        const env = { ...process.env };
+        // Don't let the child detect a "nested" session.
+        delete env.CLAUDE_SESSION_ID;
+        delete env.CLAUDE_PARENT_SESSION_ID;
+        // Constrain to a pure one-shot classifier:
+        //  --strict-mcp-config (with no --mcp-config) loads ZERO MCP servers, so
+        //    the child never loads monomind's own MCP server — avoids latency and
+        //    a potential routing→MCP→routing recursion.
+        //  --no-session-persistence keeps throwaway classification calls out of
+        //    the user's session history.
+        //  `--` terminates option parsing so a prompt can't smuggle flags.
+        const child = spawn('claude', ['--print', '--model', model, '--strict-mcp-config', '--no-session-persistence', '--', prompt], {
+            cwd,
+            env,
+            // 'ignore' closes stdin at spawn so `claude --print` doesn't block on EOF.
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            try {
+                child.kill('SIGTERM');
+            }
+            catch { /* may already be dead */ }
+            settled = true;
+            reject(new Error(`claude routing fallback timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        timer.unref?.();
+        child.stdout?.on('data', (d) => { stdout += d.toString(); });
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(err);
+        });
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(stderr.trim() || `claude exited with code ${code}`));
+            }
+        });
+    });
+}
+//# sourceMappingURL=llm-caller.js.map

package/packages/@monomind/cli/dist/src/update/checker.js

@@ -17,7 +17,6 @@ const DEFAULT_CONFIG = {
     priority: {
         '@monomind/security': 'critical',
         '@monomind/cli': 'high',
-        '@monomind/embeddings': 'normal',
     },
     exclude: [],
 };

package/packages/@monomind/cli/dist/src/update/validator.js

@@ -6,12 +6,8 @@ import * as semver from 'semver';
 // Known compatibility matrix between @monomind packages
 const COMPATIBILITY_MATRIX = {
     '@monomind/cli': {
-        '@monomind/embeddings': { minVersion: '3.0.0-alpha.1' },
         '@monomind/security': { minVersion: '3.0.0-alpha.1' },
     },
-    '@monomind/embeddings': {
-        '@monomind/cli': { minVersion: '3.0.0-alpha.50' },
-    },
 };
 // Known breaking changes by version
 const BREAKING_CHANGES = {
@@ -22,12 +18,6 @@ const BREAKING_CHANGES = {
             'Agent spawning now requires type parameter',
         ],
     },
-    '@monomind/embeddings': {
-        '3.0.0': [
-            'Switched from better-sqlite3 to sql.js',
-            'New initialization required with initEmbeddings()',
-        ],
-    },
 };
 export function validateUpdate(packageName, fromVersion, toVersion, installedPackages) {
     const result = {

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.11.5",
+  "version": "1.11.7",
   "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",
@@ -68,7 +68,6 @@
     "dist",
     "bin",
     ".claude",
-    "bundled-graph",
     "scripts",
     "README.md"
   ],
@@ -88,26 +87,20 @@
   "dependencies": {
     "ws": "^8.18.0",
     "@noble/ed25519": "^2.1.0",
-    "@monoes/monograph": "^1.1.0",
+    "@monoes/monograph": "^1.2.0",
     "@monomind/aidefence": "workspace:*",
-    "@monomind/embeddings": "workspace:*",
     "@monomind/guidance": "workspace:*",
     "@monomind/mcp": "workspace:*",
+    "@monomind/routing": "workspace:*",
     "graphology": "^0.25.4",
-    "graphology-communities-louvain": "^2.0.1",
     "graphology-metrics": "^2.4.0",
-    "graphology-shortest-path": "^2.0.2",
-    "graphology-traversal": "^0.3.1",
-    "graphology-types": "^0.24.7",
-    "chokidar": "^3.6.0",
     "semver": "^7.6.0"
   },
   "optionalDependencies": {
     "sql.js": "^1.14.1",
     "@monoes/memory": "workspace:*",
     "@monomind/plugin-gastown-bridge": "^0.1.3",
-    "agentic-flow": "^3.0.0-alpha.1",
-    "@anthropic-ai/sdk": "*"
+    "agentic-flow": "^3.0.0-alpha.1"
   },
   "publishConfig": {
     "access": "public",

package/packages/@monomind/guidance/package.json

@@ -140,8 +140,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@monomind/hooks": "workspace:*",
-    "@monoes/memory": "workspace:*"
+    "@monomind/hooks": "workspace:*"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

package/packages/@monomind/cli/bundled-graph/dist/src/build.js

@@ -1,73 +0,0 @@
-import Graph from 'graphology';
-// Mirrors upstream graphify's _normalize_id: lowercase + collapse non-alphanumeric to underscores.
-function normalizeId(s) {
-    return s.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '').toLowerCase();
-}
-/**
- * Build a graphology Graph from extracted nodes and edges.
- * Deduplicates nodes by id, merges parallel edges with higher weight.
- */
-export function buildGraph(extraction) {
-    const graph = new Graph({ type: 'directed', multi: false });
-    // Add all nodes — merge attributes if already present (dedup by id)
-    for (const node of extraction.nodes) {
-        if (!graph.hasNode(node.id)) {
-            graph.addNode(node.id, { ...node });
-        }
-        else {
-            graph.mergeNodeAttributes(node.id, { ...node });
-        }
-    }
-    // Build normalized ID lookup to remap mismatched edge endpoints before stubbing.
-    const normToId = new Map();
-    graph.forEachNode((id) => {
-        normToId.set(normalizeId(id), id);
-    });
-    // Add edges — skip self-loops, remap via normalization, stub only true externals
-    for (const edge of extraction.edges) {
-        let src = edge.source;
-        let tgt = edge.target;
-        if (!graph.hasNode(src)) {
-            const remapped = normToId.get(normalizeId(src));
-            if (remapped) {
-                src = remapped;
-            }
-            else {
-                graph.addNode(src, { id: src, label: src, fileType: 'unknown', sourceFile: '' });
-                normToId.set(normalizeId(src), src);
-            }
-        }
-        if (!graph.hasNode(tgt)) {
-            const remapped = normToId.get(normalizeId(tgt));
-            if (remapped) {
-                tgt = remapped;
-            }
-            else {
-                graph.addNode(tgt, { id: tgt, label: tgt, fileType: 'unknown', sourceFile: '' });
-                normToId.set(normalizeId(tgt), tgt);
-            }
-        }
-        if (src === tgt)
-            continue;
-        try {
-            graph.addEdge(src, tgt, {
-                relation: edge.relation,
-                confidence: edge.confidence,
-                confidenceScore: edge.confidenceScore,
-                weight: edge.weight ?? 1,
-                sourceFile: edge.sourceFile,
-                sourceLocation: edge.sourceLocation,
-            });
-        }
-        catch {
-            // Edge already exists — bump its weight
-            const existing = graph.edge(src, tgt);
-            if (existing) {
-                const prev = graph.getEdgeAttribute(existing, 'weight') ?? 1;
-                graph.setEdgeAttribute(existing, 'weight', prev + 1);
-            }
-        }
-    }
-    return graph;
-}
-//# sourceMappingURL=build.js.map

package/packages/@monomind/cli/bundled-graph/dist/src/cluster.js

@@ -1,120 +0,0 @@
-import Graph from 'graphology';
-export async function detectCommunities(graph) {
-    let louvainFn = null;
-    try {
-        const mod = await import('graphology-communities-louvain');
-        louvainFn = mod.default;
-    }
-    catch { /* louvain not available */ }
-    if (louvainFn) {
-        try {
-            const assignment = louvainFn(graph);
-            for (const [nodeId, communityId] of Object.entries(assignment)) {
-                graph.setNodeAttribute(nodeId, 'community', communityId);
-            }
-            const communities = {};
-            for (const [nodeId, communityId] of Object.entries(assignment)) {
-                if (!communities[communityId])
-                    communities[communityId] = [];
-                communities[communityId].push(nodeId);
-            }
-            return splitOversizedCommunities(graph, communities, 0.25, louvainFn);
-        }
-        catch { /* fall through */ }
-    }
-    return splitOversizedCommunities(graph, fallbackCluster(graph), 0.25, louvainFn);
-}
-function fallbackCluster(graph) {
-    const dirMap = new Map();
-    let nextId = 0;
-    const communities = {};
-    graph.forEachNode((id, attrs) => {
-        const file = attrs.sourceFile || '';
-        const parts = file.split('/');
-        const dir = parts.length > 1 ? parts.slice(0, -1).join('/') : 'root';
-        if (!dirMap.has(dir))
-            dirMap.set(dir, nextId++);
-        const cid = dirMap.get(dir);
-        graph.setNodeAttribute(id, 'community', cid);
-        if (!communities[cid])
-            communities[cid] = [];
-        communities[cid].push(id);
-    });
-    return communities;
-}
-export function cohesionScore(graph, communityNodes) {
-    const memberSet = new Set(communityNodes);
-    let totalEdges = 0;
-    let internalEdges = 0;
-    graph.forEachEdge((_edge, _attrs, source, target) => {
-        const srcIn = memberSet.has(source);
-        const tgtIn = memberSet.has(target);
-        if (srcIn || tgtIn) {
-            totalEdges++;
-            if (srcIn && tgtIn)
-                internalEdges++;
-        }
-    });
-    return totalEdges === 0 ? 1.0 : internalEdges / totalEdges;
-}
-export function splitOversizedCommunities(graph, communities, threshold = 0.25, louvainFn = null) {
-    const maxSize = threshold * graph.order;
-    const allIds = Object.keys(communities).map(Number);
-    let nextId = allIds.length > 0 ? Math.max(...allIds) + 1 : 0;
-    for (const [cidStr, members] of Object.entries(communities)) {
-        if (members.length <= maxSize)
-            continue;
-        const cid = Number(cidStr);
-        // Attempt topology-based second pass via Louvain on the community subgraph
-        if (louvainFn && members.length >= 10) {
-            try {
-                const memberSet = new Set(members);
-                const subG = new Graph({ type: 'undirected', multi: false });
-                for (const nodeId of members)
-                    subG.addNode(nodeId);
-                graph.forEachEdge((_e, _a, source, target) => {
-                    if (memberSet.has(source) && memberSet.has(target) && source !== target && !subG.hasEdge(source, target))
-                        subG.addEdge(source, target);
-                });
-                const subAssignment = louvainFn(subG);
-                const subCommunityCount = new Set(Object.values(subAssignment)).size;
-                if (subCommunityCount > 1 && subCommunityCount <= Math.ceil(members.length / 2)) {
-                    const subIdMap = new Map();
-                    const newSubIds = {};
-                    for (const [nodeId, localId] of Object.entries(subAssignment)) {
-                        if (!subIdMap.has(localId))
-                            subIdMap.set(localId, nextId++);
-                        const globalId = subIdMap.get(localId);
-                        graph.setNodeAttribute(nodeId, 'community', globalId);
-                        if (!newSubIds[globalId])
-                            newSubIds[globalId] = [];
-                        newSubIds[globalId].push(nodeId);
-                    }
-                    delete communities[cid];
-                    Object.assign(communities, newSubIds);
-                    continue;
-                }
-            }
-            catch { /* fall through to directory heuristic */ }
-        }
-        // Directory heuristic fallback
-        const subMap = new Map();
-        const newSubIds = {};
-        for (const nodeId of members) {
-            const file = graph.getNodeAttribute(nodeId, 'sourceFile') || '';
-            const parts = file.split('/');
-            const parentDir = parts.length > 1 ? parts[parts.length - 2] : 'root';
-            if (!subMap.has(parentDir))
-                subMap.set(parentDir, nextId++);
-            const subId = subMap.get(parentDir);
-            graph.setNodeAttribute(nodeId, 'community', subId);
-            if (!newSubIds[subId])
-                newSubIds[subId] = [];
-            newSubIds[subId].push(nodeId);
-        }
-        delete communities[cid];
-        Object.assign(communities, newSubIds);
-    }
-    return communities;
-}
-//# sourceMappingURL=cluster.js.map

package/packages/@monomind/cli/bundled-graph/package.json

@@ -1,57 +0,0 @@
-{
-  "name": "@monomind/graph",
-  "version": "1.4.0",
-  "type": "module",
-  "description": "Knowledge graph engine for monomind — AST extraction, graph construction, community detection, and persistent codebase understanding",
-  "main": "./dist/src/index.js",
-  "types": "./dist/src/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/src/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "clean": "rm -rf dist"
-  },
-  "dependencies": {
-    "graphology": "^0.25.4",
-    "graphology-types": "^0.24.7",
-    "graphology-communities-louvain": "^2.0.1",
-    "graphology-shortest-path": "^2.0.2",
-    "graphology-traversal": "^0.3.1",
-    "graphology-metrics": "^2.4.0",
-    "chokidar": "^3.6.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.4"
-  },
-  "optionalDependencies": {
-    "node-tree-sitter": "^0.22.4",
-    "tree-sitter-typescript": "^0.23.2",
-    "tree-sitter-javascript": "^0.23.1",
-    "tree-sitter-python": "^0.23.6",
-    "tree-sitter-go": "^0.23.4",
-    "tree-sitter-rust": "^0.23.2",
-    "tree-sitter-java": "^0.23.5",
-    "tree-sitter-c": "^0.23.4",
-    "tree-sitter-cpp": "^0.23.4",
-    "tree-sitter-ruby": "^0.23.1",
-    "tree-sitter-c-sharp": "^0.23.1",
-    "tree-sitter-kotlin": "^0.3.9",
-    "tree-sitter-swift": "^0.6.1",
-    "tree-sitter-scala": "^0.23.4",
-    "tree-sitter-php": "^0.23.11"
-  },
-  "publishConfig": {
-    "access": "public"
-  }
-}

package/packages/@monomind/cli/dist/src/commands/embeddings.d.ts

@@ -1,18 +0,0 @@
-/**
- * CLI Embeddings Command
- * Vector embeddings, semantic search, similarity operations
- *
- * Features:
- * - Multiple providers: OpenAI, Transformers.js, Agentic-Flow, Mock
- * - Document chunking with overlap
- * - L2/L1/minmax/zscore normalization
- * - Hyperbolic embeddings (Poincaré ball)
- * - Neural substrate integration
- * - Persistent SQLite cache
- *
- * github.com/nokhodian/monomind
- */
-import type { Command } from '../types.js';
-export declare const embeddingsCommand: Command;
-export default embeddingsCommand;
-//# sourceMappingURL=embeddings.d.ts.map