monomind 1.10.0 → 1.10.2

package/packages/@monomind/cli/dist/src/init/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * V1 Init Module
+ * Comprehensive initialization system for Claude Code integration
+ */
+export { type InitOptions, type InitComponents, type InitResult, type HooksConfig, type SkillsConfig, type CommandsConfig, type AgentsConfig, type StatuslineConfig, type MCPConfig, type RuntimeConfig, type EmbeddingsConfig, type PlatformInfo, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
+export { generateSettings, generateSettingsJson, } from './settings-generator.js';
+export { generateMCPConfig, generateMCPJson, } from './mcp-generator.js';
+export { generateStatuslineScript, generateStatuslineHook, } from './statusline-generator.js';
+export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHookHandler, generateIntelligenceStub, generateAutoMemoryHook, } from './helpers-generator.js';
+export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+export type { UpgradeResult } from './executor.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * V1 Init Module
+ * Comprehensive initialization system for Claude Code integration
+ */
+// Types
+export { DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, detectPlatform, } from './types.js';
+// Generators
+export { generateSettings, generateSettingsJson, } from './settings-generator.js';
+export { generateMCPConfig, generateMCPJson, } from './mcp-generator.js';
+export { generateStatuslineScript, generateStatuslineHook, } from './statusline-generator.js';
+export { generatePreCommitHook, generatePostCommitHook, generateSessionManager, generateAgentRouter, generateMemoryHelper, generateHookHandler, generateIntelligenceStub, generateAutoMemoryHook, } from './helpers-generator.js';
+export { generateClaudeMd, generateMinimalClaudeMd, CLAUDE_MD_TEMPLATES, } from './claudemd-generator.js';
+// Main executor
+export { executeInit, executeUpgrade, executeUpgradeWithMissing, default } from './executor.js';
+//# sourceMappingURL=index.js.map

package/packages/@monomind/cli/dist/src/init/mcp-generator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MCP Configuration Generator
+ * Creates .mcp.json for Claude Code MCP server integration
+ * Handles cross-platform compatibility (Windows requires cmd /c wrapper)
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate MCP configuration
+ */
+export declare function generateMCPConfig(options: InitOptions): object;
+/**
+ * Generate .mcp.json as formatted string
+ */
+export declare function generateMCPJson(options: InitOptions): string;
+/**
+ * Generate MCP server add commands for manual setup
+ */
+export declare function generateMCPCommands(options: InitOptions): string[];
+/**
+ * Get platform-specific setup instructions
+ */
+export declare function getPlatformInstructions(): {
+    platform: string;
+    note: string;
+};
+//# sourceMappingURL=mcp-generator.d.ts.map

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

@@ -0,0 +1,99 @@
+/**
+ * MCP Configuration Generator
+ * Creates .mcp.json for Claude Code MCP server integration
+ * Handles cross-platform compatibility (Windows requires cmd /c wrapper)
+ */
+/**
+ * Check if running on Windows
+ */
+function isWindows() {
+    return process.platform === 'win32';
+}
+/**
+ * Generate platform-specific MCP server entry
+ * - Windows: uses 'cmd /c npx' directly
+ * - Unix: uses 'npx' directly (simple, reliable)
+ */
+function createMCPServerEntry(npxArgs, env, additionalProps = {}) {
+    if (isWindows()) {
+        return {
+            command: 'cmd',
+            args: ['/c', 'npx', '-y', ...npxArgs],
+            env,
+            ...additionalProps,
+        };
+    }
+    // Unix: direct npx invocation — simple and reliable
+    return {
+        command: 'npx',
+        args: ['-y', ...npxArgs],
+        env,
+        ...additionalProps,
+    };
+}
+/**
+ * Generate MCP configuration
+ */
+export function generateMCPConfig(options) {
+    const config = options.mcp;
+    const mcpServers = {};
+    const npmEnv = {
+        npm_config_update_notifier: 'false',
+    };
+    // Monomind MCP server (core)
+    if (config.monomind) {
+        mcpServers['monomind'] = createMCPServerEntry(['monomind@latest', 'mcp', 'start'], {
+            ...npmEnv,
+            MONOMIND_MODE: 'v1',
+            MONOMIND_HOOKS_ENABLED: 'true',
+            MONOMIND_TOPOLOGY: options.runtime.topology,
+            MONOMIND_MAX_AGENTS: String(options.runtime.maxAgents),
+            MONOMIND_MEMORY_BACKEND: options.runtime.memoryBackend,
+        }, { autoStart: config.autoStart });
+    }
+    // Monograph knowledge graph — built into monomind MCP server since v1.8.0.
+    // Available as mcp__monomind__monograph_build, monograph_query, monograph_suggest, monograph_health.
+    // No separate server needed — the monomind entry above provides all monograph tools.
+    return { mcpServers };
+}
+/**
+ * Generate .mcp.json as formatted string
+ */
+export function generateMCPJson(options) {
+    const config = generateMCPConfig(options);
+    return JSON.stringify(config, null, 2);
+}
+/**
+ * Generate MCP server add commands for manual setup
+ */
+export function generateMCPCommands(options) {
+    const commands = [];
+    const config = options.mcp;
+    if (isWindows()) {
+        if (config.monomind) {
+            commands.push('claude mcp add monomind -- cmd /c npx -y monomind@latest mcp start');
+        }
+    }
+    else {
+        if (config.monomind) {
+            commands.push("claude mcp add monomind -- npx -y monomind@latest mcp start");
+        }
+    }
+    return commands;
+}
+/**
+ * Get platform-specific setup instructions
+ */
+export function getPlatformInstructions() {
+    if (isWindows()) {
+        return {
+            platform: 'Windows',
+            note: 'MCP configuration uses cmd /c wrapper for npx compatibility.',
+        };
+    }
+    return {
+        platform: process.platform === 'darwin' ? 'macOS' : 'Linux',
+        note: 'MCP configuration uses npx directly.',
+    };
+}
+//# sourceMappingURL=mcp-generator.js.map

package/packages/@monomind/cli/dist/src/init/settings-generator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Settings.json Generator
+ * Creates .claude/settings.json with V1-optimized hook configurations
+ */
+import type { InitOptions } from './types.js';
+/**
+ * Generate the complete settings.json content
+ */
+export declare function generateSettings(options: InitOptions): object;
+/**
+ * Generate settings.json as formatted string
+ */
+export declare function generateSettingsJson(options: InitOptions): string;
+//# sourceMappingURL=settings-generator.d.ts.map

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

@@ -0,0 +1,417 @@
+/**
+ * Settings.json Generator
+ * Creates .claude/settings.json with V1-optimized hook configurations
+ */
+import { detectPlatform } from './types.js';
+/**
+ * Generate the complete settings.json content
+ */
+export function generateSettings(options) {
+    const settings = {};
+    // Add hooks if enabled
+    if (options.components.settings) {
+        settings.hooks = generateHooksConfig(options.hooks, options.components.graphify);
+    }
+    // Add statusLine configuration if enabled
+    if (options.statusline.enabled) {
+        settings.statusLine = generateStatusLineConfig(options);
+    }
+    // Add permissions
+    // SECURITY: tightened allowlist patterns.
+    //   `Bash(npx monomind*)` previously matched any package starting with
+    //   "monomind" (including a hypothetical future typosquat). Anchor to the
+    //   official scope/namespaces only, with an explicit space between command
+    //   tokens so partial-prefix matches are rejected.
+    settings.permissions = {
+        allow: [
+            'Bash(npx @monomind/*)',
+            'Bash(npx monomind *)',
+            'Bash(npx -y monomind *)',
+            'Bash(npx monomind@*)',
+            'Bash(node .claude/helpers/*)',
+            'mcp__monomind__:*',
+        ],
+        deny: [
+            'Read(./.env)',
+            'Read(./.env.*)',
+        ],
+    };
+    // Add monomind attribution for git commits and PRs
+    settings.attribution = {
+        commit: 'Co-Authored-By: nokhodian <nokhodian@gmail.com>',
+        pr: '🤖 Generated with [monomind](https://github.com/nokhodian/monomind)',
+    };
+    // Note: Claude Code expects 'model' to be a string, not an object
+    // Model preferences are stored in monomind settings instead
+    // settings.model = 'claude-sonnet-4-5-20250929'; // Uncomment if you want to set a default model
+    // Add Agent Teams configuration (experimental feature)
+    settings.env = {
+        // Enable Claude Code Agent Teams for multi-agent coordination
+        CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
+        // Monomind specific environment
+        MONOMIND_V1_ENABLED: 'true',
+        MONOMIND_HOOKS_ENABLED: 'true',
+    };
+    // Detect platform for platform-aware configuration
+    const platform = detectPlatform();
+    // Add V1-specific settings
+    settings.monomind = {
+        version: '3.0.0',
+        enabled: true,
+        platform: {
+            os: platform.os,
+            arch: platform.arch,
+            shell: platform.shell,
+        },
+        modelPreferences: {
+            default: 'claude-opus-4-6',
+            routing: 'claude-haiku-4-5-20251001',
+        },
+        agentTeams: {
+            enabled: true,
+            teammateMode: 'auto', // 'auto' | 'in-process' | 'tmux'
+            taskListEnabled: true,
+            mailboxEnabled: true,
+            coordination: {
+                autoAssignOnIdle: true, // Auto-assign pending tasks when teammate is idle
+                trainPatternsOnComplete: true, // Train neural patterns when tasks complete
+                notifyLeadOnComplete: true, // Notify team lead when tasks complete
+                sharedMemoryNamespace: 'agent-teams', // Memory namespace for team coordination
+            },
+            hooks: {
+                teammateIdle: {
+                    enabled: true,
+                    autoAssign: true,
+                    checkTaskList: true,
+                },
+                taskCompleted: {
+                    enabled: true,
+                    trainPatterns: true,
+                    notifyLead: true,
+                },
+            },
+        },
+        swarm: {
+            topology: options.runtime.topology,
+            maxAgents: options.runtime.maxAgents,
+        },
+        memory: {
+            backend: options.runtime.memoryBackend,
+            enableHNSW: options.runtime.enableHNSW,
+            learningBridge: { enabled: options.runtime.enableLearningBridge ?? true },
+            memoryGraph: { enabled: options.runtime.enableMemoryGraph ?? true },
+            agentScopes: { enabled: options.runtime.enableAgentScopes ?? true },
+        },
+        neural: {
+            enabled: options.runtime.enableNeural,
+        },
+        daemon: {
+            autoStart: false, // Opt-in only — prevents unintended token consumption (#1427, #1330)
+            workers: [
+                'map', // Codebase mapping
+                'audit', // Security auditing (critical priority)
+                'optimize', // Performance optimization (high priority)
+            ],
+            schedules: {
+                audit: { interval: '4h', priority: 'critical' },
+                optimize: { interval: '2h', priority: 'high' },
+            },
+        },
+        learning: {
+            enabled: true,
+            autoTrain: true,
+            patterns: ['coordination', 'optimization', 'prediction'],
+            retention: {
+                shortTerm: '24h',
+                longTerm: '30d',
+            },
+        },
+        adr: {
+            autoGenerate: true,
+            directory: '/docs/adr',
+            template: 'madr',
+        },
+        ddd: {
+            trackDomains: true,
+            validateBoundedContexts: true,
+            directory: '/docs/ddd',
+        },
+        security: {
+            autoScan: true,
+            scanOnEdit: true,
+            cveCheck: true,
+            threatModel: true,
+        },
+    };
+    return settings;
+}
+/**
+ * Detect if we're on Windows for platform-aware hook commands.
+ */
+const IS_WINDOWS = process.platform === 'win32';
+/**
+ * Build a hook command with reliable $CLAUDE_PROJECT_DIR expansion.
+ * Wraps in `sh -c` to guarantee shell expansion on all platforms (macOS zsh,
+ * Linux bash). Falls back to "." if CLAUDE_PROJECT_DIR is unset, since
+ * Claude Code runs hooks from the project root.
+ * On Windows, uses `cmd /c` with %CLAUDE_PROJECT_DIR%.
+ */
+function hookCmd(script, subcommand) {
+    if (IS_WINDOWS) {
+        return `cmd /c node %CLAUDE_PROJECT_DIR%/${script} ${subcommand}`.trim();
+    }
+    // Use sh -c to ensure $CLAUDE_PROJECT_DIR is expanded by a real shell,
+    // even if Claude Code doesn't invoke hooks through a shell on macOS.
+    // eslint-disable-next-line no-template-curly-in-string
+    const dir = '${CLAUDE_PROJECT_DIR:-.}';
+    return `sh -c 'exec node "${dir}/${script}" ${subcommand}'`;
+}
+/** Shorthand for CJS hook-handler commands */
+function hookHandlerCmd(subcommand) {
+    return hookCmd('.claude/helpers/hook-handler.cjs', subcommand);
+}
+/** Shorthand for ESM auto-memory-hook commands */
+function autoMemoryCmd(subcommand) {
+    return hookCmd('.claude/helpers/auto-memory-hook.mjs', subcommand);
+}
+/** Shorthand for standalone CJS helper scripts (no subcommand) */
+function standaloneHelperCmd(script) {
+    if (IS_WINDOWS) {
+        return `cmd /c node %CLAUDE_PROJECT_DIR%/.claude/helpers/${script}`;
+    }
+    // eslint-disable-next-line no-template-curly-in-string
+    const dir = '${CLAUDE_PROJECT_DIR:-.}';
+    return `sh -c 'exec node "${dir}/.claude/helpers/${script}"'`;
+}
+/**
+ * Generate statusLine configuration for Claude Code
+ * Uses local helper script for cross-platform compatibility (no npx cold-start)
+ */
+function generateStatusLineConfig(_options) {
+    // Claude Code pipes JSON session data to the script via stdin.
+    // Valid fields: type, command, padding (optional).
+    // The script runs after each assistant message (debounced 300ms).
+    // NOTE: statusline must NOT use `cmd /c` — Claude Code manages its stdin
+    // directly for statusline commands, and `cmd /c` blocks stdin forwarding.
+    // eslint-disable-next-line no-template-curly-in-string
+    const dir = '${CLAUDE_PROJECT_DIR:-.}';
+    return {
+        type: 'command',
+        command: `sh -c 'exec node "${dir}/.claude/helpers/statusline.cjs"'`,
+    };
+}
+/**
+ * Generate hooks configuration
+ * Uses local hook-handler.cjs for cross-platform compatibility.
+ * All hooks invoke scripts directly via `node <script> <subcommand>`,
+ * working identically on Windows, macOS, and Linux.
+ */
+function generateHooksConfig(config, graphify = true) {
+    const hooks = {};
+    // Node.js scripts handle errors internally via try/catch.
+    // No shell-level error suppression needed (2>/dev/null || true breaks Windows).
+    // PreToolUse — validate commands and edits before execution
+    if (config.preToolUse) {
+        hooks.PreToolUse = [
+            {
+                matcher: 'Bash',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('pre-bash'),
+                        timeout: config.timeout,
+                    },
+                ],
+            },
+            {
+                matcher: 'Write|Edit|MultiEdit',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('pre-edit'),
+                        timeout: config.timeout,
+                    },
+                ],
+            },
+        ];
+    }
+    // PostToolUse — record edits and commands for session metrics / learning
+    if (config.postToolUse) {
+        hooks.PostToolUse = [
+            {
+                matcher: 'Write|Edit|MultiEdit',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('post-edit'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+            {
+                matcher: 'Bash',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('post-bash'),
+                        timeout: config.timeout,
+                    },
+                ],
+            },
+        ];
+    }
+    // UserPromptSubmit — intelligent task routing
+    if (config.userPromptSubmit) {
+        hooks.UserPromptSubmit = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('route'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+        ];
+    }
+    // SessionStart — restore session state + import auto memory + build knowledge graph
+    if (config.sessionStart) {
+        const sessionStartHooks = [
+            {
+                type: 'command',
+                command: hookHandlerCmd('session-restore'),
+                timeout: 15000,
+            },
+            {
+                type: 'command',
+                command: autoMemoryCmd('import'),
+                timeout: 8000,
+            },
+        ];
+        if (graphify) {
+            sessionStartHooks.push({
+                type: 'command',
+                command: standaloneHelperCmd('graphify-freshen.cjs'),
+                timeout: 5000,
+            });
+        }
+        sessionStartHooks.push({
+            type: 'command',
+            command: standaloneHelperCmd('control-start.cjs'),
+            timeout: 5000,
+        });
+        hooks.SessionStart = [{ hooks: sessionStartHooks }];
+    }
+    // SessionEnd — persist session state
+    if (config.sessionStart) {
+        hooks.SessionEnd = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('session-end'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+        ];
+    }
+    // Stop — sync auto memory on exit
+    if (config.stop) {
+        hooks.Stop = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: autoMemoryCmd('sync'),
+                        timeout: 10000,
+                    },
+                ],
+            },
+        ];
+    }
+    // PreCompact — preserve context before compaction
+    if (config.preCompact) {
+        hooks.PreCompact = [
+            {
+                matcher: 'manual',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('compact-manual'),
+                    },
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('session-end'),
+                        timeout: 5000,
+                    },
+                ],
+            },
+            {
+                matcher: 'auto',
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('compact-auto'),
+                    },
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('session-end'),
+                        timeout: 6000,
+                    },
+                ],
+            },
+        ];
+    }
+    // SubagentStart — status update when a sub-agent is spawned
+    hooks.SubagentStart = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: hookHandlerCmd('status'),
+                    timeout: 3000,
+                },
+            ],
+        },
+    ];
+    // SubagentStop — track agent completion for metrics
+    // NOTE: The valid event is "SubagentStop" (not "SubagentEnd")
+    hooks.SubagentStop = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: hookHandlerCmd('post-task'),
+                    timeout: 5000,
+                },
+            ],
+        },
+    ];
+    // Notification — capture Claude Code notifications for logging
+    if (config.notification) {
+        hooks.Notification = [
+            {
+                hooks: [
+                    {
+                        type: 'command',
+                        command: hookHandlerCmd('notify'),
+                        timeout: 3000,
+                    },
+                ],
+            },
+        ];
+    }
+    // NOTE: TeammateIdle, TaskCompleted, and PostCompact are NOT accepted by
+    // Claude Code's settings.json validator (rejected as "Invalid key in record").
+    // Agent Teams coordination lives in monomind.agentTeams.hooks instead.
+    return hooks;
+}
+/**
+ * Generate settings.json as formatted string
+ */
+export function generateSettingsJson(options) {
+    const settings = generateSettings(options);
+    return JSON.stringify(settings, null, 2);
+}
+//# sourceMappingURL=settings-generator.js.map

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