devbrain-cli 0.1.0 → 0.2.0

package/dist/bin.js

@@ -3,6 +3,9 @@ import { Command } from 'commander';
 import { InitCommand } from './commands/init.command.js';
 import { LearnCommand } from './commands/learn.command.js';
 import { ContextCommand } from './commands/context.command.js';
+import { StatusCommand } from './commands/status.command.js';
+import { HistoryCommand } from './commands/history.command.js';
+import { HookCommand } from './commands/hook.command.js';
 import { DEVBRAIN_VERSION } from '@devbrain/shared';
 const program = new Command();
 program
@@ -23,11 +26,17 @@ program
     .command('learn')
     .description('Scan repository files and update documentation memory deterministically')
     .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .option('-f, --force', 'Force a full scanned refresh of memory')
+    .option('--silent', 'Execute silently in the background')
     .option('--no-gitignore', 'Skip matching .gitignore exclude rules')
     .action(async (options) => {
     const cwd = process.cwd();
     const cmd = new LearnCommand();
-    await cmd.execute(cwd, !!options.debug, { respectGitignore: options.gitignore !== false });
+    await cmd.execute(cwd, !!options.debug, {
+        force: !!options.force,
+        silent: !!options.silent,
+        respectGitignore: options.gitignore !== false,
+    });
 });
 program
     .command('context')
@@ -39,6 +48,46 @@ program
     const cmd = new ContextCommand();
     await cmd.execute(cwd, !!options.debug, { raw: !!options.raw });
 });
+program
+    .command('status')
+    .description('Display autonomous Git integration status and repository statistics')
+    .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const cmd = new StatusCommand();
+    await cmd.execute(cwd, !!options.debug, {});
+});
+program
+    .command('history')
+    .description('Display commit history processing logs and version metrics')
+    .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const cmd = new HistoryCommand();
+    await cmd.execute(cwd, !!options.debug, {});
+});
+// Git Hook Subcommand group
+const hookGroup = program
+    .command('hook')
+    .description('Manage DevBrain autonomous Git integration hooks');
+hookGroup
+    .command('install')
+    .description('Install the post-commit git hook')
+    .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const cmd = new HookCommand();
+    await cmd.execute(cwd, !!options.debug, { action: 'install' });
+});
+hookGroup
+    .command('remove')
+    .description('Remove the post-commit git hook')
+    .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const cmd = new HookCommand();
+    await cmd.execute(cwd, !!options.debug, { action: 'remove' });
+});
 // Handle unknown commands
 program.on('command:*', () => {
     console.error('Invalid command: %s\nUse --help for a list of available commands.', program.args.join(' '));

package/dist/commands/history.command.d.ts

@@ -0,0 +1,10 @@
+import { CommandContext } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+export declare class HistoryCommand extends CommandPipeline {
+    private historyManager;
+    protected validate(context: CommandContext, _args: any): Promise<void>;
+    protected createContext(context: CommandContext, _args: any): Promise<void>;
+    protected executeService(context: CommandContext, _args: any): Promise<any>;
+    protected writeOutput(_context: CommandContext, _output: any, _args: any): Promise<void>;
+    protected reportResult(context: CommandContext, output: any, _args: any): Promise<void>;
+}

package/dist/commands/history.command.js

@@ -0,0 +1,66 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, VERSION_FILE_NAME } from '@devbrain/shared';
+import { HistoryManager } from '@devbrain/core';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+import chalk from 'chalk';
+export class HistoryCommand extends CommandPipeline {
+    historyManager;
+    async validate(context, _args) {
+        const configPath = join(context.cwd, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME);
+        if (!(await this.fsService.exists(configPath))) {
+            throw new Error('DevBrain is not initialized. Run "devbrain init" first.');
+        }
+    }
+    async createContext(context, _args) {
+        this.historyManager = new HistoryManager(context.cwd, this.fsService);
+    }
+    async executeService(context, _args) {
+        const history = await this.historyManager.loadHistory();
+        const versionPath = join(context.cwd, DEVBRAIN_DIR_NAME, VERSION_FILE_NAME);
+        let versionInfo = null;
+        if (await this.fsService.exists(versionPath)) {
+            try {
+                versionInfo = await this.fsService.readJson(versionPath);
+            }
+            catch {
+                // Ignore
+            }
+        }
+        return {
+            history,
+            versionInfo,
+        };
+    }
+    async writeOutput(_context, _output, _args) {
+        // No-op
+    }
+    async reportResult(context, output, _args) {
+        this.logger.header('DevBrain Commit Processing History');
+        const history = output.history;
+        console.log(`- Latest Processed Commit: ${chalk.yellow(history.lastProcessedCommit || 'none')}`);
+        console.log(`- Memory Schema Version: ${chalk.green(output.versionInfo?.version || '0.1.0')}`);
+        console.log(`- Total Commits Learned: ${chalk.cyan(history.commits.length)}`);
+        console.log('');
+        if (history.commits.length === 0) {
+            console.log(chalk.gray('No commit learning logs recorded. Run a commit or "devbrain learn" to populate history.'));
+            return;
+        }
+        console.log(chalk.bold('Learned Commits Log:'));
+        // Display up to 10 recent commits
+        const displayedCommits = history.commits.slice(0, 10);
+        for (const commit of displayedCommits) {
+            const hash = chalk.yellow(commit.commitHash);
+            const date = chalk.gray(new Date(commit.timestamp).toLocaleString());
+            const msg = commit.commitMessage.split('\n')[0];
+            const statusIcon = commit.status === 'success'
+                ? chalk.green('✔')
+                : commit.status === 'skipped' ? chalk.yellow('ℹ') : chalk.red('✖');
+            console.log(` ${statusIcon} ${hash} [${date}] - ${msg}`);
+        }
+        if (history.commits.length > 10) {
+            console.log(chalk.gray(`\n...and ${history.commits.length - 10} more older entries.`));
+        }
+        console.log('');
+    }
+}
+//# sourceMappingURL=history.command.js.map

package/dist/commands/hook.command.d.ts

@@ -0,0 +1,14 @@
+import { CommandContext } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+interface HookArgs {
+    action: 'install' | 'remove';
+}
+export declare class HookCommand extends CommandPipeline<HookArgs> {
+    private gitService;
+    protected validate(context: CommandContext, _args: HookArgs): Promise<void>;
+    protected createContext(context: CommandContext, _args: HookArgs): Promise<void>;
+    protected executeService(context: CommandContext, args: HookArgs): Promise<void>;
+    protected writeOutput(_context: CommandContext, _output: any, _args: HookArgs): Promise<void>;
+    protected reportResult(context: CommandContext, _output: any, args: HookArgs): Promise<void>;
+}
+export {};

package/dist/commands/hook.command.js

@@ -0,0 +1,40 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME } from '@devbrain/shared';
+import { GitService } from '@devbrain/core';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+export class HookCommand extends CommandPipeline {
+    gitService;
+    async validate(context, _args) {
+        const configPath = join(context.cwd, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME);
+        if (!(await this.fsService.exists(configPath))) {
+            throw new Error('DevBrain is not initialized. Run "devbrain init" first.');
+        }
+    }
+    async createContext(context, _args) {
+        this.gitService = new GitService(context.cwd, this.fsService);
+    }
+    async executeService(context, args) {
+        const isGit = await this.gitService.isGitRepository();
+        if (!isGit) {
+            throw new Error('This workspace is not a valid Git repository.');
+        }
+        if (args.action === 'install') {
+            await this.gitService.installHook('post-commit');
+        }
+        else if (args.action === 'remove') {
+            await this.gitService.removeHook('post-commit');
+        }
+    }
+    async writeOutput(_context, _output, _args) {
+        // No-op
+    }
+    async reportResult(context, _output, args) {
+        if (args.action === 'install') {
+            this.logger.success('Successfully installed post-commit hook for DevBrain.');
+        }
+        else {
+            this.logger.success('Successfully removed post-commit hook for DevBrain.');
+        }
+    }
+}
+//# sourceMappingURL=hook.command.js.map

package/dist/commands/init.command.d.ts

@@ -7,6 +7,7 @@ interface InitArgs {
  * Command pipeline for "devbrain init".
  */
 export declare class InitCommand extends CommandPipeline<InitArgs> {
+    private hookInstalled;
     protected validate(context: CommandContext, args: InitArgs): Promise<void>;
     protected createContext(context: CommandContext, _args: InitArgs): Promise<void>;
     protected executeService(context: CommandContext, _args: InitArgs): Promise<void>;

package/dist/commands/init.command.js

@@ -1,10 +1,12 @@
 import { join, basename } from 'node:path';
-import { ValidationError, DEVBRAIN_VERSION, DEFAULT_IGNORE_PATTERNS, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, DEFAULT_MEMORY_DIR, } from '@devbrain/shared';
+import { ValidationError, DEVBRAIN_VERSION, DEFAULT_IGNORE_PATTERNS, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, VERSION_FILE_NAME, CUSTOM_NOTES_FILE_NAME, DEFAULT_MEMORY_DIR, } from '@devbrain/shared';
+import { GitService } from '@devbrain/core';
 import { CommandPipeline } from '../pipeline/command.pipeline.js';
 /**
  * Command pipeline for "devbrain init".
  */
 export class InitCommand extends CommandPipeline {
+    hookInstalled = false;
     async validate(context, args) {
         const configPath = join(context.cwd, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME);
         if (!args.force && (await this.fsService.exists(configPath))) {
@@ -12,7 +14,6 @@ export class InitCommand extends CommandPipeline {
         }
     }
     async createContext(context, _args) {
-        // Setup default config parameters
         const projectName = basename(context.cwd);
         context.config = {
             version: DEVBRAIN_VERSION,
@@ -28,30 +29,65 @@ export class InitCommand extends CommandPipeline {
                 format: 'markdown',
                 directory: DEFAULT_MEMORY_DIR,
             },
+            auto_update: true,
+            enabled_hooks: ['post-commit'],
+            ignored_directories: [],
+            ignored_extensions: [],
+            maximum_incremental_files: 50,
+            documentation_generation: true,
+            context_generation: true,
+            verbose_logging: false,
+            safe_mode: true,
         };
     }
     async executeService(context, _args) {
         const devbrainPath = join(context.cwd, DEVBRAIN_DIR_NAME);
         const configPath = join(devbrainPath, CONFIG_FILE_NAME);
-        const memoryPath = join(context.cwd, context.config.memory.directory);
-        // Create directories
+        const versionPath = join(devbrainPath, VERSION_FILE_NAME);
+        const customNotesPath = join(devbrainPath, CUSTOM_NOTES_FILE_NAME);
+        // Create directories & write config
         await this.fsService.writeJson(configPath, context.config);
-        // Generate starter memory summary
-        const summaryPath = join(memoryPath, 'summary.md');
-        const initialSummary = [
-            `# Project Summary: ${context.config.project.name}`,
-            '',
-            '## Overview',
-            'This project has been initialized with DevBrain. Run "devbrain learn" to populate structured memory.',
-            '',
-        ].join('\n');
-        await this.fsService.write(summaryPath, initialSummary);
+        // Create version.json
+        const versionData = {
+            version: DEVBRAIN_VERSION,
+            memorySchema: 2,
+            lastMigration: new Date().toISOString().split('T')[0],
+        };
+        await this.fsService.writeJson(versionPath, versionData);
+        // Write starter custom_notes.md if not present
+        if (!(await this.fsService.exists(customNotesPath))) {
+            const defaultCustomNotes = [
+                '# Custom Developer Notes',
+                '',
+                'Use this file to document manual project conventions, architecture diagrams, decision logs, or any other notes.',
+                'This file will NEVER be overwritten by DevBrain.',
+                '',
+            ].join('\n');
+            await this.fsService.write(customNotesPath, defaultCustomNotes);
+        }
+        // Git Hook Integration
+        try {
+            const gitService = new GitService(context.cwd, this.fsService);
+            if (await gitService.isGitRepository()) {
+                await gitService.installHook('post-commit');
+                this.hookInstalled = true;
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Failed to configure Git hooks: ${err.message || err}`);
+        }
     }
     async writeOutput(_context, _output, _args) {
-        // No-op: files written in execution service
+        // No-op
     }
     async reportResult(context, _output, _args) {
         this.logger.success(`Initialized DevBrain project memory directory at ${join(context.cwd, DEVBRAIN_DIR_NAME)}`);
+        if (this.hookInstalled) {
+            this.logger.success('Automatically installed post-commit Git hook.');
+        }
+        else {
+            this.logger.warn('Git hooks not installed (directory is not a Git repository).');
+        }
     }
 }
 //# sourceMappingURL=init.command.js.map

package/dist/commands/learn.command.d.ts

@@ -1,17 +1,27 @@
 import { CommandContext } from '@devbrain/shared';
 import { CommandPipeline } from '../pipeline/command.pipeline.js';
 interface LearnArgs {
+    force?: boolean;
+    silent?: boolean;
     respectGitignore?: boolean;
 }
 /**
  * Command pipeline for "devbrain learn".
  */
 export declare class LearnCommand extends CommandPipeline<LearnArgs> {
-    private filesList;
+    private lockManager;
+    private loggerService;
+    private gitService;
+    private historyManager;
+    private memoryEngine;
+    private memoryService;
+    private contextService;
+    private stats;
     protected validate(context: CommandContext, _args: LearnArgs): Promise<void>;
-    protected createContext(context: CommandContext, args: LearnArgs): Promise<void>;
-    protected executeService(context: CommandContext, _args: LearnArgs): Promise<void>;
+    protected createContext(context: CommandContext, _args: LearnArgs): Promise<void>;
+    execute(cwd: string, debug: boolean, args: LearnArgs): Promise<void>;
+    protected executeService(context: CommandContext, args: LearnArgs): Promise<any>;
     protected writeOutput(_context: CommandContext, _output: any, _args: LearnArgs): Promise<void>;
-    protected reportResult(context: CommandContext, _output: any, _args: LearnArgs): Promise<void>;
+    protected reportResult(context: CommandContext, output: any, args: LearnArgs): Promise<void>;
 }
 export {};

package/dist/commands/learn.command.js

@@ -1,72 +1,177 @@
 import { join } from 'node:path';
 import { ValidationError, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, } from '@devbrain/shared';
-import { RepositoryScanner, AnalyzerRegistry, MemoryService, ReadmeAnalyzer, PackageJsonAnalyzer, TsconfigAnalyzer, GitAnalyzer, DockerfileAnalyzer, RequirementsTxtAnalyzer, PomXmlAnalyzer, BuildGradleAnalyzer, } from '@devbrain/core';
+import { GitService, LockManager, LoggerService, HistoryManager, DependencyResolver, MemoryEngine, MemoryService, ContextService, RepositoryScanner, } from '@devbrain/core';
 import { CommandPipeline } from '../pipeline/command.pipeline.js';
 import ora from 'ora';
 /**
  * Command pipeline for "devbrain learn".
  */
 export class LearnCommand extends CommandPipeline {
-    filesList = [];
+    lockManager;
+    loggerService;
+    gitService;
+    historyManager;
+    memoryEngine;
+    memoryService;
+    contextService;
+    stats = {
+        strategy: 'full',
+        filesCount: 0,
+        commitMessage: '',
+        commitHash: '',
+    };
     async validate(context, _args) {
         const configPath = join(context.cwd, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME);
         if (!(await this.fsService.exists(configPath))) {
             throw new ValidationError('DevBrain is not initialized in this repository.', 'Configuration file config.json not found.', 'Run "devbrain init" before executing "devbrain learn".');
         }
     }
-    async createContext(context, args) {
-        const spinner = ora('Scanning repository files...').start();
+    async createContext(context, _args) {
+        this.lockManager = new LockManager(context.cwd, this.fsService);
+        this.loggerService = new LoggerService(context.cwd, this.fsService);
+        this.gitService = new GitService(context.cwd, this.fsService);
+        this.historyManager = new HistoryManager(context.cwd, this.fsService);
+        this.memoryEngine = new MemoryEngine(context.cwd, context.config, this.fsService);
+        this.memoryService = new MemoryService(this.fsService);
+        this.contextService = new ContextService(this.fsService);
+    }
+    async execute(cwd, debug, args) {
+        // Override execute method to gracefully handle lock and hook errors without throwing
+        const isSilent = !!args.silent;
         try {
-            const scanner = new RepositoryScanner(this.fsService);
-            const respectGitignore = args.respectGitignore ?? context.config?.scanner.respectGitignore;
-            this.filesList = await scanner.scan(context.cwd, {
-                ignore: context.config?.scanner.ignore,
-                followSymlinks: context.config?.scanner.followSymlinks,
-                respectGitignore,
-            });
-            spinner.succeed(`Scanned repository: found ${this.filesList.length} files.`);
+            await super.execute(cwd, debug, args);
         }
         catch (error) {
-            spinner.fail('Scanning failed.');
-            throw error;
+            // Log errors in silent hook mode instead of exiting with 1
+            const logService = new LoggerService(cwd, this.fsService);
+            await logService.error(`Execution error: ${error.message || error}`, 'git-hook.log');
+            if (isSilent) {
+                console.error(`DevBrain Hook error logged: ${error.message || error}`);
+                process.exit(0); // Never interrupt Git commit!
+            }
+            else {
+                this.handleError(error, debug);
+                process.exit(1);
+            }
         }
     }
-    async executeService(context, _args) {
-        const spinner = ora('Analyzing code and generating memory files...').start();
+    async executeService(context, args) {
+        const isSilent = !!args.silent;
+        const forceFull = !!args.force;
+        // 1. Acquire Lock
+        const acquired = await this.lockManager.acquireLock();
+        if (!acquired) {
+            const msg = 'Another learning process is currently active or lock file exists.';
+            await this.loggerService.warn(msg, isSilent ? 'git-hook.log' : 'devbrain.log');
+            if (isSilent) {
+                return { skipped: true, reason: 'locked' };
+            }
+            throw new Error(msg + ' Ensure no other devbrain command is running, or remove .devbrain/.lock manually.');
+        }
+        const spinner = isSilent ? null : ora('DevBrain is updating project memory...').start();
         try {
-            // Setup registry with default analyzers
-            const registry = new AnalyzerRegistry();
-            registry.register(new ReadmeAnalyzer(this.fsService));
-            registry.register(new PackageJsonAnalyzer(this.fsService));
-            registry.register(new TsconfigAnalyzer(this.fsService));
-            registry.register(new GitAnalyzer(this.fsService));
-            registry.register(new DockerfileAnalyzer(this.fsService));
-            registry.register(new RequirementsTxtAnalyzer(this.fsService));
-            registry.register(new PomXmlAnalyzer(this.fsService));
-            registry.register(new BuildGradleAnalyzer(this.fsService));
-            const projectContext = {
-                cwd: context.cwd,
-                files: this.filesList,
-                config: context.config,
-            };
-            // Execute analyzers
-            const analysis = await registry.runAll(projectContext);
-            // Generate memory files
-            const memoryService = new MemoryService(this.fsService);
+            // 2. Fetch Git Metadata
+            const isGitRepo = await this.gitService.isGitRepository();
+            const lastCommit = isGitRepo ? await this.historyManager.getLastProcessedCommit() : null;
+            const currentCommit = isGitRepo ? await this.gitService.getCurrentCommitHash() : null;
+            if (currentCommit) {
+                this.stats.commitHash = currentCommit;
+                this.stats.commitMessage = await this.gitService.getCommitMessage(currentCommit);
+            }
+            // Check if memory.json exists
+            const memoryExists = await this.fsService.exists(join(context.cwd, DEVBRAIN_DIR_NAME, 'memory.json'));
+            let analysis;
+            // 3. Determine Incremental vs Full
+            if (forceFull || !isGitRepo || !lastCommit || !memoryExists) {
+                // Run Full Scan
+                this.stats.strategy = 'full';
+                if (spinner)
+                    spinner.text = 'Scanning entire project (full scan)...';
+                analysis = await this.memoryEngine.runFullScan();
+            }
+            else {
+                // Check if HEAD has actually changed
+                if (lastCommit === currentCommit) {
+                    if (spinner) {
+                        spinner.succeed('Project memory is already up to date with HEAD commit.');
+                    }
+                    await this.lockManager.releaseLock();
+                    return { skipped: true, reason: 'up-to-date' };
+                }
+                // Run Incremental Scan
+                this.stats.strategy = 'incremental';
+                if (spinner)
+                    spinner.text = 'Running incremental git-diff analysis...';
+                const changes = await this.gitService.getChangedFiles(lastCommit, currentCommit || 'HEAD');
+                // Scan directory files for context mapping
+                const scanner = new RepositoryScanner(this.fsService);
+                const allFiles = await scanner.scan(context.cwd, {
+                    ignore: context.config?.scanner.ignore,
+                    followSymlinks: context.config?.scanner.followSymlinks,
+                    respectGitignore: args.respectGitignore ?? context.config?.scanner.respectGitignore,
+                });
+                const allChanged = [
+                    ...changes.modified,
+                    ...changes.deleted,
+                    ...changes.renamed.map((r) => r.to),
+                    ...changes.renamed.map((r) => r.from),
+                ];
+                // Resolve blast radius dependencies
+                const resolver = new DependencyResolver();
+                const { resolvedFiles, isFullScan } = resolver.resolveBlastRadius(allChanged, allFiles);
+                if (isFullScan) {
+                    this.stats.strategy = 'full (config change)';
+                    if (spinner)
+                        spinner.text = 'Core config changed: scanning entire project...';
+                    analysis = await this.memoryEngine.runFullScan();
+                }
+                else {
+                    if (spinner)
+                        spinner.text = `Analyzing ${resolvedFiles.length} files in blast radius...`;
+                    analysis = await this.memoryEngine.incrementalLearn(resolvedFiles, changes.deleted, changes.renamed);
+                }
+            }
+            this.stats.filesCount = analysis.files.length;
+            // 4. Update documentation formats if enabled
             const memoryDir = join(context.cwd, context.config.memory.directory);
-            await memoryService.generateMemory(analysis, memoryDir);
-            spinner.succeed('Memory documentation generated successfully.');
+            if (context.config.documentation_generation !== false) {
+                if (spinner)
+                    spinner.text = 'Regenerating project memory documentation...';
+                await this.memoryService.generateMemory(analysis, memoryDir);
+            }
+            if (context.config.context_generation !== false) {
+                if (spinner)
+                    spinner.text = 'Regenerating AI context payload...';
+                await this.contextService.generateContext(analysis, memoryDir);
+            }
+            // 5. Append commit entry to history
+            if (isGitRepo && currentCommit) {
+                const historyEntry = {
+                    commitHash: currentCommit,
+                    timestamp: new Date().toISOString(),
+                    status: 'success',
+                    filesAnalyzed: this.stats.strategy.startsWith('full') ? ['*'] : [],
+                    commitMessage: this.stats.commitMessage,
+                };
+                await this.historyManager.addCommitEntry(historyEntry);
+            }
+            if (spinner) {
+                spinner.succeed(`Successfully learned changes (${this.stats.strategy} scan, ${this.stats.filesCount} files).`);
+            }
+            await this.loggerService.success(`Completed learning session: ${this.stats.strategy} scan.`, isSilent ? 'git-hook.log' : 'devbrain.log');
         }
-        catch (error) {
-            spinner.fail('Analysis execution failed.');
-            throw error;
+        finally {
+            // 6. Release Lock
+            await this.lockManager.releaseLock();
         }
     }
     async writeOutput(_context, _output, _args) {
-        // No-op: files written in execution service
+        // Handled in services
     }
-    async reportResult(context, _output, _args) {
-        this.logger.success(`Repository documentation written to ${join(context.cwd, context.config.memory.directory)}`);
+    async reportResult(context, output, args) {
+        if (args.silent || (output && output.skipped))
+            return;
+        this.logger.success(`Documentation and context regenerated at ${join(context.cwd, DEVBRAIN_DIR_NAME)}`);
     }
 }
 //# sourceMappingURL=learn.command.js.map

package/dist/commands/status.command.d.ts

@@ -0,0 +1,12 @@
+import { CommandContext } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+export declare class StatusCommand extends CommandPipeline {
+    private gitService;
+    private lockManager;
+    private historyManager;
+    protected validate(context: CommandContext, _args: any): Promise<void>;
+    protected createContext(context: CommandContext, _args: any): Promise<void>;
+    protected executeService(context: CommandContext, _args: any): Promise<any>;
+    protected writeOutput(_context: CommandContext, _output: any, _args: any): Promise<void>;
+    protected reportResult(context: CommandContext, status: any, _args: any): Promise<void>;
+}