milens 0.7.0 → 0.7.2

package/dist/cli.js

@@ -1,13 +1,49 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { resolve, join, dirname, basename } from 'node:path';
-import { mkdirSync, readFileSync, rmSync, existsSync } from 'node:fs';
-import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, rmSync, existsSync, cpSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { loadAliases } from './analyzer/config.js';
+const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+if (nodeMajor < 20) {
+    process.stderr.write(`milens requires Node.js >= 20.0.0 (current: ${process.version})\n`);
+    process.exit(1);
+}
 const program = new Command();
 const __filename = fileURLToPath(import.meta.url);
 const PKG_VERSION = process.env.MILENS_VERSION ?? JSON.parse(readFileSync(join(dirname(__filename), '..', 'package.json'), 'utf-8')).version;
+// Files each harness adapter contributes, relative to adapters/<harness>/ (src) and
+// the project root (dest). Copying never overwrites a file that already exists at dest.
+const HARNESS_ADAPTER_FILES = {
+    'claude-code': [
+        { src: '.claude/mcp.json', dest: '.claude/mcp.json' },
+        { src: 'CLAUDE.md', dest: 'CLAUDE.md' },
+    ],
+    'opencode': [
+        { src: '.opencode/config.json', dest: '.opencode/config.json' },
+        { src: 'AGENTS.md', dest: 'AGENTS.md' },
+    ],
+    'codex': [
+        { src: '.codex/config.toml', dest: '.codex/config.toml' },
+        { src: '.codex/codex.md', dest: '.codex/codex.md' },
+    ],
+    'cursor': [
+        { src: '.cursor/mcp.json', dest: '.cursor/mcp.json' },
+        { src: '.cursorrules', dest: '.cursorrules' },
+    ],
+    'copilot': [
+        { src: '.vscode/mcp.json', dest: '.vscode/mcp.json' },
+        { src: '.github/copilot-instructions.md', dest: '.github/copilot-instructions.md' },
+    ],
+    'gemini': [
+        { src: '.gemini/settings.json', dest: '.gemini/settings.json' },
+        { src: '.gemini/context.md', dest: '.gemini/context.md' },
+    ],
+    'zed': [
+        { src: '.zed/settings.json', dest: '.zed/settings.json' },
+    ],
+};
 program
     .name('milens')
     .description('Code intelligence engine — analyze codebases, build knowledge graphs, serve via MCP')
@@ -52,7 +88,6 @@ program
             files: opts.files,
             onProgress: reporter,
         });
-        // Register in global registry
         const contentHash = createHash('sha256').update(JSON.stringify(stats)).digest('hex').slice(0, 12);
         const { RepoRegistry } = await import('./store/registry.js');
         new RepoRegistry().register(rootPath, dbPath, contentHash);
@@ -176,17 +211,23 @@ program
 program
     .command('serve')
     .description('Start MCP server')
-    .option('-p, --path <path>', 'Repository root path', '.')
+    .option('-p, --path <path>', 'Repository root path (defaults to $CLAUDE_PROJECT_DIR, then cwd)')
     .option('--http', 'Use HTTP transport instead of stdio')
     .option('--port <port>', 'HTTP port', '3100')
     .action(async (opts) => {
+    // Project-scoped .mcp.json always passes -p explicitly (highest priority, unchanged
+    // behavior). Claude Code plugin-scoped MCP servers omit -p and rely on
+    // CLAUDE_PROJECT_DIR, which Claude Code injects into the subprocess env — unlike
+    // ${CLAUDE_PLUGIN_ROOT}, which resolves to the plugin's own install dir, not the
+    // user's project (see adapters/claude-code/README notes).
+    const repoPath = opts.path ?? process.env.CLAUDE_PROJECT_DIR ?? '.';
     if (opts.http) {
         const { startHttp } = await import('./server/mcp.js');
-        await startHttp(parseInt(opts.port), resolve(opts.path));
+        await startHttp(parseInt(opts.port), resolve(repoPath));
     }
     else {
         const { startStdio } = await import('./server/mcp.js');
-        await startStdio(resolve(opts.path));
+        await startStdio(resolve(repoPath));
     }
 });
 program
@@ -194,6 +235,7 @@ program
     .description('Show index status')
     .option('-p, --path <path>', 'Repository root path', '.')
     .action(async (opts) => {
+    const { existsSync } = await import('node:fs');
     const { Database } = await import('./store/db.js');
     const { RepoRegistry } = await import('./store/registry.js');
     const reg = new RepoRegistry();
@@ -202,6 +244,10 @@ program
         console.log('Not indexed.');
         return;
     }
+    if (!existsSync(entry.dbPath)) {
+        console.log(`Not indexed. Run \`milens analyze\` first.\n(Registry entry stale — directory may have been deleted: ${entry.rootPath})`);
+        return;
+    }
     const db = new Database(entry.dbPath);
     const stats = db.getStats();
     console.log(`Repository: ${entry.rootPath}`);
@@ -294,7 +340,6 @@ program
     console.log('║  Step 1/4: Scanning project...          ║');
     console.log('╚══════════════════════════════════════════╝');
     console.log();
-    // Run initial scan
     const initialScan = uninstall({
         rootPath,
         dryRun: false,
@@ -304,7 +349,6 @@ program
         keepConfigs: !!opts.keepConfigs,
         scanOnly: true,
     });
-    // Collect all items for display
     const allScanned = [];
     for (const item of initialScan.autoRemoved) {
         allScanned.push(`${item.file} (${item.action})`);
@@ -329,7 +373,6 @@ program
     console.log('║  Step 2/4: Auto-removing...             ║');
     console.log('╚══════════════════════════════════════════╝');
     console.log();
-    // Run auto-remove (without interactive items)
     const autoResult = uninstall({
         rootPath,
         dryRun: false,
@@ -339,7 +382,6 @@ program
         keepConfigs: !!opts.keepConfigs,
         scanOnly: false,
     });
-    // Show only auto-removed items
     for (const item of autoResult.autoRemoved) {
         console.log(`  ✓ ${item.file} — ${item.action}`);
     }
@@ -554,7 +596,6 @@ program
     }
     const { Database } = await import('./store/db.js');
     const db = new Database(trackDbPath);
-    // Determine repo filter from --path
     let repoFilter;
     if (opts.path) {
         repoFilter = resolve(opts.path);
@@ -1006,7 +1047,7 @@ program
                 const rules = loadRules().filter(r => r.enabled);
                 console.log(`Loaded ${rules.length} active security rules\n`);
                 const findings = [];
-                const MAX_FILE_SIZE = 200 * 1024;
+                const MAX_FILE_SIZE = 200 * 1024; // skip files >200KB to avoid regex timeout
                 function scanDir(dir) {
                     try {
                         for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -1064,7 +1105,6 @@ program
                             console.log(`  ${s}: ${bySeverity[s]}`);
                     }
                     console.log();
-                    // Show top findings by severity
                     const sorted = [...findings].sort((a, b) => {
                         const order = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };
                         return (order[a.severity] ?? 4) - (order[b.severity] ?? 4);
@@ -1171,6 +1211,7 @@ program
     .option('-p, --path <path>', 'Repository root path', '.')
     .option('--profile <profile>', 'minimal|standard|full', 'standard')
     .option('--with <modules>', 'Comma-separated extra modules (security,ci,hooks)')
+    .option('--target <harnesses>', `Comma-separated harnesses to install adapters for (${Object.keys(HARNESS_ADAPTER_FILES).join(',')},all)`)
     .option('--interactive', 'Interactive install mode')
     .action(async (opts) => {
     const root = resolve(opts.path);
@@ -1211,6 +1252,7 @@ program
         console.log('  claude-code, opencode, codex, cursor, copilot, gemini, zed, all');
         const harnessChoice = await ask('Harnesses [all]: ');
         const harnesses = harnessChoice.trim() || 'all';
+        opts.target = harnesses;
         // Generate command
         const withFlags = opts.with ? `--with ${opts.with}` : '';
         const harnessFlag = harnesses === 'all' ? '' : `--target ${harnesses}`;
@@ -1242,10 +1284,11 @@ program
         console.log('  (run `milens analyze -p . --force` manually if this fails)');
     }
     console.log('Step 2/4: Generating AGENTS.md...');
+    let db = null;
     try {
         const dbPath = new RepoRegistry().findDbPath(root);
         if (dbPath) {
-            const db = new Database(dbPath);
+            db = new Database(dbPath);
             const { generateAgentsMd } = await import('./agents-md.js');
             const agentsMd = generateAgentsMd(db, root);
             const { writeFileSync, mkdirSync, existsSync } = await import('node:fs');
@@ -1253,7 +1296,6 @@ program
                 mkdirSync(root, { recursive: true });
             writeFileSync(resolve(root, 'AGENTS.md'), agentsMd);
             console.log('  ✓ AGENTS.md created');
-            db.close();
         }
     }
     catch (e) {
@@ -1262,33 +1304,46 @@ program
     if (opts.profile !== 'minimal') {
         console.log('Step 3/4: Installing skill files...');
         try {
-            const { cpSync, existsSync, mkdirSync } = await import('node:fs');
-            const { join: pathJoin } = await import('node:path');
-            const { fileURLToPath } = await import('node:url');
-            const skillSrc = pathJoin(resolve(fileURLToPath(import.meta.url), '..', '..'), '.agents', 'skills');
-            const skillDst = pathJoin(root, '.agents', 'skills');
-            if (existsSync(skillSrc)) {
-                if (!existsSync(skillDst))
-                    mkdirSync(skillDst, { recursive: true });
-                cpSync(skillSrc, skillDst, { recursive: true });
-                console.log('  ✓ Skill files installed');
+            if (db) {
+                const { generateSkills } = await import('./skills.js');
+                const result = generateSkills(db, root, ['agents']);
+                console.log(`  ✓ Generated ${result.count} skill files`);
+                for (const d of result.dirs)
+                    console.log(`    ${d}`);
             }
             else {
-                console.log('  ⚠ Skill template not found (run from milens repo)');
+                console.log('  ⚠ Skills skipped: no database available (run analyze first)');
             }
         }
         catch (e) {
             console.log(`  ⚠ Skill install skipped: ${e.message}`);
         }
     }
+    if (db)
+        db.close();
     if (opts.profile === 'full' || (opts.with && opts.with.includes('hooks'))) {
         console.log('Step 4/4: Installing git hooks...');
         try {
-            const { writeFileSync, existsSync, mkdirSync, chmodSync } = await import('node:fs');
+            const { writeFileSync, existsSync, mkdirSync, chmodSync, readFileSync } = await import('node:fs');
             const hooksDir = resolve(root, '.git', 'hooks');
             if (!existsSync(hooksDir)) {
                 mkdirSync(hooksDir, { recursive: true });
             }
+            const hookPath = resolve(hooksDir, 'pre-commit');
+            // Check for existing non-milens hook (e.g. Husky) before overwriting
+            if (existsSync(hookPath)) {
+                const existing = readFileSync(hookPath, 'utf-8');
+                if (!existing.includes('milens') && !existing.includes('Auto-installed by milens')) {
+                    const isHusky = existing.includes('husky') || existing.includes('.husky');
+                    if (isHusky) {
+                        console.log('  ⚠ Skipped pre-commit hook — Husky hook already present (.husky/). Install manually with "milens hooks install".');
+                    }
+                    else {
+                        console.log('  ⚠ Skipped pre-commit hook — existing hook found. Install manually with "milens hooks install".');
+                    }
+                    return;
+                }
+            }
             const preCommitContent = `#!/bin/bash
 # Auto-installed by milens init
 echo "Milens: Pre-commit check..."
@@ -1324,6 +1379,52 @@ echo "Milens: Done."
             console.log(`  ⚠ Hook install skipped: ${e.message}`);
         }
     }
+    if (opts.target) {
+        console.log('Installing harness adapters...');
+        const targetTokens = opts.target.split(',').map((h) => h.trim()).filter(Boolean);
+        const requested = targetTokens.includes('all')
+            ? Object.keys(HARNESS_ADAPTER_FILES)
+            : targetTokens;
+        const adaptersRoot = join(dirname(__filename), '..', 'adapters');
+        for (const harness of requested) {
+            const files = HARNESS_ADAPTER_FILES[harness];
+            if (!files) {
+                console.log(`  ⚠ Unknown harness "${harness}" — skipped. Valid: ${Object.keys(HARNESS_ADAPTER_FILES).join(', ')}, all`);
+                continue;
+            }
+            for (const { src, dest } of files) {
+                const srcPath = join(adaptersRoot, harness, src);
+                const destPath = resolve(root, dest);
+                if (!existsSync(srcPath)) {
+                    console.log(`  ⚠ ${harness}: template not found (${src}) — run from an npm install of milens`);
+                    continue;
+                }
+                if (existsSync(destPath)) {
+                    console.log(`  - ${dest} already exists — skipped (not overwritten)`);
+                    continue;
+                }
+                mkdirSync(dirname(destPath), { recursive: true });
+                cpSync(srcPath, destPath);
+                console.log(`  ✓ ${dest} (${harness})`);
+            }
+        }
+    }
+    // Ensure .milens/ is gitignored
+    try {
+        const { existsSync, readFileSync, appendFileSync, writeFileSync } = await import('node:fs');
+        const gitignorePath = resolve(root, '.gitignore');
+        const entry = '\n# milens code intelligence index (local, machine-specific)\n.milens/\n';
+        if (existsSync(gitignorePath)) {
+            const content = readFileSync(gitignorePath, 'utf-8');
+            if (!content.includes('.milens')) {
+                appendFileSync(gitignorePath, entry);
+            }
+        }
+        else {
+            writeFileSync(gitignorePath, entry.trimStart());
+        }
+    }
+    catch { /* best-effort */ }
     console.log(`\n✓ Milens ${opts.profile} profile bootstrapped for ${root}`);
     console.log('Next steps:');
     console.log('  1. Open project in your AI coding agent (Claude Code, OpenCode, etc.)');
@@ -1334,12 +1435,72 @@ program
     .command('hooks <action>')
     .description('Manage milens hook system')
     .option('-p, --path <path>', 'Repository root path', '.')
+    .option('--repo <path>', 'Repository root path (alias for --path)')
+    .option('--agent <name>', 'Agent name (for session-start/session-end)')
     .option('--hook <hook>', 'Hook name (sessionStart, sessionEnd, preCommit, fileChange, preCompact, postCompact)')
+    .option('--mode <mode>', 'Enforcement mode (warn | strict) for guard-set-mode')
     .action(async (action, opts) => {
-    const { HookManager } = await import('./server/hooks.js');
+    const { HookManager, defaultOnSessionStart, defaultOnSessionEnd, defaultOnPreCompact, defaultOnPostCompact } = await import('./server/hooks.js');
     const manager = new HookManager();
-    const projectPath = resolve(opts.path);
+    const projectPath = resolve(opts.repo || opts.path);
     switch (action) {
+        case 'session-start': {
+            const agent = opts.agent || 'cli';
+            const rootPath = projectPath;
+            const dbPath = join(rootPath, '.milens', 'milens.db');
+            const sessionId = randomUUID();
+            const ctx = { agent, sessionId, rootPath };
+            try {
+                const output = await defaultOnSessionStart(ctx, dbPath);
+                console.log(output);
+            }
+            catch (e) {
+                console.error(`Session start hook failed: ${e.message || e}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case 'session-end': {
+            const agent = opts.agent || 'cli';
+            const rootPath = projectPath;
+            const dbPath = join(rootPath, '.milens', 'milens.db');
+            const sessionId = randomUUID();
+            const ctx = { agent, sessionId, rootPath };
+            try {
+                const output = await defaultOnSessionEnd(ctx, dbPath);
+                console.log(output);
+            }
+            catch (e) {
+                console.error(`Session end hook failed: ${e.message || e}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case 'pre-compact': {
+            const rootPath = projectPath;
+            const dbPath = join(rootPath, '.milens', 'milens.db');
+            try {
+                const output = await defaultOnPreCompact(rootPath, dbPath);
+                console.log(output);
+            }
+            catch (e) {
+                console.error(`Pre-compact hook failed: ${e.message || e}`);
+                process.exit(1);
+            }
+            break;
+        }
+        case 'post-compact': {
+            const rootPath = projectPath;
+            try {
+                const output = await defaultOnPostCompact(rootPath);
+                console.log(output);
+            }
+            catch (e) {
+                console.error(`Post-compact hook failed: ${e.message || e}`);
+                process.exit(1);
+            }
+            break;
+        }
         case 'enable': {
             if (opts.hook) {
                 manager.enableHook(opts.hook, projectPath);
@@ -1410,8 +1571,42 @@ program
             console.log(`Hook profile set to "${profileName}" for ${projectPath}`);
             break;
         }
+        case 'guard-mark-checked': {
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            }
+            const rawStdin = Buffer.concat(chunks).toString();
+            const { handleMarkChecked } = await import('./server/guard-hook.js');
+            handleMarkChecked(rawStdin, projectPath);
+            break;
+        }
+        case 'guard-check-edit': {
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            }
+            const rawStdin = Buffer.concat(chunks).toString();
+            const { handleCheckEdit } = await import('./server/guard-hook.js');
+            const result = handleCheckEdit(rawStdin, projectPath);
+            process.stdout.write(result.stdout + '\n');
+            if (result.exitCode !== 0)
+                process.exit(result.exitCode);
+            break;
+        }
+        case 'guard-set-mode': {
+            const mode = opts.mode;
+            if (mode !== 'warn' && mode !== 'strict') {
+                console.error(`Invalid mode "${mode}". Use "warn" or "strict".`);
+                process.exit(1);
+            }
+            const { writeMode } = await import('./server/guard-hook.js');
+            writeMode(projectPath, mode);
+            console.log(`Guard enforcement mode set to "${mode}" for ${projectPath}`);
+            break;
+        }
         default:
-            console.log(`Unknown action: ${action}. Use: enable, disable, list, profile`);
+            console.log(`Unknown action: ${action}. Use: enable, disable, list, profile, session-start, session-end, pre-compact, post-compact, guard-mark-checked, guard-check-edit, guard-set-mode`);
     }
 });
 const securityCmd = program