@tonycasey/lisa 1.2.0 → 2.0.0

package/dist/lib/cli.js

@@ -0,0 +1,664 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScan = exports.TEMPLATE_ROOT = exports.DEFAULT_GROUP = exports.DEFAULT_ENDPOINT = exports.createDefaultServices = void 0;
+exports.initCommand = initCommand;
+exports.doctorCommand = doctorCommand;
+exports.upCommand = upCommand;
+exports.downCommand = downCommand;
+const commander_1 = require("commander");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = require("@inquirer/prompts");
+const services_1 = require("./services");
+Object.defineProperty(exports, "createDefaultServices", { enumerable: true, get: function () { return services_1.createDefaultServices; } });
+const scanner_1 = require("./scanner");
+Object.defineProperty(exports, "runScan", { enumerable: true, get: function () { return scanner_1.runScan; } });
+const logging_1 = require("./infrastructure/logging");
+// Templates are copied into dist/project by postbuild; resolve relative to compiled file.
+const TEMPLATE_ROOT = path_1.default.join(__dirname, '..', 'project');
+exports.TEMPLATE_ROOT = TEMPLATE_ROOT;
+// Bundled hooks and plugins are in dist/hooks and dist/opencode
+const BUNDLED_HOOKS_ROOT = path_1.default.join(__dirname, '..', 'hooks');
+const BUNDLED_OPENCODE_ROOT = path_1.default.join(__dirname, '..', 'opencode');
+// Read version from package.json (works in both dev and dist)
+const PACKAGE_JSON_PATH = path_1.default.join(__dirname, '..', '..', 'package.json');
+const VERSION = fs_extra_1.default.existsSync(PACKAGE_JSON_PATH)
+    ? fs_extra_1.default.readJsonSync(PACKAGE_JSON_PATH).version
+    : '0.0.0';
+const DEFAULT_ENDPOINT = 'http://localhost:8010/mcp/';
+exports.DEFAULT_ENDPOINT = DEFAULT_ENDPOINT;
+const ZEP_CLOUD_ENDPOINT = 'https://api.getzep.com/mcp/';
+/**
+ * Get project name from package.json or directory name.
+ * Used as the default group ID for memory storage.
+ */
+function getProjectName() {
+    try {
+        const pkgPath = path_1.default.join(process.cwd(), 'package.json');
+        if (fs_extra_1.default.existsSync(pkgPath)) {
+            const pkg = fs_extra_1.default.readJsonSync(pkgPath);
+            if (pkg.name) {
+                // Remove scope prefix if present (e.g., @tonycasey/lisa -> lisa)
+                return pkg.name.replace(/^@[^/]+\//, '');
+            }
+        }
+    }
+    catch {
+        // Ignore errors reading package.json
+    }
+    // Fall back to directory name
+    return path_1.default.basename(process.cwd());
+}
+const DEFAULT_GROUP = getProjectName();
+exports.DEFAULT_GROUP = DEFAULT_GROUP;
+// Create CLI logger (console disabled by default to avoid interfering with CLI output)
+const cliLogger = (0, logging_1.createLogger)({
+    enableConsole: process.env.LOG_CONSOLE === 'true',
+    enableFile: process.env.LOG_FILE !== 'false',
+});
+/**
+ * Create a symlink with Windows fallback.
+ * On Windows, tries junction first, then falls back to directory copy.
+ * Records copy fallbacks for later sync.
+ */
+async function createSymlink(target, link, cwd) {
+    const isWindows = process.platform === 'win32';
+    const projectRoot = cwd || process.cwd();
+    // Skip if link already exists (use lstat to detect symlinks even if target doesn't exist)
+    try {
+        await fs_extra_1.default.lstat(link);
+        return; // Link exists (symlink, junction, or regular file/dir)
+    }
+    catch {
+        // Link doesn't exist, proceed with creation
+    }
+    // Calculate relative path from link to target (for Unix symlinks)
+    const linkDir = path_1.default.dirname(link);
+    const relativeTarget = path_1.default.relative(linkDir, target);
+    try {
+        if (isWindows) {
+            // Windows junctions require absolute paths
+            const absoluteTarget = path_1.default.resolve(target);
+            // Try junction first (doesn't require admin rights)
+            await fs_extra_1.default.symlink(absoluteTarget, link, 'junction');
+        }
+        else {
+            // Unix: standard symlink with relative path
+            await fs_extra_1.default.symlink(relativeTarget, link, 'dir');
+        }
+    }
+    catch (err) {
+        const error = err;
+        if (isWindows && (error.code === 'EPERM' || error.code === 'ENOENT' || error.code === 'EINVAL')) {
+            // Junction failed, fall back to copy
+            console.warn(chalk_1.default.yellow(`  Symlink failed, copying directory instead: ${path_1.default.basename(link)}`));
+            await fs_extra_1.default.copy(target, link);
+            // Record that we used copy (for future sync)
+            await recordCopyFallback(projectRoot, link, target);
+        }
+        else {
+            throw err;
+        }
+    }
+}
+/**
+ * Track directories that were copied instead of linked.
+ * Used by `lisa sync` to keep copies up to date.
+ */
+async function recordCopyFallback(projectRoot, link, target) {
+    const fallbackFile = path_1.default.join(projectRoot, '.lisa', '.copy-fallbacks.json');
+    let existing = { copies: [] };
+    try {
+        existing = await fs_extra_1.default.readJson(fallbackFile);
+    }
+    catch {
+        // File doesn't exist yet, use default
+    }
+    // Store relative paths
+    const relLink = path_1.default.relative(projectRoot, link);
+    const relTarget = path_1.default.relative(projectRoot, target);
+    // Check if already recorded
+    if (!existing.copies.some(c => c.link === relLink)) {
+        existing.copies.push({ link: relLink, target: relTarget, createdAt: new Date().toISOString() });
+        await fs_extra_1.default.ensureDir(path_1.default.dirname(fallbackFile));
+        await fs_extra_1.default.writeJson(fallbackFile, existing, { spaces: 2 });
+    }
+}
+// Interactive prompt functions
+async function promptDeploymentMode() {
+    return await (0, prompts_1.select)({
+        message: 'How would you like to configure storage?',
+        choices: [
+            {
+                name: 'Local Docker (runs Neo4j + MCP server locally)',
+                value: 'local',
+            },
+            {
+                name: 'Zep Cloud (managed storage service)',
+                value: 'zep-cloud',
+            },
+            {
+                name: 'Set up later (scaffold project, configure storage later)',
+                value: 'skip',
+            },
+        ],
+    });
+}
+async function promptZepCloudConfig() {
+    const zepApiKey = await (0, prompts_1.password)({
+        message: 'Zep API Key:',
+        validate: (val) => val.length > 0 || 'API key is required',
+    });
+    const zepProjectId = await (0, prompts_1.input)({
+        message: 'Zep Project ID:',
+        validate: (val) => val.length > 0 || 'Project ID is required',
+    });
+    return {
+        zepApiKey,
+        zepProjectId,
+        endpoint: ZEP_CLOUD_ENDPOINT,
+    };
+}
+async function promptGroupId() {
+    const projectName = path_1.default.basename(process.cwd());
+    return await (0, prompts_1.input)({
+        message: 'Group ID:',
+        default: projectName,
+    });
+}
+async function promptCliSupport() {
+    const choices = await (0, prompts_1.checkbox)({
+        message: 'Which CLI tools do you want to support?',
+        choices: [
+            {
+                name: 'Claude Code (Anthropic)',
+                value: 'claude-code',
+                checked: true,
+            },
+            {
+                name: 'OpenCode (open source)',
+                value: 'opencode',
+                checked: true,
+            },
+        ],
+    });
+    // Default to both if none selected
+    if (choices.length === 0) {
+        return ['claude-code', 'opencode'];
+    }
+    return choices;
+}
+async function initCommand(opts, services) {
+    const force = Boolean(opts.force);
+    const cwd = opts.cwd;
+    let config;
+    let cliSupport;
+    // Determine if we need interactive prompts
+    const hasExplicitMode = opts.mode !== undefined;
+    const skipPrompts = opts.yes || hasExplicitMode;
+    if (skipPrompts) {
+        // Non-interactive mode - use provided options or defaults
+        const mode = opts.mode || 'local';
+        config = {
+            mode,
+            endpoint: opts.endpoint || (mode === 'zep-cloud' ? ZEP_CLOUD_ENDPOINT : DEFAULT_ENDPOINT),
+            groupId: opts.group || process.env.GRAPHITI_GROUP_ID || DEFAULT_GROUP,
+            zepApiKey: opts.zepApiKey,
+            zepProjectId: opts.zepProjectId,
+        };
+        // Default to both CLIs if not specified
+        cliSupport = opts.cliSupport || ['claude-code', 'opencode'];
+    }
+    else {
+        // Interactive mode - prompt user
+        const mode = await promptDeploymentMode();
+        let modeConfig = {};
+        if (mode === 'zep-cloud') {
+            modeConfig = await promptZepCloudConfig();
+        }
+        else {
+            modeConfig = { endpoint: DEFAULT_ENDPOINT };
+        }
+        const groupId = await promptGroupId();
+        // Prompt for CLI support
+        cliSupport = await promptCliSupport();
+        config = {
+            mode,
+            endpoint: modeConfig.endpoint || DEFAULT_ENDPOINT,
+            groupId,
+            ...modeConfig,
+        };
+    }
+    const includeDocker = opts.includeDocker !== false && config.mode !== 'zep-cloud' && config.mode !== 'skip';
+    const supportClaudeCode = cliSupport.includes('claude-code');
+    const supportOpenCode = cliSupport.includes('opencode');
+    const replacements = {
+        GRAPHITI_ENDPOINT: config.endpoint,
+        GRAPHITI_GROUP: config.groupId,
+        GRAPHITI_GROUP_ID: config.groupId,
+        PROJECT_NAME: config.groupId,
+    };
+    const lisaDir = path_1.default.join(cwd, '.lisa');
+    const skillsDir = path_1.default.join(lisaDir, 'skills');
+    const rulesDir = path_1.default.join(lisaDir, 'rules');
+    const claudeDir = path_1.default.join(cwd, '.claude');
+    const composeDest = path_1.default.join(cwd, 'docker-compose.graphiti.yml');
+    const copies = [];
+    // Create .env from template on first install only (preserve user customizations)
+    const envDest = path_1.default.join(lisaDir, '.env');
+    if (!await fs_extra_1.default.pathExists(envDest)) {
+        await fs_extra_1.default.ensureDir(lisaDir);
+        copies.push(services.templateCopier.copy('.lisa/.env.template', envDest, replacements, false // Never force overwrite - preserves user customizations
+        ));
+    }
+    // Skill scaffolding (model-neutral)
+    copies.push(services.templateCopier.copy('.lisa/skills/memory/SKILL.md', path_1.default.join(skillsDir, 'memory', 'SKILL.md'), replacements, force));
+    copies.push(services.templateCopier.copy('.lisa/skills/tasks/SKILL.md', path_1.default.join(skillsDir, 'tasks', 'SKILL.md'), replacements, force));
+    // Rules scaffolding (shared)
+    copies.push(services.templateCopier.copy('.lisa/rules/shared/clean-architecture.md', path_1.default.join(rulesDir, 'shared', 'clean-architecture.md'), replacements, force));
+    copies.push(services.templateCopier.copy('.lisa/rules/shared/code-quality-rules.md', path_1.default.join(rulesDir, 'shared', 'code-quality-rules.md'), replacements, force));
+    copies.push(services.templateCopier.copy('.lisa/rules/shared/testing-principles.md', path_1.default.join(rulesDir, 'shared', 'testing-principles.md'), replacements, force));
+    // Rules scaffolding (typescript)
+    copies.push(services.templateCopier.copy('.lisa/rules/typescript/coding-standards.md', path_1.default.join(rulesDir, 'typescript', 'coding-standards.md'), replacements, force));
+    copies.push(services.templateCopier.copy('.lisa/rules/typescript/testing.md', path_1.default.join(rulesDir, 'typescript', 'testing.md'), replacements, force));
+    copies.push(services.templateCopier.copy('.lisa/rules/typescript/typescript-config-guide.md', path_1.default.join(rulesDir, 'typescript', 'typescript-config-guide.md'), replacements, force));
+    // Claude Code scaffolding (hooks and settings) - only if Claude Code is selected
+    if (supportClaudeCode) {
+        copies.push(services.templateCopier.copy('.claude/config.js', path_1.default.join(claudeDir, 'config.js'), replacements, force));
+        // Copy bundled hooks (these are pre-bundled with all dependencies)
+        const hooksDir = path_1.default.join(claudeDir, 'hooks');
+        await fs_extra_1.default.ensureDir(hooksDir);
+        const bundledHooks = ['session-start.js', 'session-stop.js', 'user-prompt-submit.js'];
+        for (const hook of bundledHooks) {
+            const src = path_1.default.join(BUNDLED_HOOKS_ROOT, hook);
+            const dest = path_1.default.join(hooksDir, hook);
+            if (await fs_extra_1.default.pathExists(src)) {
+                copies.push(fs_extra_1.default.copy(src, dest, { overwrite: force }));
+            }
+        }
+        // Create symlinks for .claude/skills and .claude/rules
+        await createSymlink(skillsDir, path_1.default.join(claudeDir, 'skills'), cwd);
+        await createSymlink(rulesDir, path_1.default.join(claudeDir, 'rules'), cwd);
+    }
+    // OpenCode scaffolding - only if OpenCode is selected
+    if (supportOpenCode) {
+        const opencodeDir = path_1.default.join(cwd, '.opencode');
+        const pluginDir = path_1.default.join(opencodeDir, 'plugin');
+        await fs_extra_1.default.ensureDir(pluginDir);
+        // Copy bundled OpenCode plugin
+        const pluginSrc = path_1.default.join(BUNDLED_OPENCODE_ROOT, 'lisa.js');
+        const pluginDest = path_1.default.join(pluginDir, 'lisa.js');
+        if (await fs_extra_1.default.pathExists(pluginSrc)) {
+            copies.push(fs_extra_1.default.copy(pluginSrc, pluginDest, { overwrite: force }));
+        }
+        // Create symlink for .opencode/skills
+        await createSymlink(skillsDir, path_1.default.join(opencodeDir, 'skills'), cwd);
+    }
+    if (includeDocker) {
+        // Choose compose file based on mode
+        const composeTemplate = '.lisa/docker/docker-compose.graphiti.yml';
+        copies.push(services.templateCopier.copy(composeTemplate, composeDest, replacements, force));
+    }
+    await Promise.all(copies);
+    // Build scaffolded directories list
+    const scaffoldedDirs = ['.lisa'];
+    if (supportClaudeCode)
+        scaffoldedDirs.push('.claude');
+    if (supportOpenCode)
+        scaffoldedDirs.push('.opencode');
+    if (includeDocker)
+        scaffoldedDirs.push('Docker assets');
+    console.log(chalk_1.default.green(`Scaffolded ${scaffoldedDirs.join(', ')} into ${cwd}`));
+    console.log(`Mode: ${config.mode}`);
+    console.log(`Endpoint: ${config.endpoint}`);
+    console.log(`Group ID: ${config.groupId}`);
+    console.log(`CLI Support: ${cliSupport.join(', ')}`);
+    // Save config to .lisa/lisa.config.json
+    const lisaConfigPath = path_1.default.join(lisaDir, 'lisa.config.json');
+    const lisaConfig = {
+        graphiti: config,
+        cliSupport,
+    };
+    await fs_extra_1.default.ensureDir(lisaDir);
+    await fs_extra_1.default.writeJson(lisaConfigPath, lisaConfig, { spaces: 2 });
+    console.log(chalk_1.default.green(`Saved configuration to ${lisaConfigPath}`));
+    // Show skip mode instructions
+    if (config.mode === 'skip') {
+        console.log('');
+        console.log(chalk_1.default.cyan('To configure storage later:'));
+        console.log(chalk_1.default.cyan('  1. Read .lisa/docs/STORAGE_SETUP.md'));
+        console.log(chalk_1.default.cyan('  2. Edit .lisa/.env with your configuration'));
+        console.log(chalk_1.default.cyan('  3. Start a new terminal session'));
+        console.log(chalk_1.default.cyan('  4. Run `lisa doctor` to verify connection'));
+    }
+    // Isolated mode: create .claude/lib structure for non-npm projects
+    if (opts.isolated) {
+        const libDir = path_1.default.join(claudeDir, 'lib');
+        await fs_extra_1.default.ensureDir(libDir);
+        // Create minimal package.json in .claude/lib
+        const libPackageJson = {
+            name: 'claude-lib',
+            version: '1.0.0',
+            private: true,
+            description: 'Lisa support files for Claude Code',
+        };
+        const libPackagePath = path_1.default.join(libDir, 'package.json');
+        if (!await fs_extra_1.default.pathExists(libPackagePath) || force) {
+            await fs_extra_1.default.writeJson(libPackagePath, libPackageJson, { spaces: 2 });
+            console.log(chalk_1.default.green('Created .claude/lib/package.json'));
+        }
+        // Add .claude/lib to .gitignore if not already there
+        const gitignorePath = path_1.default.join(cwd, '.gitignore');
+        if (await fs_extra_1.default.pathExists(gitignorePath)) {
+            let gitignore = await fs_extra_1.default.readFile(gitignorePath, 'utf8');
+            if (!gitignore.includes('.claude/lib/node_modules')) {
+                gitignore += '\n# Lisa support files\n.claude/lib/node_modules/\n';
+                await fs_extra_1.default.writeFile(gitignorePath, gitignore);
+                console.log(chalk_1.default.green('Added .claude/lib/node_modules to .gitignore'));
+            }
+        }
+        console.log('');
+        console.log(chalk_1.default.cyan('Isolated mode: Lisa installed to .claude/lib/'));
+        console.log(chalk_1.default.cyan('Your project root stays clean (no package.json or node_modules).'));
+    }
+}
+async function loadConfig(cwd) {
+    const lisaEnv = path_1.default.join(cwd, '.lisa', '.env');
+    if (!(await fs_extra_1.default.pathExists(lisaEnv)))
+        return null;
+    const raw = await fs_extra_1.default.readFile(lisaEnv, 'utf8');
+    const map = {};
+    raw.split(/\r?\n/).forEach((line) => {
+        if (!line || line.startsWith('#'))
+            return;
+        const idx = line.indexOf('=');
+        if (idx === -1)
+            return;
+        const key = line.slice(0, idx).trim();
+        const val = line.slice(idx + 1).trim();
+        map[key] = val;
+    });
+    return {
+        endpoint: map.GRAPHITI_ENDPOINT || DEFAULT_ENDPOINT,
+        group: map.GRAPHITI_GROUP_ID || DEFAULT_GROUP,
+        mode: map.STORAGE_MODE || 'local',
+        zepApiKey: map.ZEP_API_KEY,
+    };
+}
+async function doctorCommand(opts, services) {
+    const cwd = opts.cwd;
+    const composeFile = opts.compose || path_1.default.join(cwd, 'docker-compose.graphiti.yml');
+    const config = (await loadConfig(cwd)) ?? { endpoint: undefined, group: undefined, mode: 'local' };
+    const endpoint = opts.endpoint || config.endpoint || DEFAULT_ENDPOINT;
+    const mode = config.mode || 'local';
+    const results = [];
+    // Show current mode
+    results.push(chalk_1.default.cyan(`Mode: ${mode}`));
+    results.push(chalk_1.default.cyan(`Group: ${config.group || DEFAULT_GROUP}`));
+    results.push('');
+    // Mode-specific checks
+    if (mode === 'zep-cloud') {
+        // Zep Cloud mode - no local Docker needed
+        results.push(chalk_1.default.yellow('Zep Cloud mode - no local Docker required'));
+        results.push('');
+        // Get API key from config or environment for Zep Cloud authentication
+        const zepApiKey = config.zepApiKey || process.env.ZEP_API_KEY;
+        if (!zepApiKey) {
+            results.push(chalk_1.default.yellow('Warning: ZEP_API_KEY not configured (required for Zep Cloud)'));
+        }
+        try {
+            await services.mcp.ping(endpoint, { apiKey: zepApiKey });
+            results.push(chalk_1.default.green(`Zep MCP reachable at ${endpoint}`));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push(chalk_1.default.red(`Zep MCP check failed at ${endpoint}: ${message}`));
+        }
+    }
+    else {
+        // Local mode - Docker is needed
+        try {
+            const stdout = await services.docker.version();
+            results.push(chalk_1.default.green(`Docker OK: ${stdout}`));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push(chalk_1.default.red(`Docker missing or not running: ${message}`));
+        }
+        try {
+            const stdout = await services.docker.composeVersion();
+            results.push(chalk_1.default.green(`Docker Compose OK: ${stdout}`));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push(chalk_1.default.red(`Docker Compose missing: ${message}`));
+        }
+        if (await fs_extra_1.default.pathExists(composeFile)) {
+            results.push(chalk_1.default.green(`Compose file found: ${composeFile}`));
+        }
+        else {
+            results.push(chalk_1.default.red(`Compose file not found: ${composeFile}`));
+        }
+        try {
+            await services.mcp.ping(endpoint);
+            results.push(chalk_1.default.green(`MCP reachable at ${endpoint}`));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            results.push(chalk_1.default.red(`MCP check failed at ${endpoint}: ${message}`));
+        }
+    }
+    console.log(results.join('\n'));
+}
+async function upCommand(opts, services) {
+    await services.docker.compose(opts.composeFile, ['up', '-d']);
+}
+async function downCommand(opts, services) {
+    await services.docker.compose(opts.composeFile, ['down']);
+}
+const program = new commander_1.Command();
+program
+    .name('lisa')
+    .description('Lisa remembers everything. Memory for Claude Code and AI assistants.')
+    .version(VERSION);
+program
+    .command('init')
+    .description('Scaffold .lisa, .claude/.opencode, and Docker assets')
+    .option('-e, --endpoint <url>', 'MCP endpoint')
+    .option('-g, --group <id>', 'Default group id')
+    .option('-f, --force', 'Overwrite existing files')
+    .option('-m, --mode <mode>', 'Deployment mode: local or zep-cloud')
+    .option('--zep-api-key <key>', 'Zep API key (for zep-cloud mode)')
+    .option('--zep-project-id <id>', 'Zep project ID (for zep-cloud mode)')
+    .option('-y, --yes', 'Skip prompts, use defaults')
+    .option('--isolated', 'Install to .claude/lib for non-npm projects (Python, Go, etc.)')
+    .option('--claude-only', 'Only scaffold for Claude Code')
+    .option('--opencode-only', 'Only scaffold for OpenCode')
+    .action(async (cmd) => {
+    await (0, logging_1.withCorrelation)(async () => {
+        const log = cliLogger.child({ command: 'init' });
+        log.info('Starting init command', {
+            mode: cmd.mode,
+            claudeOnly: cmd.claudeOnly,
+            opencodeOnly: cmd.opencodeOnly
+        });
+        const services = (0, services_1.createDefaultServices)(TEMPLATE_ROOT);
+        // Determine CLI support from flags
+        let cliSupport;
+        if (cmd.claudeOnly && !cmd.opencodeOnly) {
+            cliSupport = ['claude-code'];
+        }
+        else if (cmd.opencodeOnly && !cmd.claudeOnly) {
+            cliSupport = ['opencode'];
+        }
+        else if (cmd.claudeOnly && cmd.opencodeOnly) {
+            cliSupport = ['claude-code', 'opencode'];
+        }
+        // If neither flag is set, cliSupport remains undefined and prompts will be shown
+        await initCommand({
+            endpoint: cmd.endpoint,
+            group: cmd.group,
+            force: cmd.force,
+            cwd: process.cwd(),
+            includeDocker: true,
+            mode: cmd.mode,
+            zepApiKey: cmd.zepApiKey,
+            zepProjectId: cmd.zepProjectId,
+            yes: cmd.yes,
+            isolated: cmd.isolated,
+            cliSupport,
+        }, services);
+        log.info('Init command completed');
+    });
+});
+program
+    .command('setup')
+    .description('Scaffold .lisa and .claude/.opencode only (no Docker assets)')
+    .option('-e, --endpoint <url>', 'MCP endpoint')
+    .option('-g, --group <id>', 'Default group id')
+    .option('-f, --force', 'Overwrite existing files')
+    .option('-m, --mode <mode>', 'Deployment mode: local or zep-cloud')
+    .option('--zep-api-key <key>', 'Zep API key (for zep-cloud mode)')
+    .option('--zep-project-id <id>', 'Zep project ID (for zep-cloud mode)')
+    .option('-y, --yes', 'Skip prompts, use defaults')
+    .option('--isolated', 'Install to .claude/lib for non-npm projects (Python, Go, etc.)')
+    .option('--claude-only', 'Only scaffold for Claude Code')
+    .option('--opencode-only', 'Only scaffold for OpenCode')
+    .action(async (cmd) => {
+    const services = (0, services_1.createDefaultServices)(TEMPLATE_ROOT);
+    // Determine CLI support from flags
+    let cliSupport;
+    if (cmd.claudeOnly && !cmd.opencodeOnly) {
+        cliSupport = ['claude-code'];
+    }
+    else if (cmd.opencodeOnly && !cmd.claudeOnly) {
+        cliSupport = ['opencode'];
+    }
+    else if (cmd.claudeOnly && cmd.opencodeOnly) {
+        cliSupport = ['claude-code', 'opencode'];
+    }
+    await initCommand({
+        endpoint: cmd.endpoint,
+        group: cmd.group,
+        force: cmd.force,
+        cwd: process.cwd(),
+        includeDocker: false,
+        mode: cmd.mode,
+        zepApiKey: cmd.zepApiKey,
+        zepProjectId: cmd.zepProjectId,
+        yes: cmd.yes,
+        isolated: cmd.isolated,
+        cliSupport,
+    }, services);
+});
+program
+    .command('up')
+    .description('Start Neo4j/Graph/graphiti-mcp via docker compose')
+    .option('-c, --compose <file>', 'Compose file', 'docker-compose.graphiti.yml')
+    .action(async (cmd) => {
+    const composeFile = path_1.default.resolve(process.cwd(), cmd.compose);
+    const services = (0, services_1.createDefaultServices)(TEMPLATE_ROOT);
+    await upCommand({ composeFile }, services);
+});
+program
+    .command('down')
+    .description('Stop Neo4j/Graph/graphiti-mcp via docker compose')
+    .option('-c, --compose <file>', 'Compose file', 'docker-compose.graphiti.yml')
+    .action(async (cmd) => {
+    const composeFile = path_1.default.resolve(process.cwd(), cmd.compose);
+    const services = (0, services_1.createDefaultServices)(TEMPLATE_ROOT);
+    await downCommand({ composeFile }, services);
+});
+program
+    .command('doctor')
+    .description('Validate Docker and MCP connectivity')
+    .option('-c, --compose <file>', 'Compose file', 'docker-compose.graphiti.yml')
+    .option('-e, --endpoint <url>', 'MCP endpoint override')
+    .action(async (cmd) => {
+    const services = (0, services_1.createDefaultServices)(TEMPLATE_ROOT);
+    await doctorCommand({ cwd: process.cwd(), compose: cmd.compose, endpoint: cmd.endpoint }, services);
+});
+program
+    .command('scan [path]')
+    .description('Scan a directory for projects and create solution-level knowledge')
+    .option('--dry-run', 'Preview what would be discovered without storing facts')
+    .option('--clean', 'Remove previous scan facts before adding new ones')
+    .option('-v, --verbose', 'Show detailed output for each project')
+    .action(async (targetPath, cmd) => {
+    await (0, logging_1.withCorrelation)(async () => {
+        const log = cliLogger.child({ command: 'scan' });
+        const scanPath = targetPath || process.cwd();
+        log.info('Starting scan', {
+            path: scanPath,
+            dryRun: cmd.dryRun,
+            clean: cmd.clean,
+            verbose: cmd.verbose,
+        });
+        const options = {
+            dryRun: cmd.dryRun,
+            clean: cmd.clean,
+            verbose: cmd.verbose,
+        };
+        try {
+            const result = await (0, scanner_1.runScan)(scanPath, options);
+            log.info('Scan completed', {
+                success: result.success,
+                projectsFound: result.projectsFound,
+                factsGenerated: result.factsGenerated,
+            });
+            process.exit(result.success ? 0 : 1);
+        }
+        catch (err) {
+            log.error('Scan failed', { error: err instanceof Error ? err.message : String(err) });
+            console.error(chalk_1.default.red(`Scan failed: ${err instanceof Error ? err.message : err}`));
+            process.exit(1);
+        }
+    });
+});
+program
+    .command('sync')
+    .description('Sync copied directories (for Windows when symlinks fail)')
+    .action(async () => {
+    const cwd = process.cwd();
+    const fallbackFile = path_1.default.join(cwd, '.lisa', '.copy-fallbacks.json');
+    if (!await fs_extra_1.default.pathExists(fallbackFile)) {
+        console.log(chalk_1.default.yellow('No copy fallbacks found. Symlinks are working correctly.'));
+        return;
+    }
+    try {
+        const { copies } = await fs_extra_1.default.readJson(fallbackFile);
+        if (!copies || copies.length === 0) {
+            console.log(chalk_1.default.yellow('No directories need syncing.'));
+            return;
+        }
+        console.log(chalk_1.default.cyan(`Syncing ${copies.length} copied directories...`));
+        for (const { link, target } of copies) {
+            const linkPath = path_1.default.join(cwd, link);
+            const targetPath = path_1.default.join(cwd, target);
+            if (!await fs_extra_1.default.pathExists(targetPath)) {
+                console.log(chalk_1.default.yellow(`  Skipping ${link}: source ${target} not found`));
+                continue;
+            }
+            await fs_extra_1.default.remove(linkPath);
+            await fs_extra_1.default.copy(targetPath, linkPath);
+            console.log(chalk_1.default.green(`  Synced: ${link}`));
+        }
+        console.log(chalk_1.default.green('Sync complete.'));
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`Sync failed: ${err instanceof Error ? err.message : err}`));
+        process.exit(1);
+    }
+});
+if (require.main === module) {
+    program.parseAsync(process.argv).catch((err) => {
+        console.error(chalk_1.default.red(err.message));
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=cli.js.map