monomind 1.7.0 → 1.8.0

package/.claude/commands/monomind-createtask.md

@@ -73,8 +73,8 @@ Parse `$ARGUMENTS` to determine input type:
 
 Run ALL of the following in parallel (skip any that error):
 
-1. **Knowledge graph — suggest**: Call `mcp__monomind__graphify_suggest` with the first 200 chars of `RAW_CONTENT`.
-2. **Knowledge graph — query**: If any specific module/component names appear in `RAW_CONTENT`, call `mcp__monomind__graphify_query` for each (up to 5 queries).
+1. **Knowledge graph — suggest**: Call `mcp__monomind__monograph_suggest` with the first 200 chars of `RAW_CONTENT`.
+2. **Knowledge graph — query**: If any specific module/component names appear in `RAW_CONTENT`, call `mcp__monomind__monograph_query` for each (up to 5 queries).
 3. **Memory search**: Call `mcp__monomind__memory_search` with a summary of the input. Use top 5 results.
 4. **README**: Read `README.md` (first 200 lines). Skip if missing.
 5. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`.

package/.claude/commands/monomind-do.md

@@ -258,7 +258,7 @@ Collect in parallel (skip any that error):
 1. **README**: Read `README.md` (first 200 lines).
 2. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`.
 3. **Memory search**: Call `mcp__monomind__memory_search` with the first task's title.
-4. **Knowledge graph**: Call `mcp__monomind__graphify_suggest` with the first task's title.
+4. **Knowledge graph**: Call `mcp__monomind__monograph_suggest` with the first task's title.
 
 Bundle into `PROJECT_CONTEXT` and include in every agent prompt.
 

package/.claude/commands/monomind-idea.md

@@ -49,7 +49,7 @@ Collect ALL of the following in parallel (skip any that error):
 
 3. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`. Extract name, description, and keywords/tags.
 
-4. **Knowledge graph**: Call `mcp__monomind__graphify_suggest` with the user's prompt (`$ARGUMENTS`). Skip if it errors or returns empty.
+4. **Knowledge graph**: Call `mcp__monomind__monograph_suggest` with the user's prompt (`$ARGUMENTS`). Skip if it errors or returns empty.
 
 5. **Memory search**: Call `mcp__monomind__memory_search` with the user's prompt (`$ARGUMENTS`). Use the top 5 results.
 

package/.claude/commands/monomind-improve.md

@@ -53,7 +53,7 @@ Collect ALL of the following in parallel (skip any that error):
 
 3. **Package manifest**: Read whichever exists first: `package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`. Extract name, description, and keywords/tags.
 
-4. **Knowledge graph**: Call `mcp__monomind__graphify_suggest` with the user's prompt (`$ARGUMENTS`). Skip if it errors or returns empty.
+4. **Knowledge graph**: Call `mcp__monomind__monograph_suggest` with the user's prompt (`$ARGUMENTS`). Skip if it errors or returns empty.
 
 5. **Memory search**: Call `mcp__monomind__memory_search` with the user's prompt (`$ARGUMENTS`). Use the top 5 results.
 
@@ -71,8 +71,8 @@ Spawn 2 agents in parallel via the Agent tool:
 
 Provide it with `$ARGUMENTS` and `PROJECT_CONTEXT`. It must:
 
-1. **Trace the component** — find all files, functions, classes, and modules related to the target. Use `mcp__monomind__graphify_query` for each key term found.
-2. **Map dependencies** — what does the component depend on? What depends on it? Use `mcp__monomind__graphify_shortest_path` for key relationships.
+1. **Trace the component** — find all files, functions, classes, and modules related to the target. Use `mcp__monomind__monograph_query` for each key term found.
+2. **Map dependencies** — what does the component depend on? What depends on it? Use `mcp__monomind__monograph_shortest_path` for key relationships.
 3. **Identify pain points** — look for:
    - Code smells (large files, deep nesting, god objects, duplicated logic)
    - Missing tests or low coverage areas

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "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",
@@ -39,21 +39,6 @@
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "dev": "tsx watch src/index.ts",
-    "build": "tsc",
-    "build:ts": "cd packages/@monomind/cli && npm run build || true",
-    "test": "vitest",
-    "test:ui": "vitest --ui",
-    "test:security": "vitest run packages/__tests__/security/",
-    "lint": "cd packages/@monomind/cli && npm run lint || true",
-    "security:audit": "npm audit --audit-level high",
-    "security:fix": "npm audit fix",
-    "security:test": "npm run test:security",
-    "v1:domains": "npm run build:domains",
-    "v1:swarm": "npm run start:swarm",
-    "v1:security": "npm run security:audit && npm run security:test"
-  },
   "dependencies": {
     "semver": "^7.6.0"
   },
@@ -120,5 +105,20 @@
   "publishConfig": {
     "access": "public",
     "tag": "latest"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "build:ts": "cd packages/@monomind/cli && npm run build || true",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:security": "vitest run packages/__tests__/security/",
+    "lint": "cd packages/@monomind/cli && npm run lint || true",
+    "security:audit": "npm audit --audit-level high",
+    "security:fix": "npm audit fix",
+    "security:test": "npm run test:security",
+    "v1:domains": "npm run build:domains",
+    "v1:swarm": "npm run start:swarm",
+    "v1:security": "npm run security:audit && npm run security:test"
   }
-}
+}

package/packages/@monomind/cli/dist/src/commands/doctor.js

@@ -382,50 +382,31 @@ async function installClaudeCode() {
         return false;
     }
 }
-// Check graphify (Python knowledge graph engine)
-async function checkGraphify() {
+// Check monograph (TypeScript knowledge graph engine, bundled with CLI)
+async function checkMonograph() {
     try {
-        await runCommand('graphify --help');
-        return { name: 'Graphify', status: 'pass', message: 'installed (knowledge graph engine)' };
-    }
-    catch {
-        // Check if Python/uv are available for the fix suggestion
-        let fix = 'pip install graphifyy';
-        try {
-            await runCommand('uv --version');
-            fix = 'uv tool install graphifyy';
+        const __filename = fileURLToPath(import.meta.url);
+        const candidates = [
+            join(dirname(__filename), '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
+            join(dirname(__filename), '..', '..', '..', '..', 'node_modules', '@monomind', 'monograph', 'package.json'),
+        ];
+        if (candidates.some(p => existsSync(p))) {
+            return { name: 'Monograph', status: 'pass', message: 'available (knowledge graph engine)' };
         }
-        catch { }
         return {
-            name: 'Graphify',
+            name: 'Monograph',
             status: 'warn',
-            message: 'Not installed (knowledge graph disabled)',
-            fix
+            message: 'Package not found (knowledge graph disabled)',
+            fix: 'npm install in project root'
         };
     }
-}
-// Install graphify Python package
-async function installGraphify() {
-    try {
-        output.writeln();
-        output.writeln(output.bold('Installing Graphify knowledge graph engine...'));
-        // Prefer uv (fast, isolated), fall back to pip
-        let cmd = 'pip install graphifyy';
-        try {
-            await runCommand('uv --version');
-            cmd = 'uv tool install graphifyy';
-        }
-        catch { }
-        execSync(cmd, { encoding: 'utf8', stdio: 'inherit', timeout: 120000 });
-        output.writeln(output.success('Graphify installed successfully!'));
-        return true;
-    }
-    catch (error) {
-        output.writeln(output.error('Failed to install Graphify'));
-        if (error instanceof Error) {
-            output.writeln(output.dim(error.message));
-        }
-        return false;
+    catch {
+        return {
+            name: 'Monograph',
+            status: 'warn',
+            message: 'Package check failed (knowledge graph may be unavailable)',
+            fix: 'npm install in project root'
+        };
     }
 }
 // Check agentic-flow v1 integration (filesystem-based to avoid slow WASM/DB init)
@@ -491,14 +472,14 @@ export const doctorCommand = {
         {
             name: 'install',
             short: 'i',
-            description: 'Auto-install missing dependencies (Claude Code CLI, Graphify)',
+            description: 'Auto-install missing dependencies (Claude Code CLI)',
             type: 'boolean',
             default: false
         },
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, graphify)',
+            description: 'Check specific component (version, node, npm, config, daemon, memory, api, git, mcp, claude, disk, typescript, monograph)',
             type: 'string'
         },
         {
@@ -540,7 +521,7 @@ export const doctorCommand = {
             checkMcpServers,
             checkDiskSpace,
             checkBuildTools,
-            checkGraphify,
+            checkMonograph,
             checkAgenticFlow
         ];
         const componentMap = {
@@ -557,7 +538,7 @@ export const doctorCommand = {
             'mcp': checkMcpServers,
             'disk': checkDiskSpace,
             'typescript': checkBuildTools,
-            'graphify': checkGraphify,
+            'monograph': checkMonograph,
             'agentic-flow': checkAgenticFlow
         };
         let checksToRun = allChecks;
@@ -616,22 +597,6 @@ export const doctorCommand = {
                     output.writeln(formatCheck(newCheck));
                 }
             }
-            const graphifyResult = results.find(r => r.name === 'Graphify');
-            if (graphifyResult && graphifyResult.status !== 'pass') {
-                const installed = await installGraphify();
-                if (installed) {
-                    const newCheck = await checkGraphify();
-                    const idx = results.findIndex(r => r.name === 'Graphify');
-                    if (idx !== -1) {
-                        results[idx] = newCheck;
-                        const fixIdx = fixes.findIndex(f => f.startsWith('Graphify:'));
-                        if (fixIdx !== -1 && newCheck.status === 'pass') {
-                            fixes.splice(fixIdx, 1);
-                        }
-                    }
-                    output.writeln(formatCheck(newCheck));
-                }
-            }
         }
         // Summary
         const passed = results.filter(r => r.status === 'pass').length;

package/packages/@monomind/cli/dist/src/init/executor.js

@@ -302,82 +302,25 @@ export async function executeInit(options) {
     return result;
 }
 /**
- * Ensure graphify (Python knowledge graph engine) is installed.
- * Tries uv first, falls back to pip. Non-fatal if neither works.
- */
-async function ensureGraphifyInstalled(result) {
-    const { execSync } = await import('child_process');
-    try {
-        execSync('graphify --help', { encoding: 'utf8', stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        const installers = ['uv tool install graphifyy', 'pip install graphifyy'];
-        for (const cmd of installers) {
-            try {
-                execSync(cmd, { encoding: 'utf8', stdio: 'ignore', timeout: 120000 });
-                result.created.files.push('graphify (installed via ' + cmd.split(' ')[0] + ')');
-                return true;
-            }
-            catch { /* try next */ }
-        }
-        result.skipped.push('graphify: could not auto-install (run: uv tool install graphifyy)');
-        return false;
-    }
-}
-/**
- * Initialize graphify fully: install skill, git hooks, build graph, install watch.
- * Fire-and-forget for the graph build — init does not wait for it to complete.
- * Non-fatal: if graphify is unavailable the step is simply skipped.
+ * Initialize the Monograph knowledge graph (native TypeScript, no Python required).
+ * Fire-and-forget build — init does not wait for it to complete.
  */
 async function initKnowledgeGraph(targetDir, result) {
-    const installed = await ensureGraphifyInstalled(result);
-    if (!installed)
-        return;
-    const { execSync, spawn } = await import('child_process');
     const { mkdirSync } = await import('fs');
     const outputDir = path.join(targetDir, '.monomind', 'graph');
     mkdirSync(outputDir, { recursive: true });
-    // 1. Install graphify skill into Claude Code config
     try {
-        execSync('graphify claude install', { cwd: targetDir, stdio: 'ignore', timeout: 10000 });
-        result.created.files.push('graphify claude skill (installed)');
-    }
-    catch { /* non-fatal */ }
-    // 2. Install git hooks (auto-rebuild on commit)
-    try {
-        execSync('graphify hook install', { cwd: targetDir, stdio: 'ignore', timeout: 10000 });
-        result.created.files.push('graphify git hooks (post-commit, post-checkout)');
-    }
-    catch { /* non-fatal */ }
-    // 3. Build knowledge graph in background (fire-and-forget)
-    try {
-        const child = spawn('graphify', ['update', targetDir], {
-            stdio: 'ignore',
-            detached: true,
-            cwd: targetDir,
+        const { buildAsync } = await import('@monoes/monograph');
+        buildAsync(targetDir, { codeOnly: false })
+            .then(() => { })
+            .catch((err) => {
+            console.warn('[monograph] Background build failed:', err);
         });
-        child.unref();
-        result.created.files.push('.monomind/graph/ (knowledge graph building in background)');
+        result.created.files.push('.monomind/monograph.db (knowledge graph building in background)');
     }
-    catch (_err) {
-        result.skipped.push('knowledge graph: graphify update failed');
+    catch (err) {
+        result.skipped.push('knowledge graph: monograph package unavailable');
     }
-    // 4. Start graphify watch daemon (live graph updates on file save)
-    try {
-        const watchChild = spawn('graphify', ['watch', targetDir], {
-            stdio: 'ignore',
-            detached: true,
-            cwd: targetDir,
-        });
-        watchChild.unref();
-        // Store PID so it can be stopped later
-        const { writeFileSync } = await import('fs');
-        const pidPath = path.join(outputDir, 'watch.pid');
-        writeFileSync(pidPath, String(watchChild.pid));
-        result.created.files.push('graphify watch (live graph updates on file save)');
-    }
-    catch { /* non-fatal */ }
 }
 /**
  * Start the monomind daemon with background workers.

package/packages/@monomind/cli/dist/src/init/helpers-generator.js

@@ -22,7 +22,7 @@ STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM)
 for FILE in $STAGED_FILES; do
   if [[ "$FILE" =~ \\.(ts|js|tsx|jsx)$ ]]; then
     echo "  Validating: $FILE"
-    npx @monoes/cli hooks pre-edit --file "$FILE" --validate-syntax 2>/dev/null || true
+    npx @monomind/cli hooks pre-edit --file "$FILE" --validate-syntax 2>/dev/null || true
   fi
 done
 
@@ -451,21 +451,21 @@ export function generateHookHandler() {
         "        var archKeywords = ['understand', 'architecture', 'how does', 'what calls', 'dependency', 'depends on', 'flow', 'how is', 'explain codebase', 'project structure', 'what is the relationship', 'graph', 'knowledge'];",
         '        var promptLower = prompt.toLowerCase();',
         '        var isArchQuery = archKeywords.some(function(k) { return promptLower.includes(k); });',
-        "        var graphJson = require('path').join(process.cwd(), 'graphify-out', 'graph.json');",
+        "        var graphJson = require('path').join(process.cwd(), '.monomind', 'monograph.db');",
         "        var hasGraph = require('fs').existsSync(graphJson);",
         '        if (isArchQuery) {',
         "          var gfOutput = [];",
         "          gfOutput.push('');",
-        "          gfOutput.push('+------- graphify | Knowledge Graph Available ----------------+');",
+        "          gfOutput.push('+------- monograph | Knowledge Graph Available ---------------+');",
         '          if (hasGraph) {',
-        "            gfOutput.push('| Graph: graphify-out/graph.json                              |');",
-        "            gfOutput.push('| Use: mcp__monomind__graphify_god_nodes                     |');",
-        "            gfOutput.push('|      mcp__monomind__graphify_query                         |');",
-        "            gfOutput.push('|      mcp__monomind__graphify_shortest_path                 |');",
-        "            gfOutput.push('| Tip: Call graphify_god_nodes first for architecture overview|');",
+        "            gfOutput.push('| Graph: .monomind/monograph.db                               |');",
+        "            gfOutput.push('| Use: mcp__monomind__monograph_god_nodes                    |');",
+        "            gfOutput.push('|      mcp__monomind__monograph_query                        |');",
+        "            gfOutput.push('|      mcp__monomind__monograph_shortest_path                |');",
+        "            gfOutput.push('| Tip: Call monograph_god_nodes first for architecture overview|');",
         '          } else {',
         "            gfOutput.push('| No graph found. Build with:                                 |');",
-        "            gfOutput.push('|   python -m graphify . (pip install graphifyy[mcp] first)   |');",
+        "            gfOutput.push('|   mcp__monomind__monograph_build                            |');",
         '          }',
         "          gfOutput.push('+--------------------------------------------------------------+');",
         "          console.log(gfOutput.join('\\n'));",
@@ -842,7 +842,7 @@ export function generateIntelligenceStub() {
 /**
  * Generate a minimal auto-memory-hook.mjs fallback for fresh installs.
  * This ESM script handles import/sync/status commands gracefully when
- * @monoes/memory is not installed. Gets overwritten when source copy succeeds.
+ * @monomind/memory is not installed. Gets overwritten when source copy succeeds.
  */
 export function generateAutoMemoryHook() {
     return `#!/usr/bin/env node
@@ -879,17 +879,17 @@ async function loadMemoryPackage() {
   try {
     const { createRequire } = await import('module');
     const require = createRequire(join(PROJECT_ROOT, 'package.json'));
-    return require('@monoes/memory');
+    return require('@monomind/memory');
   } catch { /* fall through */ }
 
-  // Strategy 2: ESM import (works when @monoes/memory is a direct dependency)
-  try { return await import('@monoes/memory'); } catch { /* fall through */ }
+  // Strategy 2: ESM import (works when @monomind/memory is a direct dependency)
+  try { return await import('@monomind/memory'); } catch { /* fall through */ }
 
   // Strategy 3: Walk up from PROJECT_ROOT looking for the package in any node_modules
   let searchDir = PROJECT_ROOT;
   const { parse } = await import('path');
   while (searchDir !== parse(searchDir).root) {
-    const candidate = join(searchDir, 'node_modules', '@monoes', 'memory', 'dist', 'index.js');
+    const candidate = join(searchDir, 'node_modules', '@monomind', 'memory', 'dist', 'index.js');
     if (existsSync(candidate)) {
       try { return await import(\`file://\${candidate}\`); } catch { /* fall through */ }
     }

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

@@ -39,8 +39,9 @@ import { ruvllmWasmTools } from './mcp-tools/ruvllm-tools.js';
 import { wasmAgentTools } from './mcp-tools/wasm-agent-tools.js';
 import { guidanceTools } from './mcp-tools/guidance-tools.js';
 import { autopilotTools } from './mcp-tools/autopilot-tools.js';
-// Knowledge graph tools (graphify)
+// Knowledge graph tools (graphify — deprecated shims + monograph native)
 import { graphifyTools } from './mcp-tools/graphify-tools.js';
+import { monographTools } from './mcp-tools/monograph-tools.js';
 // Coverage-aware routing tools
 import { coverageRouterTools } from './ruvector/coverage-tools.js';
 // A2A Agent Card protocol (source: https://a2a-protocol.org)
@@ -91,7 +92,9 @@ registerTools([
     ...guidanceTools,
     // Autopilot persistent completion tools
     ...autopilotTools,
-    // Knowledge graph (graphify) tools — build, query, report, suggest, health
+    // Knowledge graph — native monograph tools (replaces Python graphify)
+    ...monographTools,
+    // Graphify deprecated shims — proxy to monograph_* tools
     ...graphifyTools,
     // Coverage-aware routing tools
     ...coverageRouterTools,

package/packages/@monomind/cli/dist/src/mcp-tools/graphify-tools.d.ts

@@ -1,73 +1,10 @@
 /**
- * Graphify MCP Tools
+ * Graphify MCP Tools — DEPRECATED SHIMS
  *
- * Bridges graphify's (Python) knowledge graph into monomind's MCP tool surface.
- * Agents can query the codebase knowledge graph without reading files —
- * god_nodes(), query_graph(), shortest_path() give structural understanding
- * in milliseconds vs. reading dozens of source files.
- *
- * Graph is built by `graphify update` (Python CLI) on `monomind init` and
- * stored at .monomind/graph/graph.json (legacy: graphify-out/graph.json).
- * Install: uv tool install graphifyy
- */
-import { type MCPTool } from './types.js';
-/**
- * Build or rebuild the knowledge graph for a directory.
- */
-export declare const graphifyBuildTool: MCPTool;
-/**
- * Query the knowledge graph with natural language.
- */
-export declare const graphifyQueryTool: MCPTool;
-/**
- * Get the most connected (god) nodes — the core abstractions.
- */
-export declare const graphifyGodNodesTool: MCPTool;
-/**
- * Get full details for a specific node.
- */
-export declare const graphifyGetNodeTool: MCPTool;
-/**
- * Find shortest path between two concepts.
- */
-export declare const graphifyShortestPathTool: MCPTool;
-/**
- * Get all nodes in a community (cluster of related components).
- */
-export declare const graphifyGetCommunityTool: MCPTool;
-/**
- * Get graph statistics: node/edge counts, communities, confidence breakdown.
- */
-export declare const graphifyStatsTool: MCPTool;
-/**
- * Find surprising cross-community connections (architectural insights).
- */
-export declare const graphifySurprisesTool: MCPTool;
-/**
- * Generate or open the interactive HTML visualization of the knowledge graph.
- */
-export declare const graphifyVisualizeTool: MCPTool;
-/**
- * Start a background file watcher that rebuilds the knowledge graph + HTML
- * whenever source files change (debounced 2 s).
- */
-export declare const graphifyWatchTool: MCPTool;
-/**
- * Stop the background graph watcher started by graphify_watch.
- */
-export declare const graphifyWatchStopTool: MCPTool;
-/**
- * Read the GRAPH_REPORT.md generated during the last build.
- */
-export declare const graphifyReportTool: MCPTool;
-/**
- * Suggest questions the knowledge graph can answer about the codebase.
- */
-export declare const graphifySuggestTool: MCPTool;
-/**
- * Run a corpus health check on the project files.
+ * All graphify_* tools are deprecated. They proxy to monograph_* tools.
+ * Will be removed in next major release.
  */
-export declare const graphifyHealthTool: MCPTool;
+import type { MCPTool } from './types.js';
 export declare const graphifyTools: MCPTool[];
 export default graphifyTools;
 //# sourceMappingURL=graphify-tools.d.ts.map