monomind 1.6.9 → 1.7.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,129 @@ 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.
+ * 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.
  */
 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 {
-        // 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'],
+        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,
         });
-        // 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)');
     }
     catch (_err) {
-        // Non-fatal — @monomind/graph is an optional enhancement.
-        result.skipped.push('knowledge graph: @monomind/graph not available');
+        result.skipped.push('knowledge graph: graphify update failed');
+    }
+    // 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.
+ * 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,
+        });
+        result.created.files.push('doctor --install (health check + auto-fix)');
+    }
+    catch {
+        result.skipped.push('doctor: auto-fix skipped (run: monomind doctor --install)');
     }
 }
 /**
@@ -1811,6 +1908,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/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