@exero1/claudecontext 0.1.0

package/dist/installer/install.js

@@ -0,0 +1,714 @@
+#!/usr/bin/env node
+/**
+ * ClaudeContext installer.
+ *
+ * Commands:
+ *   claudecontext init [--project-root <path>]   Install in a project
+ *   claudecontext remove                          Remove hooks/config (preserves state.db)
+ *   claudecontext migrate                         Migrate schema for upgrades
+ *   claudecontext doctor                          Check installation health
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, copyFileSync, rmSync } from 'node:fs';
+import { join, resolve, dirname, basename } from 'node:path';
+import { createInterface } from 'node:readline';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { detectAreas } from '../src/detection/areas.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const isWindows = process.platform === 'win32';
+// ── Utilities ──────────────────────────────────────────────────────────────
+function log(msg) {
+    process.stdout.write(`  ${msg}\n`);
+}
+function ok(msg) {
+    process.stdout.write(`  ✓ ${msg}\n`);
+}
+function warn(msg) {
+    process.stdout.write(`  ⚠ ${msg}\n`);
+}
+function err(msg) {
+    process.stdout.write(`  ✗ ${msg}\n`);
+}
+function ask(rl, question) {
+    return new Promise(resolve => {
+        rl.question(`  ${question} `, answer => {
+            resolve(answer.trim());
+        });
+    });
+}
+function mergeJson(existing, patch) {
+    return { ...existing, ...patch };
+}
+async function cmdInit(projectRoot, opts = {}) {
+    process.stdout.write('\n╔══════════════════════════════════════╗\n');
+    process.stdout.write('║     ClaudeContext Setup Wizard       ║\n');
+    process.stdout.write('╚══════════════════════════════════════╝\n\n');
+    log(`Setting up ClaudeContext in: ${projectRoot}`);
+    let projectName;
+    let projectDesc;
+    let techStack;
+    let testStrategy;
+    let areas;
+    let conventions;
+    let invariants;
+    if (opts.config) {
+        // ── Non-interactive: load from config file ──
+        let cfg = {};
+        try {
+            cfg = JSON.parse(readFileSync(resolve(opts.config), 'utf8'));
+        }
+        catch {
+            err(`Cannot read config file: ${opts.config}`);
+            process.exit(1);
+        }
+        projectName = cfg.projectName ?? basename(projectRoot);
+        projectDesc = cfg.projectDesc ?? '';
+        techStack = cfg.techStack ?? '';
+        testStrategy = cfg.testStrategy ?? '';
+        conventions = cfg.conventions ?? '';
+        invariants = cfg.invariants ?? '';
+        areas = cfg.areas ?? detectAreas(projectRoot);
+        log(`Loaded config from: ${opts.config}`);
+        log(`Project: ${projectName} | Areas: ${areas.length}`);
+    }
+    else if (opts.yes) {
+        // ── Non-interactive: use defaults + auto-detect ──
+        projectName = basename(projectRoot);
+        projectDesc = '';
+        techStack = '';
+        testStrategy = '';
+        conventions = '';
+        invariants = '';
+        areas = detectAreas(projectRoot);
+        log(`Using --yes: project="${projectName}", auto-detected ${areas.length} area(s)`);
+        if (areas.length > 0) {
+            log(`  Areas: ${areas.map(a => a.name).join(', ')}`);
+        }
+    }
+    else {
+        // ── Interactive wizard ──
+        if (!process.stdin.isTTY) {
+            err('No TTY detected. Run with --yes to use defaults, or --config <file> for non-interactive setup.');
+            process.exit(1);
+        }
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        // Step 1/4: Project info
+        process.stdout.write('\n── Step 1/4: Project information ────────\n');
+        projectName = await ask(rl, 'Project name:');
+        projectDesc = await ask(rl, 'Brief project description (1-2 sentences):');
+        techStack = await ask(rl, 'Tech stack (e.g. TypeScript, React, PostgreSQL):');
+        testStrategy = await ask(rl, 'Test strategy (e.g. Vitest unit + Playwright E2E):');
+        // Step 2/4: Code areas
+        process.stdout.write('\n── Step 2/4: Code areas (subsystems) ───\n');
+        const detected = detectAreas(projectRoot);
+        if (detected.length > 0) {
+            log(`Auto-detected ${detected.length} area(s): ${detected.map(a => a.name).join(', ')}`);
+        }
+        log('Enter your main code areas. Press Enter with empty input to finish.');
+        log('Example: auth, api, database, frontend');
+        areas = [];
+        while (true) {
+            const areaName = await ask(rl, `Area name (or Enter to finish):`);
+            if (!areaName)
+                break;
+            const globs = await ask(rl, `  File patterns for "${areaName}" (comma-separated, e.g. src/auth/**,src/middleware/auth*):`);
+            areas.push({
+                name: areaName,
+                globs: globs.split(',').map(g => g.trim()).filter(Boolean),
+                docPath: `docs/context/${areaName}.md`,
+            });
+            ok(`Area "${areaName}" added`);
+        }
+        if (areas.length === 0 && detected.length > 0) {
+            areas = detected;
+            log(`No areas entered — using auto-detected areas: ${areas.map(a => a.name).join(', ')}`);
+        }
+        // Step 3/4: Conventions
+        process.stdout.write('\n── Step 3/4: Conventions ───────────────\n');
+        conventions = await ask(rl, 'Key conventions (e.g. "Use async/await, no callbacks; snake_case for DB"):');
+        invariants = await ask(rl, 'Critical invariants (e.g. "Never expose user IDs in URLs"):');
+        rl.close();
+    }
+    process.stdout.write('\n── Step 4/4: Creating files ────────────\n');
+    // Create directories
+    const stateDir = join(projectRoot, '.claudecontext');
+    const hooksDir = join(projectRoot, '.claude', 'hooks');
+    const tasksDir = join(projectRoot, 'tasks');
+    const docsDir = join(projectRoot, 'docs', 'context');
+    for (const dir of [stateDir, hooksDir, tasksDir, docsDir]) {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+            ok(`Created ${dir}`);
+        }
+    }
+    // Write CLAUDE.md (preserve if user-modified)
+    const claudeMdPath = join(projectRoot, 'CLAUDE.md');
+    if (existsSync(claudeMdPath)) {
+        copyFileSync(claudeMdPath, `${claudeMdPath}.backup`);
+        warn(`Backed up existing CLAUDE.md to CLAUDE.md.backup`);
+    }
+    const areasSection = areas.length > 0
+        ? areas.map(a => `- **${a.name}**: \`${a.globs.join(', ')}\` → docs at \`${a.docPath}\``).join('\n')
+        : '- (no areas configured — run `claudecontext init` to add areas)';
+    const claudeMdContent = `# ${projectName || 'Project'}
+
+## ClaudeContext — System Instructions
+
+**MANDATORY — do these every session:**
+
+1. **Start of session / after compaction:** call \`context_get_bundle\` immediately. This restores your task context.
+2. **After EVERY technical decision** (architecture choice, tradeoff accepted, approach selected): call \`context_update_task\` and record it in the "decisions" field. Do not defer this — decisions not recorded here are permanently lost on compaction.
+3. **First time you understand the goal:** call \`context_update_task\` to set the "goal" field in plain English.
+4. **Files touched** are auto-tracked by the post-write hook — you do NOT need to add them manually.
+5. To show the user what context is loaded: call \`context_status\`.
+
+---
+
+## Project Description
+
+${projectDesc || '(add description)'}
+
+---
+
+## Tech Stack
+
+${techStack || '(add tech stack)'}
+
+---
+
+## Key Areas
+
+${areasSection}
+
+---
+
+## Conventions
+
+${conventions || '(add conventions)'}
+
+---
+
+## Critical Invariants
+
+${invariants || '(add invariants)'}
+
+---
+
+## Test Strategy
+
+${testStrategy || '(add test strategy)'}
+`;
+    writeFileSync(claudeMdPath, claudeMdContent);
+    ok('Generated CLAUDE.md');
+    // Write areas.json
+    const areasPath = join(stateDir, 'areas.json');
+    writeFileSync(areasPath, JSON.stringify(areas, null, 2));
+    ok('Written .claudecontext/areas.json');
+    // Write empty gate-rules.json (opt-in custom deny/warn rules)
+    const gateRulesPath = join(stateDir, 'gate-rules.json');
+    if (!existsSync(gateRulesPath)) {
+        writeFileSync(gateRulesPath, JSON.stringify([], null, 2) + '\n');
+        ok('Created .claudecontext/gate-rules.json (add custom deny/warn rules here)');
+    }
+    // Write config.json with default budget structure (all keys omitted = use defaults)
+    const configPath = join(stateDir, 'config.json');
+    if (!existsSync(configPath)) {
+        const defaultConfig = {
+            // Override token budgets by adding a "budgets" key, e.g.:
+            // "budgets": { "L1": 15000, "total": 40000 }
+            // Defaults: L0=3000 L1=8000 L2=10000 L3=2000 L4=2000 graph=4000 total=29000
+            budgets: {},
+        };
+        writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + '\n');
+        ok('Created .claudecontext/config.json (add budgets overrides to customise token limits)');
+    }
+    // Write .mcp.json (always use npx — never absolute paths)
+    const mcpJsonPath = join(projectRoot, '.mcp.json');
+    const mcpConfig = {
+        mcpServers: {
+            claudecontext: {
+                command: 'npx',
+                args: ['claudecontext-mcp'],
+                env: {
+                    CLAUDECONTEXT_PROJECT_ROOT: projectRoot,
+                    NODE_OPTIONS: '--no-warnings',
+                },
+            },
+        },
+    };
+    writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+    ok('Written .mcp.json (uses npx — works across npm updates)');
+    // Install hook scripts
+    // install.js is at dist/installer/install.js → go up 2 levels to reach package root → hooks/
+    const hooksSource = resolve(__dirname, '..', '..', 'hooks');
+    const hookFiles = ['session-start.mjs', 'pre-tool-use.mjs', 'post-write.mjs', 'pre-compact.mjs'];
+    for (const hookFile of hookFiles) {
+        const src = join(hooksSource, hookFile);
+        const dest = join(hooksDir, hookFile);
+        if (existsSync(src)) {
+            writeFileSync(dest, readFileSync(src, 'utf8'));
+            if (!isWindows)
+                chmodSync(dest, 0o755);
+            ok(`Installed hook: ${hookFile}`);
+        }
+    }
+    // Merge hooks config into .claude/settings.json
+    const settingsPath = join(projectRoot, '.claude', 'settings.json');
+    let settings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            settings = JSON.parse(readFileSync(settingsPath, 'utf8'));
+            copyFileSync(settingsPath, `${settingsPath}.backup`);
+            warn('Backed up existing .claude/settings.json');
+        }
+        catch { /* ignore */ }
+    }
+    // Use project-relative paths so hooks work after the project is moved or cloned.
+    // On Windows: prefix with "node" since shebangs are ignored.
+    const hookCmd = (name) => isWindows ? `node .claude/hooks/${name}` : `.claude/hooks/${name}`;
+    const hooksConfig = {
+        hooks: {
+            SessionStart: [{ matcher: 'startup|resume', hooks: [{ type: 'command', command: hookCmd('session-start.mjs') }] }],
+            PreToolUse: [{ matcher: 'Bash|Write|Edit|MultiEdit', hooks: [{ type: 'command', command: hookCmd('pre-tool-use.mjs') }] }],
+            PostToolUse: [{ matcher: 'Write|Edit|MultiEdit', hooks: [{ type: 'command', command: hookCmd('post-write.mjs') }] }],
+            PreCompact: [{ hooks: [{ type: 'command', command: hookCmd('pre-compact.mjs') }] }],
+        },
+    };
+    const mergedSettings = mergeJson(settings, hooksConfig);
+    writeFileSync(settingsPath, JSON.stringify(mergedSettings, null, 2));
+    ok('Merged hooks into .claude/settings.json');
+    // Create area docs stubs
+    for (const area of areas) {
+        const docPath = join(projectRoot, area.docPath);
+        if (!existsSync(docPath)) {
+            const docContent = `# ${area.name} — Architecture\n\n## Overview\n\n(Describe the ${area.name} subsystem)\n\n## Key Files\n\n${area.globs.map(g => `- \`${g}\``).join('\n')}\n\n## API Contracts\n\n(Document key interfaces and contracts)\n\n## Gotchas\n\n(Known footguns and non-obvious behavior)\n`;
+            mkdirSync(dirname(docPath), { recursive: true });
+            writeFileSync(docPath, docContent);
+            ok(`Created area doc: ${area.docPath}`);
+        }
+    }
+    process.stdout.write('\n╔══════════════════════════════════════╗\n');
+    process.stdout.write('║       Setup complete! 🎉             ║\n');
+    process.stdout.write('╚══════════════════════════════════════╝\n\n');
+    log('Next steps:');
+    log('  1. Open this project in Claude Code');
+    log('  2. Run: context_status() to verify the MCP server is connected');
+    log('  3. Run: context_get_bundle() to load your context');
+    log('');
+    log('Docs: Fill in docs/context/<area>.md for each subsystem you defined.');
+    log('');
+}
+function cmdRemove(projectRoot, opts = {}) {
+    log(`Removing ClaudeContext from: ${projectRoot}`);
+    const stateDir = join(projectRoot, '.claudecontext');
+    // Files always removed (hooks, config, mcp.json)
+    const toRemove = [
+        join(projectRoot, '.mcp.json'),
+        ...['session-start', 'pre-tool-use', 'post-write', 'pre-compact'].flatMap(h => [
+            join(projectRoot, '.claude', 'hooks', `${h}.mjs`),
+            join(projectRoot, '.claude', 'hooks', `${h}.js`),
+        ]),
+        join(stateDir, 'areas.json'),
+        join(stateDir, 'config.json'),
+        join(stateDir, 'gate-rules.json'),
+        join(stateDir, 'l0.log'),
+        join(stateDir, '.session.lock'),
+    ];
+    // Files only removed with --purge
+    const toRemoveIfPurge = [
+        join(stateDir, 'state.db'),
+        stateDir,
+    ];
+    if (opts.dryRun) {
+        log('Dry run — nothing will be deleted:');
+        for (const f of toRemove) {
+            if (existsSync(f))
+                log(`  would remove: ${f}`);
+        }
+        if (opts.purge) {
+            for (const f of toRemoveIfPurge) {
+                if (existsSync(f))
+                    log(`  would remove: ${f}`);
+            }
+        }
+        else {
+            warn(`Would keep: ${join(stateDir, 'state.db')} (pass --purge to delete all state)`);
+        }
+        return;
+    }
+    const removeOne = (path) => {
+        if (existsSync(path)) {
+            rmSync(path, { recursive: true, force: true });
+            ok(`Removed: ${path}`);
+        }
+    };
+    for (const f of toRemove)
+        removeOne(f);
+    if (opts.purge) {
+        for (const f of toRemoveIfPurge)
+            removeOne(f);
+        ok('All state deleted (--purge)');
+    }
+    else {
+        warn(`Kept ${join(stateDir, 'state.db')} — pass --purge to delete all state`);
+    }
+    ok('Removal complete');
+}
+async function cmdMigrate(projectRoot) {
+    const dbPath = join(projectRoot, '.claudecontext', 'state.db');
+    if (!existsSync(dbPath)) {
+        warn('No state.db found — nothing to migrate');
+        return;
+    }
+    // Import Db dynamically to avoid errors if node:sqlite unavailable
+    try {
+        const { DatabaseSync } = await import('node:sqlite');
+        const db = new DatabaseSync(dbPath);
+        // Add columns if missing — SQLite does not support IF NOT EXISTS in ALTER TABLE,
+        // so we catch the "already has column" error specifically.
+        const migrations = [
+            { col: 'co_occurrence_count', sql: `ALTER TABLE edges ADD COLUMN co_occurrence_count INTEGER DEFAULT 1` },
+            { col: 'confidence', sql: `ALTER TABLE edges ADD COLUMN confidence REAL DEFAULT 1.0` },
+        ];
+        for (const { col, sql } of migrations) {
+            try {
+                db.exec(sql);
+                ok(`Migration applied: ${col}`);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (msg.includes('already has column')) {
+                    ok(`Column ${col} already present — skipping`);
+                }
+                else {
+                    throw e; // re-throw unexpected errors
+                }
+            }
+        }
+        db.close();
+        ok('Migration complete');
+    }
+    catch (e) {
+        err(`Migration failed: ${e}`);
+    }
+}
+async function cmdDoctor(projectRoot) {
+    let allOk = true;
+    const check = (label, ok_, hint) => {
+        if (ok_) {
+            ok(label);
+        }
+        else {
+            err(`${label}${hint ? ` — ${hint}` : ''}`);
+            allOk = false;
+        }
+    };
+    process.stdout.write('\n── ClaudeContext Doctor ─────────────────\n\n');
+    // Node version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1), 10);
+    check(`Node.js version: ${nodeVersion}`, major >= 22, 'Node 22+ required (node:sqlite)');
+    // State directory
+    const stateDir = join(projectRoot, '.claudecontext');
+    check('.claudecontext/ exists', existsSync(stateDir), 'Run: claudecontext init');
+    // Database
+    const dbPath = join(stateDir, 'state.db');
+    check('.claudecontext/state.db exists', existsSync(dbPath), 'Run: claudecontext init');
+    // .mcp.json
+    const mcpPath = join(projectRoot, '.mcp.json');
+    check('.mcp.json exists', existsSync(mcpPath), 'Run: claudecontext init');
+    if (existsSync(mcpPath)) {
+        try {
+            const mcp = JSON.parse(readFileSync(mcpPath, 'utf8'));
+            const server = mcp?.mcpServers?.claudecontext;
+            check('.mcp.json uses npx (not absolute path)', server?.command === 'npx', 'Absolute paths break on npm update');
+        }
+        catch {
+            check('.mcp.json is valid JSON', false);
+        }
+    }
+    // On Windows: verify node is in PATH (required for hook invocation)
+    if (isWindows) {
+        try {
+            execSync('node --version', { stdio: 'ignore' });
+            ok('node is in PATH (required for hooks on Windows)');
+        }
+        catch {
+            err('node not found in PATH — hooks use "node .claude/hooks/..." and require node in PATH');
+            allOk = false;
+        }
+    }
+    // Hook scripts — existence + execute permissions
+    const hooksDir = join(projectRoot, '.claude', 'hooks');
+    const hookFiles = ['session-start.mjs', 'pre-tool-use.mjs', 'post-write.mjs', 'pre-compact.mjs'];
+    for (const hookFile of hookFiles) {
+        const hookPath = join(hooksDir, hookFile);
+        const exists = existsSync(hookPath);
+        check(`Hook ${hookFile} exists`, exists, `Run: claudecontext init`);
+        if (exists && !isWindows) {
+            try {
+                const { statSync } = await import('node:fs');
+                const stats = statSync(hookPath);
+                const isExecutable = (stats.mode & 0o111) !== 0;
+                check(`Hook ${hookFile} is executable`, isExecutable, `Run: chmod +x .claude/hooks/${hookFile}`);
+            }
+            catch {
+                check(`Hook ${hookFile} is executable`, false, `Cannot stat file`);
+            }
+        }
+    }
+    // areas.json
+    const areasPath = join(stateDir, 'areas.json');
+    check('.claudecontext/areas.json exists', existsSync(areasPath), 'Run: claudecontext init to configure areas');
+    if (existsSync(areasPath)) {
+        try {
+            const existingAreas = JSON.parse(readFileSync(areasPath, 'utf8'));
+            if (Array.isArray(existingAreas) && existingAreas.length === 0) {
+                const detectable = detectAreas(projectRoot);
+                if (detectable.length > 0) {
+                    warn(`areas.json is empty — ${detectable.length} area(s) detected (${detectable.map(a => a.name).join(', ')}). Run: claudecontext auto-areas`);
+                }
+            }
+        }
+        catch { /* ignore parse errors — already reported */ }
+    }
+    // config.json (optional — validate if present)
+    const configPath = join(stateDir, 'config.json');
+    if (existsSync(configPath)) {
+        try {
+            const cfg = JSON.parse(readFileSync(configPath, 'utf8'));
+            const budgets = cfg.budgets;
+            if (budgets !== undefined) {
+                const budgetKeys = ['L0', 'L1', 'L2', 'L3', 'L4', 'graph', 'total'];
+                const invalidKeys = Object.keys(budgets).filter(k => !budgetKeys.includes(k));
+                const invalidValues = Object.entries(budgets)
+                    .filter(([, v]) => typeof v !== 'number' || v <= 0 || !Number.isInteger(v));
+                const totalOver = typeof budgets.total === 'number' && budgets.total > 200_000;
+                if (invalidKeys.length > 0) {
+                    err(`.claudecontext/config.json budgets has unknown keys: ${invalidKeys.join(', ')}`);
+                    allOk = false;
+                }
+                else if (invalidValues.length > 0) {
+                    err(`.claudecontext/config.json budgets values must be positive integers`);
+                    allOk = false;
+                }
+                else if (totalOver) {
+                    err(`.claudecontext/config.json total budget > 200000 — this may cause performance issues`);
+                    allOk = false;
+                }
+                else {
+                    ok('.claudecontext/config.json is valid');
+                }
+            }
+            else {
+                ok('.claudecontext/config.json is valid (no budget overrides)');
+            }
+        }
+        catch {
+            err('.claudecontext/config.json is not valid JSON — run: claudecontext init');
+            allOk = false;
+        }
+    }
+    // gate-rules.json (optional — skip if missing)
+    const gateRulesPath = join(stateDir, 'gate-rules.json');
+    if (existsSync(gateRulesPath)) {
+        try {
+            const rules = JSON.parse(readFileSync(gateRulesPath, 'utf8'));
+            const valid = Array.isArray(rules) && rules.every((r) => r && typeof r === 'object' &&
+                'action' in r && 'pattern' in r && 'reason' in r);
+            if (valid) {
+                ok('.claudecontext/gate-rules.json is valid');
+            }
+            else {
+                err('.claudecontext/gate-rules.json has invalid entries — each entry needs { action, pattern, reason }');
+                allOk = false;
+            }
+        }
+        catch {
+            err('.claudecontext/gate-rules.json is not valid JSON — run: claudecontext init');
+            allOk = false;
+        }
+    }
+    process.stdout.write('\n');
+    if (allOk) {
+        ok('All checks passed — ClaudeContext is healthy');
+    }
+    else {
+        warn('Some checks failed — run: claudecontext init to fix');
+    }
+    process.stdout.write('\n');
+}
+async function cmdAutoAreas(projectRoot, dryRun) {
+    process.stdout.write('\n── Auto-detecting areas ─────────────────\n\n');
+    log(`Scanning project structure in: ${projectRoot}`);
+    const proposed = detectAreas(projectRoot);
+    if (proposed.length === 0) {
+        warn('No detectable areas found — make sure src/ (or lib/, app/) has subdirectories with ≥3 source files.');
+        return;
+    }
+    process.stdout.write('\nProposed areas.json entries:\n');
+    for (const area of proposed) {
+        process.stdout.write(`  • ${area.name}: globs=${area.globs.join(', ')} → ${area.docPath}\n`);
+    }
+    if (dryRun) {
+        process.stdout.write('\n(dry-run — no changes written)\n\n');
+        return;
+    }
+    // Merge with existing areas (don't overwrite user-defined globs for same-name areas)
+    const stateDir = join(projectRoot, '.claudecontext');
+    const areasPath = join(stateDir, 'areas.json');
+    let existing = [];
+    if (existsSync(areasPath)) {
+        try {
+            existing = JSON.parse(readFileSync(areasPath, 'utf8'));
+        }
+        catch { /* ignore */ }
+    }
+    const existingNames = new Set(existing.map(a => a.name));
+    const toAdd = proposed.filter(a => !existingNames.has(a.name));
+    if (toAdd.length === 0) {
+        ok('All detected areas are already configured.');
+        return;
+    }
+    const merged = [...existing, ...toAdd];
+    if (!existsSync(stateDir))
+        mkdirSync(stateDir, { recursive: true });
+    writeFileSync(areasPath, JSON.stringify(merged, null, 2));
+    ok(`Added ${toAdd.length} area(s) to .claudecontext/areas.json: ${toAdd.map(a => a.name).join(', ')}`);
+    log('Run `claudecontext doctor` to verify.');
+    process.stdout.write('\n');
+}
+/**
+ * Register claudecontext as a user-scoped (global) MCP server.
+ *
+ * This means it's available in every project without per-project .mcp.json.
+ * Uses `claude mcp add --scope user` which writes to ~/.claude.json.
+ *
+ * Hooks are still per-project — run `claudecontext init` in each project for hooks.
+ */
+async function cmdGlobalInstall() {
+    process.stdout.write('\n╔══════════════════════════════════════╗\n');
+    process.stdout.write('║   ClaudeContext Global Install       ║\n');
+    process.stdout.write('╚══════════════════════════════════════╝\n\n');
+    log('This registers claudecontext as a user-scoped MCP server.');
+    log('After this, the MCP server is available in ALL your projects automatically.');
+    log('');
+    // Check Node version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1), 10);
+    if (major < 22) {
+        err(`Node.js ${nodeVersion} detected — Node 22+ required. Please upgrade.`);
+        process.exit(1);
+    }
+    ok(`Node.js ${nodeVersion}`);
+    // Check claude CLI is available (Windows uses claude.cmd)
+    const claudeBin = isWindows ? 'claude.cmd' : 'claude';
+    try {
+        execSync(`${claudeBin} --version`, { stdio: 'pipe' });
+        ok('claude CLI found');
+    }
+    catch {
+        err('claude CLI not found — install it with: npm install -g @anthropic-ai/claude-code');
+        process.exit(1);
+    }
+    // Register as user-scoped MCP server
+    // The MCP server uses process.cwd() as project root, which Claude Code sets to the project directory.
+    log('Registering with claude mcp add --scope user ...');
+    try {
+        execSync(`${claudeBin} mcp add --transport stdio --scope user claudecontext -- npx --no-warnings claudecontext-mcp`, { stdio: 'inherit' });
+        ok('claudecontext registered as global MCP server');
+    }
+    catch {
+        warn('claude mcp add failed — attempting manual registration in ~/.claude.json ...');
+        // Fallback: write directly to ~/.claude.json
+        const homeDir = process.env['HOME'] ?? process.env['USERPROFILE'] ?? '';
+        const claudeJsonPath = join(homeDir, '.claude.json');
+        let claudeJson = {};
+        if (existsSync(claudeJsonPath)) {
+            try {
+                claudeJson = JSON.parse(readFileSync(claudeJsonPath, 'utf8'));
+            }
+            catch { /* ignore */ }
+        }
+        const mcpServers = claudeJson['mcpServers'] ?? {};
+        mcpServers['claudecontext'] = {
+            type: 'stdio',
+            command: 'npx',
+            args: ['claudecontext-mcp'],
+            env: { NODE_OPTIONS: '--no-warnings' },
+        };
+        claudeJson['mcpServers'] = mcpServers;
+        writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2));
+        ok(`Written to ${claudeJsonPath}`);
+    }
+    process.stdout.write('\n╔══════════════════════════════════════╗\n');
+    process.stdout.write('║     Global install complete!         ║\n');
+    process.stdout.write('╚══════════════════════════════════════╝\n\n');
+    log('The claudecontext MCP server is now available in all your projects.');
+    log('');
+    log('To verify: open any project in Claude Code and run context_status()');
+    log('');
+    log('Note: Hooks (SessionStart, PreToolUse, etc.) are still per-project.');
+    log('Run `claudecontext init` in each project to install hooks.');
+    log('');
+}
+// ── Main ───────────────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+const command = args[0];
+const projectRootArg = args.indexOf('--project-root');
+const projectRoot = projectRootArg !== -1
+    ? resolve(args[projectRootArg + 1] ?? process.cwd())
+    : resolve(process.cwd());
+switch (command) {
+    case 'init': {
+        const yes = args.includes('--yes');
+        const configIdx = args.indexOf('--config');
+        const config = configIdx !== -1 ? args[configIdx + 1] : undefined;
+        const initOpts = {};
+        if (yes)
+            initOpts.yes = true;
+        if (config)
+            initOpts.config = config;
+        await cmdInit(projectRoot, initOpts);
+        break;
+    }
+    case 'global-install':
+        await cmdGlobalInstall();
+        break;
+    case 'remove': {
+        const dryRun = args.includes('--dry-run');
+        const purge = args.includes('--purge');
+        cmdRemove(projectRoot, { dryRun, purge });
+        break;
+    }
+    case 'migrate':
+        await cmdMigrate(projectRoot);
+        break;
+    case 'doctor':
+        await cmdDoctor(projectRoot);
+        break;
+    case 'auto-areas': {
+        const dryRun = args.includes('--dry-run');
+        await cmdAutoAreas(projectRoot, dryRun);
+        break;
+    }
+    default:
+        process.stdout.write(`
+ClaudeContext — Persistent memory for Claude Code
+
+Commands:
+  claudecontext init [--project-root <path>]   Set up ClaudeContext in a project (interactive)
+    --yes                                         Skip prompts, use auto-detected defaults
+    --config <file>                               Load setup from a JSON config file (non-interactive)
+  claudecontext global-install                  Register as global MCP (available in all projects)
+  claudecontext remove                          Remove hooks and config (preserves state.db)
+    --dry-run                                     Show what would be removed without deleting
+    --purge                                       Also delete state.db and .claudecontext/
+  claudecontext migrate                         Migrate database schema
+  claudecontext doctor                          Check installation health
+  claudecontext auto-areas [--dry-run]          Auto-detect subsystem areas from directory structure
+
+`);
+        process.exit(command ? 1 : 0);
+}
+//# sourceMappingURL=install.js.map