@colbymchenry/codegraph 0.2.9 → 0.4.8

package/dist/bin/codegraph.js

@@ -9,13 +9,18 @@
  *   codegraph                    Run interactive installer (when no args)
  *   codegraph install            Run interactive installer
  *   codegraph init [path]        Initialize CodeGraph in a project
+ *   codegraph uninit [path]      Remove CodeGraph from a project
  *   codegraph index [path]       Index all files in the project
  *   codegraph sync [path]        Sync changes since last index
  *   codegraph status [path]      Show index status
  *   codegraph query <search>     Search for symbols
+ *   codegraph files [options]    Show project file structure
  *   codegraph context <task>     Build context for a task
- *   codegraph hooks install      Install git hooks
- *   codegraph hooks remove       Remove git hooks
+ *   codegraph mark-dirty [path]  Mark project as needing sync (hooks)
+ *   codegraph sync-if-dirty [path] Sync if marked dirty (hooks)
+ *
+ * Note: Git hooks have been removed. CodeGraph sync is triggered automatically
+ * through codegraph's Claude Code hooks integration.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -50,18 +55,27 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
-const index_1 = __importDefault(require("../index"));
+const index_1 = __importStar(require("../index"));
 const installer_1 = require("../installer");
+const sentry_1 = require("../sentry");
 // Check if running with no arguments - run installer
+// Read version for Sentry release tag
+const pkgVersion = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8')).version;
+    }
+    catch {
+        return undefined;
+    }
+})();
+(0, sentry_1.initSentry)({ processName: 'codegraph-cli', version: pkgVersion });
 if (process.argv.length === 2) {
     (0, installer_1.runInstaller)().catch((err) => {
+        (0, sentry_1.captureException)(err);
         console.error('Installation failed:', err.message);
         process.exit(1);
     });
@@ -70,6 +84,14 @@ else {
     // Normal CLI flow
     main();
 }
+process.on('uncaughtException', (error) => {
+    (0, sentry_1.captureException)(error);
+    console.error('[CodeGraph] Uncaught exception:', error);
+});
+process.on('unhandledRejection', (reason) => {
+    (0, sentry_1.captureException)(reason);
+    console.error('[CodeGraph] Unhandled rejection:', reason);
+});
 function main() {
     const program = new commander_1.Command();
     // Version from package.json
@@ -109,9 +131,30 @@ function main() {
     // =============================================================================
     /**
      * Resolve project path from argument or current directory
+     * Walks up parent directories to find nearest initialized CodeGraph project
+     * (must have .codegraph/codegraph.db, not just .codegraph/lessons.db)
      */
     function resolveProjectPath(pathArg) {
-        return path.resolve(pathArg || process.cwd());
+        const absolutePath = path.resolve(pathArg || process.cwd());
+        // If exact path is initialized (has codegraph.db), use it
+        if (index_1.default.isInitialized(absolutePath)) {
+            return absolutePath;
+        }
+        // Walk up to find nearest parent with CodeGraph initialized
+        // Note: findNearestCodeGraphRoot finds any .codegraph folder, but we need one with codegraph.db
+        let current = absolutePath;
+        const root = path.parse(current).root;
+        while (current !== root) {
+            const parent = path.dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+            if (index_1.default.isInitialized(current)) {
+                return current;
+            }
+        }
+        // Not found - return original path (will fail later with helpful error)
+        return absolutePath;
     }
     /**
      * Format a number with commas
@@ -195,7 +238,6 @@ function main() {
         .command('init [path]')
         .description('Initialize CodeGraph in a project directory')
         .option('-i, --index', 'Run initial indexing after initialization')
-        .option('--no-hooks', 'Skip git hooks installation')
         .action(async (pathArg, options) => {
         const projectPath = resolveProjectPath(pathArg);
         console.log(chalk.bold('\nInitializing CodeGraph...\n'));
@@ -212,16 +254,6 @@ function main() {
             });
             success(`Initialized CodeGraph in ${projectPath}`);
             info(`Created .codegraph/ directory`);
-            // Install git hooks if requested (default: true)
-            if (options.hooks !== false && cg.isGitRepository()) {
-                const hookResult = cg.installGitHooks();
-                if (hookResult.success) {
-                    success('Installed git post-commit hook for auto-sync');
-                }
-                else {
-                    warn(`Could not install git hooks: ${hookResult.message}`);
-                }
-            }
             // Run initial index if requested
             if (options.index) {
                 console.log('\nIndexing project...\n');
@@ -245,10 +277,48 @@ function main() {
             cg.destroy();
         }
         catch (err) {
+            (0, sentry_1.captureException)(err);
             error(`Failed to initialize: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
     });
+    /**
+     * codegraph uninit [path]
+     */
+    program
+        .command('uninit [path]')
+        .description('Remove CodeGraph from a project (deletes .codegraph/ directory)')
+        .option('-f, --force', 'Skip confirmation prompt')
+        .action(async (pathArg, options) => {
+        const projectPath = resolveProjectPath(pathArg);
+        try {
+            if (!index_1.default.isInitialized(projectPath)) {
+                warn(`CodeGraph is not initialized in ${projectPath}`);
+                return;
+            }
+            if (!options.force) {
+                // Confirm with user
+                const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+                const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+                const answer = await new Promise((resolve) => {
+                    rl.question(chalk.yellow('⚠ This will permanently delete all CodeGraph data. Continue? (y/N) '), resolve);
+                });
+                rl.close();
+                if (answer.toLowerCase() !== 'y') {
+                    info('Cancelled');
+                    return;
+                }
+            }
+            const cg = index_1.default.openSync(projectPath);
+            cg.uninitialize();
+            success(`Removed CodeGraph from ${projectPath}`);
+        }
+        catch (err) {
+            (0, sentry_1.captureException)(err);
+            error(`Failed to uninitialize: ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+    });
     /**
      * codegraph index [path]
      */
@@ -305,6 +375,7 @@ function main() {
             cg.destroy();
         }
         catch (err) {
+            (0, sentry_1.captureException)(err);
             error(`Failed to index: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
@@ -355,6 +426,7 @@ function main() {
             cg.destroy();
         }
         catch (err) {
+            (0, sentry_1.captureException)(err);
             if (!options.quiet) {
                 error(`Failed to sync: ${err instanceof Error ? err.message : String(err)}`);
             }
@@ -367,10 +439,15 @@ function main() {
     program
         .command('status [path]')
         .description('Show index status and statistics')
-        .action(async (pathArg) => {
+        .option('-j, --json', 'Output as JSON')
+        .action(async (pathArg, options) => {
         const projectPath = resolveProjectPath(pathArg);
         try {
             if (!index_1.default.isInitialized(projectPath)) {
+                if (options.json) {
+                    console.log(JSON.stringify({ initialized: false, projectPath }));
+                    return;
+                }
                 console.log(chalk.bold('\nCodeGraph Status\n'));
                 info(`Project: ${projectPath}`);
                 warn('Not initialized');
@@ -380,6 +457,26 @@ function main() {
             const cg = await index_1.default.open(projectPath);
             const stats = cg.getStats();
             const changes = cg.getChangedFiles();
+            // JSON output mode
+            if (options.json) {
+                console.log(JSON.stringify({
+                    initialized: true,
+                    projectPath,
+                    fileCount: stats.fileCount,
+                    nodeCount: stats.nodeCount,
+                    edgeCount: stats.edgeCount,
+                    dbSizeBytes: stats.dbSizeBytes,
+                    nodesByKind: stats.nodesByKind,
+                    languages: Object.entries(stats.filesByLanguage).filter(([, count]) => count > 0).map(([lang]) => lang),
+                    pendingChanges: {
+                        added: changes.added.length,
+                        modified: changes.modified.length,
+                        removed: changes.removed.length,
+                    },
+                }));
+                cg.destroy();
+                return;
+            }
             console.log(chalk.bold('\nCodeGraph Status\n'));
             // Project info
             console.log(chalk.cyan('Project:'), projectPath);
@@ -428,20 +525,10 @@ function main() {
                 success('Index is up to date');
             }
             console.log();
-            // Git hooks status
-            if (cg.isGitRepository()) {
-                const hookInstalled = cg.isGitHookInstalled();
-                if (hookInstalled) {
-                    success('Git hooks: installed');
-                }
-                else {
-                    warn('Git hooks: not installed');
-                    info('Run "codegraph hooks install" to enable auto-sync');
-                }
-            }
             cg.destroy();
         }
         catch (err) {
+            (0, sentry_1.captureException)(err);
             error(`Failed to get status: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
@@ -496,54 +583,24 @@ function main() {
             cg.destroy();
         }
         catch (err) {
+            (0, sentry_1.captureException)(err);
             error(`Search failed: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
     });
     /**
-     * codegraph context <task>
+     * codegraph files [path]
      */
     program
-        .command('context <task>')
-        .description('Build context for a task (outputs markdown)')
-        .option('-p, --path <path>', 'Project path')
-        .option('-n, --max-nodes <number>', 'Maximum nodes to include', '50')
-        .option('-c, --max-code <number>', 'Maximum code blocks', '10')
-        .option('--no-code', 'Exclude code blocks')
-        .option('-f, --format <format>', 'Output format (markdown, json)', 'markdown')
-        .action(async (task, options) => {
-        const projectPath = resolveProjectPath(options.path);
-        try {
-            if (!index_1.default.isInitialized(projectPath)) {
-                error(`CodeGraph not initialized in ${projectPath}`);
-                process.exit(1);
-            }
-            const cg = await index_1.default.open(projectPath);
-            const context = await cg.buildContext(task, {
-                maxNodes: parseInt(options.maxNodes || '50', 10),
-                maxCodeBlocks: parseInt(options.maxCode || '10', 10),
-                includeCode: options.code !== false,
-                format: options.format,
-            });
-            // Output the context
-            console.log(context);
-            cg.destroy();
-        }
-        catch (err) {
-            error(`Failed to build context: ${err instanceof Error ? err.message : String(err)}`);
-            process.exit(1);
-        }
-    });
-    /**
-     * codegraph hooks <action>
-     */
-    const hooksCommand = program
-        .command('hooks')
-        .description('Manage git hooks');
-    hooksCommand
-        .command('install')
-        .description('Install git post-commit hook for auto-sync')
+        .command('files')
+        .description('Show project file structure from the index')
         .option('-p, --path <path>', 'Project path')
+        .option('--filter <dir>', 'Filter to files under this directory')
+        .option('--pattern <glob>', 'Filter files matching this glob pattern')
+        .option('--format <format>', 'Output format (tree, flat, grouped)', 'tree')
+        .option('--max-depth <number>', 'Maximum directory depth for tree format')
+        .option('--no-metadata', 'Hide file metadata (language, symbol count)')
+        .option('-j, --json', 'Output as JSON')
         .action(async (options) => {
         const projectPath = resolveProjectPath(options.path);
         try {
@@ -552,69 +609,165 @@ function main() {
                 process.exit(1);
             }
             const cg = await index_1.default.open(projectPath);
-            if (!cg.isGitRepository()) {
-                error('Not a git repository');
+            let files = cg.getFiles();
+            if (files.length === 0) {
+                info('No files indexed. Run "codegraph index" first.');
                 cg.destroy();
-                process.exit(1);
+                return;
             }
-            const result = cg.installGitHooks();
-            if (result.success) {
-                success(result.message);
-                if (result.previousHookBackedUp) {
-                    info('Previous hook backed up to post-commit.codegraph-backup');
-                }
+            // Filter by path prefix
+            if (options.filter) {
+                const filter = options.filter;
+                files = files.filter(f => f.path.startsWith(filter) || f.path.startsWith('./' + filter));
             }
-            else {
-                error(result.message);
-                process.exit(1);
-            }
-            cg.destroy();
-        }
-        catch (err) {
-            error(`Failed to install hooks: ${err instanceof Error ? err.message : String(err)}`);
-            process.exit(1);
-        }
-    });
-    hooksCommand
-        .command('remove')
-        .description('Remove git post-commit hook')
-        .option('-p, --path <path>', 'Project path')
-        .action(async (options) => {
-        const projectPath = resolveProjectPath(options.path);
-        try {
-            if (!index_1.default.isInitialized(projectPath)) {
-                error(`CodeGraph not initialized in ${projectPath}`);
-                process.exit(1);
+            // Filter by glob pattern
+            if (options.pattern) {
+                const regex = globToRegex(options.pattern);
+                files = files.filter(f => regex.test(f.path));
             }
-            const cg = await index_1.default.open(projectPath);
-            if (!cg.isGitRepository()) {
-                error('Not a git repository');
+            if (files.length === 0) {
+                info('No files found matching the criteria.');
                 cg.destroy();
-                process.exit(1);
+                return;
             }
-            const result = cg.removeGitHooks();
-            if (result.success) {
-                success(result.message);
-                if (result.restoredFromBackup) {
-                    info('Restored previous hook from backup');
-                }
+            // JSON output
+            if (options.json) {
+                const output = files.map(f => ({
+                    path: f.path,
+                    language: f.language,
+                    nodeCount: f.nodeCount,
+                    size: f.size,
+                }));
+                console.log(JSON.stringify(output, null, 2));
+                cg.destroy();
+                return;
             }
-            else {
-                error(result.message);
-                process.exit(1);
+            const includeMetadata = options.metadata !== false;
+            const format = options.format || 'tree';
+            const maxDepth = options.maxDepth ? parseInt(options.maxDepth, 10) : undefined;
+            // Format output
+            switch (format) {
+                case 'flat':
+                    console.log(chalk.bold(`\nFiles (${files.length}):\n`));
+                    for (const file of files.sort((a, b) => a.path.localeCompare(b.path))) {
+                        if (includeMetadata) {
+                            console.log(`  ${file.path} ${chalk.dim(`(${file.language}, ${file.nodeCount} symbols)`)}`);
+                        }
+                        else {
+                            console.log(`  ${file.path}`);
+                        }
+                    }
+                    break;
+                case 'grouped':
+                    console.log(chalk.bold(`\nFiles by Language (${files.length} total):\n`));
+                    const byLang = new Map();
+                    for (const file of files) {
+                        const existing = byLang.get(file.language) || [];
+                        existing.push(file);
+                        byLang.set(file.language, existing);
+                    }
+                    const sortedLangs = [...byLang.entries()].sort((a, b) => b[1].length - a[1].length);
+                    for (const [lang, langFiles] of sortedLangs) {
+                        console.log(chalk.cyan(`${lang} (${langFiles.length}):`));
+                        for (const file of langFiles.sort((a, b) => a.path.localeCompare(b.path))) {
+                            if (includeMetadata) {
+                                console.log(`  ${file.path} ${chalk.dim(`(${file.nodeCount} symbols)`)}`);
+                            }
+                            else {
+                                console.log(`  ${file.path}`);
+                            }
+                        }
+                        console.log();
+                    }
+                    break;
+                case 'tree':
+                default:
+                    console.log(chalk.bold(`\nProject Structure (${files.length} files):\n`));
+                    printFileTree(files, includeMetadata, maxDepth, chalk);
+                    break;
             }
+            console.log();
             cg.destroy();
         }
         catch (err) {
-            error(`Failed to remove hooks: ${err instanceof Error ? err.message : String(err)}`);
+            (0, sentry_1.captureException)(err);
+            error(`Failed to list files: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
     });
-    hooksCommand
-        .command('status')
-        .description('Check git hooks status')
+    /**
+     * Convert glob pattern to regex
+     */
+    function globToRegex(pattern) {
+        const escaped = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '{{GLOBSTAR}}')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\?/g, '[^/]')
+            .replace(/\{\{GLOBSTAR\}\}/g, '.*');
+        return new RegExp(escaped);
+    }
+    /**
+     * Print files as a tree
+     */
+    function printFileTree(files, includeMetadata, maxDepth, chalk) {
+        const root = { name: '', children: new Map() };
+        for (const file of files) {
+            const parts = file.path.split('/');
+            let current = root;
+            for (let i = 0; i < parts.length; i++) {
+                const part = parts[i];
+                if (!part)
+                    continue;
+                if (!current.children.has(part)) {
+                    current.children.set(part, { name: part, children: new Map() });
+                }
+                current = current.children.get(part);
+                if (i === parts.length - 1) {
+                    current.file = { language: file.language, nodeCount: file.nodeCount };
+                }
+            }
+        }
+        const renderNode = (node, prefix, isLast, depth) => {
+            if (maxDepth !== undefined && depth > maxDepth)
+                return;
+            const connector = isLast ? '└── ' : '├── ';
+            const childPrefix = isLast ? '    ' : '│   ';
+            if (node.name) {
+                let line = prefix + connector + node.name;
+                if (node.file && includeMetadata) {
+                    line += chalk.dim(` (${node.file.language}, ${node.file.nodeCount} symbols)`);
+                }
+                console.log(line);
+            }
+            const children = [...node.children.values()];
+            children.sort((a, b) => {
+                const aIsDir = a.children.size > 0 && !a.file;
+                const bIsDir = b.children.size > 0 && !b.file;
+                if (aIsDir !== bIsDir)
+                    return aIsDir ? -1 : 1;
+                return a.name.localeCompare(b.name);
+            });
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                const nextPrefix = node.name ? prefix + childPrefix : prefix;
+                renderNode(child, nextPrefix, i === children.length - 1, depth + 1);
+            }
+        };
+        renderNode(root, '', true, 0);
+    }
+    /**
+     * codegraph context <task>
+     */
+    program
+        .command('context <task>')
+        .description('Build context for a task (outputs markdown)')
         .option('-p, --path <path>', 'Project path')
-        .action(async (options) => {
+        .option('-n, --max-nodes <number>', 'Maximum nodes to include', '50')
+        .option('-c, --max-code <number>', 'Maximum code blocks', '10')
+        .option('--no-code', 'Exclude code blocks')
+        .option('-f, --format <format>', 'Output format (markdown, json)', 'markdown')
+        .action(async (task, options) => {
         const projectPath = resolveProjectPath(options.path);
         try {
             if (!index_1.default.isInitialized(projectPath)) {
@@ -622,22 +775,19 @@ function main() {
                 process.exit(1);
             }
             const cg = await index_1.default.open(projectPath);
-            if (!cg.isGitRepository()) {
-                info('Not a git repository');
-                cg.destroy();
-                return;
-            }
-            if (cg.isGitHookInstalled()) {
-                success('Git hook is installed');
-            }
-            else {
-                warn('Git hook is not installed');
-                info('Run "codegraph hooks install" to enable auto-sync');
-            }
+            const context = await cg.buildContext(task, {
+                maxNodes: parseInt(options.maxNodes || '50', 10),
+                maxCodeBlocks: parseInt(options.maxCode || '10', 10),
+                includeCode: options.code !== false,
+                format: options.format,
+            });
+            // Output the context
+            console.log(context);
             cg.destroy();
         }
         catch (err) {
-            error(`Failed to check hooks: ${err instanceof Error ? err.message : String(err)}`);
+            (0, sentry_1.captureException)(err);
+            error(`Failed to build context: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
     });
@@ -664,15 +814,15 @@ function main() {
                 console.log(chalk.bold('\nCodeGraph MCP Server\n'));
                 info('Use --mcp flag to start the MCP server');
                 console.log('\nTo use with Claude Code, add to your MCP configuration:');
-                console.log(chalk.dim(`
-{
-  "mcpServers": {
-    "codegraph": {
-      "command": "codegraph",
-      "args": ["serve", "--mcp"]
-    }
-  }
-}
+                console.log(chalk.dim(`
+{
+  "mcpServers": {
+    "codegraph": {
+      "command": "codegraph",
+      "args": ["serve", "--mcp"]
+    }
+  }
+}
 `));
                 console.log('Available tools:');
                 console.log(chalk.cyan('  codegraph_search') + '    - Search for code symbols');
@@ -681,14 +831,84 @@ function main() {
                 console.log(chalk.cyan('  codegraph_callees') + '   - Find what a symbol calls');
                 console.log(chalk.cyan('  codegraph_impact') + '    - Analyze impact of changes');
                 console.log(chalk.cyan('  codegraph_node') + '      - Get symbol details');
+                console.log(chalk.cyan('  codegraph_files') + '     - Get project file structure');
                 console.log(chalk.cyan('  codegraph_status') + '    - Get index status');
             }
         }
         catch (err) {
+            (0, sentry_1.captureException)(err);
             error(`Failed to start server: ${err instanceof Error ? err.message : String(err)}`);
             process.exit(1);
         }
     });
+    /**
+     * codegraph mark-dirty [path]
+     *
+     * Touches .codegraph/.dirty to signal that files have changed.
+     * Used by Claude Code PostToolUse hooks to batch syncs.
+     * Runs silently and always exits 0.
+     */
+    program
+        .command('mark-dirty [path]')
+        .description('Mark project as needing sync (used by Claude Code hooks)')
+        .action(async (pathArg) => {
+        try {
+            const startPath = path.resolve(pathArg || process.cwd());
+            const projectRoot = (0, index_1.findNearestCodeGraphRoot)(startPath);
+            if (!projectRoot) {
+                // No .codegraph/ found — exit silently
+                process.exit(0);
+            }
+            const dirtyPath = path.join((0, index_1.getCodeGraphDir)(projectRoot), '.dirty');
+            fs.writeFileSync(dirtyPath, Date.now().toString(), 'utf-8');
+        }
+        catch {
+            // Never fail — this runs in the background during edits
+        }
+        process.exit(0);
+    });
+    /**
+     * codegraph sync-if-dirty [path]
+     *
+     * Syncs the index only if .codegraph/.dirty exists.
+     * Removes the marker BEFORE syncing so edits during sync
+     * create a new marker for the next Stop event.
+     * Runs silently and always exits 0.
+     */
+    program
+        .command('sync-if-dirty [path]')
+        .description('Sync if project was marked dirty (used by Claude Code hooks)')
+        .action(async (pathArg) => {
+        try {
+            const startPath = path.resolve(pathArg || process.cwd());
+            const projectRoot = (0, index_1.findNearestCodeGraphRoot)(startPath);
+            if (!projectRoot) {
+                process.exit(0);
+            }
+            const dirtyPath = path.join((0, index_1.getCodeGraphDir)(projectRoot), '.dirty');
+            // No marker → nothing to do (sub-ms exit)
+            if (!fs.existsSync(dirtyPath)) {
+                process.exit(0);
+            }
+            // Remove marker FIRST so edits during sync create a new one
+            try {
+                fs.unlinkSync(dirtyPath);
+            }
+            catch { /* ignore */ }
+            // If not fully initialized (no DB), exit
+            if (!index_1.default.isInitialized(projectRoot)) {
+                process.exit(0);
+            }
+            // Run sync
+            const cg = await index_1.default.open(projectRoot);
+            await cg.sync();
+            cg.destroy();
+        }
+        catch {
+            // Never fail — this runs at the end of Claude responses
+        }
+        process.exit(0);
+    });
     /**
      * codegraph install
      */