monomind 1.6.9 → 1.8.0

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

@@ -11,6 +11,7 @@ import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { detectPlatform, DEFAULT_INIT_OPTIONS } from './types.js';
+import { writeSharedInstructions } from './shared-instructions-generator.js';
 import { generateSettingsJson, generateSettings } from './settings-generator.js';
 import { generateMCPJson } from './mcp-generator.js';
 import { generateStatuslineScript } from './statusline-generator.js';
@@ -66,7 +67,7 @@ const SKILLS_MAP = {
 const COMMANDS_MAP = {
     core: [
         'monomind-help.md', 'monomind-swarm.md', 'monomind-memory.md',
-        'monomind-do.md', 'monomind-idea.md', 'monomind-createtask.md', 'monomind-repeat.md',
+        'monomind-do.md', 'monomind-idea.md', 'monomind-improve.md', 'monomind-createtask.md', 'monomind-repeat.md',
         'mastermind.md', 'list-agents.md', 'use-agent.md',
         'metrics.md', 'tokens.md', 'browse.md', 'sparc.md', 'ts.md',
     ],
@@ -281,12 +282,18 @@ export async function executeInit(options) {
         if (options.components.claudeMd) {
             await writeClaudeMd(targetDir, options, result);
         }
+        // Generate .agents/shared_instructions.md + seed project memory
+        writeSharedInstructions(targetDir, options.force, result);
         // Count enabled hooks
         result.summary.hooksEnabled = countEnabledHooks(options);
         // Build knowledge graph in background (non-blocking)
         if (options.components.graphify) {
             await initKnowledgeGraph(targetDir, result);
         }
+        // Start daemon with background workers (non-blocking)
+        await startDaemonBackground(targetDir, result);
+        // Run doctor auto-fix (non-blocking, best-effort)
+        await runDoctorFix(targetDir, result);
     }
     catch (error) {
         result.success = false;
@@ -295,39 +302,72 @@ export async function executeInit(options) {
     return result;
 }
 /**
- * Spawn a background process to build the @monomind/graph knowledge graph.
- * Fire-and-forget: init does not wait for the ~20s graph build to complete.
- * Non-fatal: if @monomind/graph 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 { mkdirSync } = await import('fs');
+    const outputDir = path.join(targetDir, '.monomind', 'graph');
+    mkdirSync(outputDir, { recursive: true });
     try {
-        // Verify the package is resolvable before spawning — fast path to skip gracefully.
-        await import('@monomind/graph');
-        const outputDir = path.join(targetDir, '.monomind', 'graph');
-        const { spawn } = await import('child_process');
-        // Escape single quotes in path strings for the inline ES module script.
-        const safePath = targetDir.replace(/'/g, "\\'");
-        const safeOut = outputDir.replace(/'/g, "\\'");
-        const script = `
-import('@monomind/graph').then(({ buildGraph }) =>
-  buildGraph('${safePath}', { codeOnly: true, outputDir: '${safeOut}' })
-).then(r => console.log('[graph] built: ' + r.filesProcessed + ' files, ' + r.analysis.stats.nodes + ' nodes'))
- .catch(e => console.error('[graph] build failed:', e.message));
-`;
-        const child = spawn(process.execPath, ['--input-type=module'], {
-            stdio: ['pipe', 'ignore', 'ignore'],
-            detached: true,
+        const { buildAsync } = await import('@monoes/monograph');
+        buildAsync(targetDir, { codeOnly: false })
+            .then(() => { })
+            .catch((err) => {
+            console.warn('[monograph] Background build failed:', err);
+        });
+        result.created.files.push('.monomind/monograph.db (knowledge graph building in background)');
+    }
+    catch (err) {
+        result.skipped.push('knowledge graph: monograph package unavailable');
+    }
+}
+/**
+ * Start the monomind daemon with background workers.
+ * Non-fatal: if daemon fails to start, init continues.
+ */
+async function startDaemonBackground(targetDir, result) {
+    try {
+        const { execSync } = await import('child_process');
+        // Check if daemon is already running
+        const pidFile = path.join(targetDir, '.monomind', 'daemon.pid');
+        const { existsSync, readFileSync } = await import('fs');
+        if (existsSync(pidFile)) {
+            const pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+            try {
+                process.kill(pid, 0);
+                result.skipped.push('daemon: already running (PID ' + pid + ')');
+                return;
+            }
+            catch { /* stale PID, continue */ }
+        }
+        execSync('npx monomind@latest daemon start --background', {
+            cwd: targetDir,
+            stdio: 'ignore',
+            timeout: 15000,
+        });
+        result.created.files.push('monomind daemon (background workers started)');
+    }
+    catch {
+        result.skipped.push('daemon: could not auto-start (run: monomind daemon start)');
+    }
+}
+/**
+ * Run doctor --install to auto-fix any remaining issues.
+ * Non-fatal: best-effort health check and auto-install.
+ */
+async function runDoctorFix(targetDir, result) {
+    try {
+        const { execSync } = await import('child_process');
+        execSync('npx monomind@latest doctor --install', {
             cwd: targetDir,
+            stdio: 'ignore',
+            timeout: 120000,
         });
-        // Write the script to stdin then close so node processes it.
-        child.stdin?.write(script);
-        child.stdin?.end();
-        child.unref();
-        result.created.files.push('.monomind/graph/ (knowledge graph building in background)');
+        result.created.files.push('doctor --install (health check + auto-fix)');
     }
-    catch (_err) {
-        // Non-fatal — @monomind/graph is an optional enhancement.
-        result.skipped.push('knowledge graph: @monomind/graph not available');
+    catch {
+        result.skipped.push('doctor: auto-fix skipped (run: monomind doctor --install)');
     }
 }
 /**
@@ -1811,6 +1851,37 @@ async function writeClaudeMd(targetDir, options, result) {
         catch {
             // Non-critical — global CLAUDE.md is best-effort
         }
+        // Also inject the token-display hook into ~/.claude/settings.json
+        const globalSettingsPath = path.join(globalClaudeDir, 'settings.json');
+        try {
+            if (!fs.existsSync(globalClaudeDir)) {
+                fs.mkdirSync(globalClaudeDir, { recursive: true });
+            }
+            let globalSettings = {};
+            if (fs.existsSync(globalSettingsPath)) {
+                try {
+                    globalSettings = JSON.parse(fs.readFileSync(globalSettingsPath, 'utf-8'));
+                }
+                catch { /* malformed JSON — start fresh */ }
+            }
+            // Inject SessionStart token hook if not already present
+            const hooks = globalSettings.hooks ?? {};
+            const sessionStartHooks = hooks['SessionStart'] ?? [];
+            const tokenHookCommand = 'npx --yes monomind@latest tokens today';
+            const alreadyPresent = sessionStartHooks.some(entry => Array.isArray(entry.hooks) && entry.hooks.some(h => h.command === tokenHookCommand));
+            if (!alreadyPresent) {
+                sessionStartHooks.push({
+                    hooks: [{ type: 'command', command: tokenHookCommand, timeout: 10000 }],
+                });
+                hooks['SessionStart'] = sessionStartHooks;
+                globalSettings.hooks = hooks;
+                fs.writeFileSync(globalSettingsPath, JSON.stringify(globalSettings, null, 2), 'utf-8');
+                result.created.files.push('~/.claude/settings.json (added token hook)');
+            }
+        }
+        catch {
+            // Non-critical — global settings hook is best-effort
+        }
     }
 }
 /**

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/init/shared-instructions-generator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared Instructions Generator
+ *
+ * Auto-detects project profile and generates:
+ * 1. .agents/shared_instructions.md  — prepended to every agent prompt
+ * 2. Memory seeds — pre-loaded into AgentDB so agents start with project best practices
+ */
+import type { InitResult } from './types.js';
+export interface ProjectProfile {
+    name: string;
+    description: string;
+    language: 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'unknown';
+    framework: string[];
+    packageManager: 'pnpm' | 'npm' | 'yarn' | 'bun' | 'cargo' | 'poetry' | 'uv' | 'pip' | 'unknown';
+    testFramework: string[];
+    buildTool: string[];
+    isMonorepo: boolean;
+    monorepoTool: string;
+    database: string[];
+    hasDocker: boolean;
+    hasCi: boolean;
+    ciTool: string;
+    maxFileLines: number | null;
+    srcDir: string;
+    testDir: string;
+    version: string;
+    isPublicNpm: boolean;
+}
+export declare function detectProjectProfile(cwd: string): ProjectProfile;
+export declare function generateSharedInstructions(profile: ProjectProfile): string;
+export interface MemorySeed {
+    key: string;
+    value: string;
+    namespace: string;
+}
+export declare function generateMemorySeeds(profile: ProjectProfile): MemorySeed[];
+export declare function writeSharedInstructions(cwd: string, force: boolean, result: InitResult): void;
+//# sourceMappingURL=shared-instructions-generator.d.ts.map