devbrain-cli 0.1.0 → 0.3.0

package/dist/commands/learn.command.js

@@ -1,72 +1,294 @@
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
+import { unlink, readdir } from 'node:fs/promises';
 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, SQLiteVectorStore, TransformersProvider, VectorIndexer, } 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;
+        // 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);
+            }
+            const memoryExists = await this.fsService.exists(join(context.cwd, DEVBRAIN_DIR_NAME, 'memory.json'));
+            // Phase 1: Synchronize Project Memory
+            await this.synchronizeProjectMemory(context, args, spinner, isGitRepo, lastCommit, currentCommit, memoryExists);
+            // Phase 2: Synchronize Vector Index
+            await this.synchronizeVectorIndex(context, args, spinner);
+            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');
+        }
+        finally {
+            // 3. Release Lock
+            await this.lockManager.releaseLock();
+        }
+    }
+    async synchronizeProjectMemory(context, args, spinner, isGitRepo, lastCommit, currentCommit, memoryExists) {
+        const forceFull = !!args.force;
+        if (forceFull || !isGitRepo || !lastCommit || !memoryExists || lastCommit !== currentCommit) {
+            let analysis;
+            if (forceFull || !isGitRepo || !lastCommit || !memoryExists) {
+                this.stats.strategy = 'full';
+                if (spinner)
+                    spinner.text = 'Scanning entire project (full scan)...';
+                analysis = await this.memoryEngine.runFullScan();
+            }
+            else {
+                this.stats.strategy = 'incremental';
+                if (spinner)
+                    spinner.text = 'Running incremental git-diff analysis...';
+                const changes = await this.gitService.getChangedFiles(lastCommit, currentCommit || 'HEAD');
+                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),
+                ];
+                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;
             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);
+            }
+            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);
+            }
         }
-        catch (error) {
-            spinner.fail('Analysis execution failed.');
-            throw error;
+        else {
+            if (spinner) {
+                this.logger.debug('Git HEAD unchanged. Skipping project repository scan.');
+            }
+            this.stats.strategy = 'skipped';
+        }
+    }
+    async synchronizeVectorIndex(context, args, spinner) {
+        const isSilent = !!args.silent;
+        const dbPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'vectors.db');
+        const vectorsExist = await this.fsService.exists(dbPath);
+        if (args.repair || !vectorsExist) {
+            if (spinner) {
+                spinner.text = args.repair
+                    ? 'Repairing vector index (clearing existing)...'
+                    : 'Initializing new vector index...';
+            }
+            try {
+                if (await this.fsService.exists(dbPath)) {
+                    await unlink(dbPath);
+                }
+            }
+            catch { }
+        }
+        if (spinner)
+            spinner.text = 'Updating local vector index...';
+        const vectorStore = new SQLiteVectorStore(dbPath);
+        try {
+            const embeddingProvider = new TransformersProvider();
+            const indexer = new VectorIndexer(vectorStore, embeddingProvider);
+            const filesToIndex = new Set();
+            const projectMemoryPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'PROJECT_MEMORY.md');
+            if (await this.fsService.exists(projectMemoryPath)) {
+                filesToIndex.add(projectMemoryPath);
+            }
+            const customNotesPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'custom_notes.md');
+            if (await this.fsService.exists(customNotesPath)) {
+                filesToIndex.add(customNotesPath);
+            }
+            const memoryDir = join(context.cwd, context.config.memory.directory);
+            if (await this.fsService.exists(memoryDir)) {
+                try {
+                    const files = await readdir(memoryDir);
+                    for (const file of files) {
+                        if (file.endsWith('.md') || file.endsWith('.markdown')) {
+                            // Ignore noisy timeline / git logs
+                            if (file.toLowerCase().includes('timeline')) {
+                                continue;
+                            }
+                            filesToIndex.add(join(memoryDir, file));
+                        }
+                    }
+                }
+                catch { }
+            }
+            for (const filePath of filesToIndex) {
+                const memoryId = relative(join(context.cwd, DEVBRAIN_DIR_NAME), filePath).replace(/\\/g, '/');
+                await indexer.indexMemory(filePath, memoryId);
+            }
+        }
+        catch (err) {
+            if (!args.repair && vectorsExist) {
+                if (spinner)
+                    spinner.text = 'Corrupted index detected, performing automatic repair...';
+                try {
+                    vectorStore.close();
+                    if (await this.fsService.exists(dbPath)) {
+                        await unlink(dbPath);
+                    }
+                    const repairStore = new SQLiteVectorStore(dbPath);
+                    try {
+                        const embeddingProvider = new TransformersProvider();
+                        const indexer = new VectorIndexer(repairStore, embeddingProvider);
+                        const filesToIndex = new Set();
+                        const projectMemoryPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'PROJECT_MEMORY.md');
+                        if (await this.fsService.exists(projectMemoryPath)) {
+                            filesToIndex.add(projectMemoryPath);
+                        }
+                        const customNotesPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'custom_notes.md');
+                        if (await this.fsService.exists(customNotesPath)) {
+                            filesToIndex.add(customNotesPath);
+                        }
+                        const memoryDir = join(context.cwd, context.config.memory.directory);
+                        if (await this.fsService.exists(memoryDir)) {
+                            try {
+                                const files = await readdir(memoryDir);
+                                for (const file of files) {
+                                    if (file.endsWith('.md') || file.endsWith('.markdown')) {
+                                        // Ignore noisy timeline / git logs
+                                        if (file.toLowerCase().includes('timeline')) {
+                                            continue;
+                                        }
+                                        filesToIndex.add(join(memoryDir, file));
+                                    }
+                                }
+                            }
+                            catch { }
+                        }
+                        for (const filePath of filesToIndex) {
+                            const memoryId = relative(join(context.cwd, DEVBRAIN_DIR_NAME), filePath).replace(/\\/g, '/');
+                            await indexer.indexMemory(filePath, memoryId);
+                        }
+                    }
+                    finally {
+                        repairStore.close();
+                    }
+                }
+                catch (repairErr) {
+                    await this.loggerService.error(`Vector index automatic repair failed: ${repairErr.message || repairErr}`, isSilent ? 'git-hook.log' : 'devbrain.log');
+                    if (!isSilent) {
+                        this.logger.warn(`Vector index update failed: ${repairErr.message || repairErr}`);
+                    }
+                }
+            }
+            else {
+                await this.loggerService.error(`Vector index build error: ${err.message || err}`, isSilent ? 'git-hook.log' : 'devbrain.log');
+                if (!isSilent) {
+                    this.logger.warn(`Vector index update failed (graceful fallback): ${err.message || err}`);
+                }
+            }
+        }
+        finally {
+            vectorStore.close();
         }
     }
     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/search.command.d.ts

@@ -0,0 +1,14 @@
+import { CommandContext } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+interface SearchArgs {
+    query: string;
+    top?: number;
+}
+export declare class SearchCommand extends CommandPipeline<SearchArgs> {
+    protected validate(context: CommandContext, _args: SearchArgs): Promise<void>;
+    protected createContext(_context: CommandContext, _args: SearchArgs): Promise<void>;
+    protected executeService(context: CommandContext, args: SearchArgs): Promise<any[]>;
+    protected writeOutput(_context: CommandContext, output: any[], args: SearchArgs): Promise<void>;
+    protected reportResult(_context: CommandContext, output: any[], _args: SearchArgs): Promise<void>;
+}
+export {};

package/dist/commands/search.command.js

@@ -0,0 +1,90 @@
+import { join } from 'node:path';
+import { ValidationError, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, } from '@devbrain/shared';
+import { SQLiteVectorStore, TransformersProvider, RankingEngine, SemanticRetriever, HistoryManager } from '@devbrain/core';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+import chalk from 'chalk';
+export class SearchCommand extends CommandPipeline {
+    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.', 'Configuration file config.json not found.', 'Run "devbrain init" before executing "devbrain search".');
+        }
+    }
+    async createContext(_context, _args) {
+        // No-op
+    }
+    async executeService(context, args) {
+        const dbPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'vectors.db');
+        if (!(await this.fsService.exists(dbPath))) {
+            throw new ValidationError('Vector database not found.', 'No vectors.db file present in .devbrain.', 'Please run "devbrain learn" to scan your repository and initialize the vector store.');
+        }
+        const vectorStore = new SQLiteVectorStore(dbPath);
+        try {
+            const embeddingProvider = new TransformersProvider();
+            const rankingEngine = new RankingEngine(context.config);
+            const retriever = new SemanticRetriever(vectorStore, embeddingProvider, rankingEngine, context.config);
+            // Retrieve recent commits from history
+            let recentCommits = [];
+            try {
+                const historyManager = new HistoryManager(context.cwd, this.fsService);
+                const history = await historyManager.loadHistory();
+                if (history && history.commits) {
+                    recentCommits = history.commits.map(c => ({ hash: c.commitHash, message: c.commitMessage }));
+                }
+            }
+            catch { }
+            const topK = args.top ?? context.config?.semanticSearch?.topK ?? 8;
+            return await retriever.searchRelevantMemories(args.query, topK, recentCommits);
+        }
+        finally {
+            vectorStore.close();
+        }
+    }
+    async writeOutput(_context, output, args) {
+        console.log(chalk.bold(`\nDevBrain Semantic Search Results for: "${chalk.cyan(args.query)}"\n`));
+        if (output.length === 0) {
+            console.log(chalk.yellow('No matching memories found.'));
+            return;
+        }
+        for (let i = 0; i < output.length; i++) {
+            const match = output[i];
+            const chunk = match.chunk;
+            let meta = {};
+            try {
+                meta = JSON.parse(chunk.metadata);
+            }
+            catch { }
+            const similarity = meta.similarity !== undefined ? meta.similarity : 0.0;
+            let parentTitle = 'General';
+            if (match.parentSection) {
+                try {
+                    const parentMeta = JSON.parse(match.parentSection.metadata);
+                    parentTitle = parentMeta.title || 'General';
+                }
+                catch { }
+            }
+            else {
+                parentTitle = meta.sectionTitle || meta.title || 'General';
+            }
+            console.log(`${chalk.green(`[#${i + 1}]`)} ${chalk.bold(parentTitle)}`);
+            console.log(`  Similarity: ${similarity.toFixed(4)} (Score: ${match.score.toFixed(4)})`);
+            console.log(`  Type: ${chunk.level}`);
+            console.log(`  Source: ${chunk.memoryId}`);
+            if (chunk.level === 'bullet') {
+                console.log(`  Matched Concept: ${chalk.white(chunk.text)}`);
+            }
+            else {
+                const snippet = chunk.text.split('\n').slice(0, 3).map((l) => `    ${l}`).join('\n');
+                console.log(`  Matched Concept:\n${chalk.dim(snippet)}`);
+                if (chunk.text.split('\n').length > 3) {
+                    console.log(chalk.dim('    ...'));
+                }
+            }
+            console.log();
+        }
+    }
+    async reportResult(_context, output, _args) {
+        this.logger.debug(`Displayed ${output.length} semantic search matches.`);
+    }
+}
+//# sourceMappingURL=search.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>;
+}

package/dist/commands/status.command.js

@@ -0,0 +1,82 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, VERSION_FILE_NAME } from '@devbrain/shared';
+import { GitService, LockManager, HistoryManager } from '@devbrain/core';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+import chalk from 'chalk';
+export class StatusCommand extends CommandPipeline {
+    gitService;
+    lockManager;
+    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.gitService = new GitService(context.cwd, this.fsService);
+        this.lockManager = new LockManager(context.cwd, this.fsService);
+        this.historyManager = new HistoryManager(context.cwd, this.fsService);
+    }
+    async executeService(context, _args) {
+        const isGitRepo = await this.gitService.isGitRepository();
+        const isHookInstalled = isGitRepo ? await this.gitService.isHookInstalled('post-commit') : false;
+        const isLocked = await this.lockManager.isLocked();
+        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 {
+                // Fallback
+            }
+        }
+        const history = await this.historyManager.loadHistory();
+        const lastCommit = history.lastProcessedCommit || 'none';
+        // Count tracked files in memory.json
+        const memoryPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'memory.json');
+        let filesCount = 0;
+        if (await this.fsService.exists(memoryPath)) {
+            try {
+                const memoryData = await this.fsService.readJson(memoryPath);
+                filesCount = memoryData.files?.length || 0;
+            }
+            catch {
+                // Ignore
+            }
+        }
+        return {
+            isGitRepo,
+            isHookInstalled,
+            isLocked,
+            versionInfo,
+            lastCommit,
+            filesCount,
+            config: context.config,
+        };
+    }
+    async writeOutput(_context, _output, _args) {
+        // No-op
+    }
+    async reportResult(context, status, _args) {
+        this.logger.header('DevBrain Status Board');
+        console.log(`- Version: ${chalk.green(status.versionInfo?.version || '0.1.0')}`);
+        console.log(`- Memory Schema: ${chalk.cyan(status.versionInfo?.memorySchema || '1')}`);
+        console.log(`- Last Processed Commit: ${chalk.yellow(status.lastCommit)}`);
+        console.log(`- Files Tracked in Memory: ${chalk.blue(status.filesCount)}`);
+        console.log('');
+        console.log(chalk.bold('Integrations & Processes:'));
+        console.log(`- Git Repository: ${status.isGitRepo ? chalk.green('Yes') : chalk.red('No')}`);
+        console.log(`- Post-commit Git Hook Installed: ${status.isHookInstalled ? chalk.green('Yes') : chalk.yellow('No')}`);
+        console.log(`- Lock Active: ${status.isLocked ? chalk.red('Yes') : chalk.green('No (Idle)')}`);
+        console.log('');
+        console.log(chalk.bold('Configuration Parameters:'));
+        console.log(`- Auto Update: ${status.config.auto_update !== false ? chalk.green('Enabled') : chalk.yellow('Disabled')}`);
+        console.log(`- Documentation Gen: ${status.config.documentation_generation !== false ? chalk.green('Enabled') : chalk.yellow('Disabled')}`);
+        console.log(`- AI Context Gen: ${status.config.context_generation !== false ? chalk.green('Enabled') : chalk.yellow('Disabled')}`);
+        console.log(`- Safe Mode: ${status.config.safe_mode !== false ? chalk.green('Enabled') : chalk.yellow('Disabled')}`);
+        console.log('');
+    }
+}
+//# sourceMappingURL=status.command.js.map

package/dist/temp-prefix/devbrain

@@ -0,0 +1,16 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/node_modules/devbrain-cli/dist/bin.js" "$@"
+else 
+  exec node  "$basedir/node_modules/devbrain-cli/dist/bin.js" "$@"
+fi

package/dist/temp-prefix/devbrain.cmd

@@ -0,0 +1,17 @@
+@ECHO off
+GOTO start
+:find_dp0
+SET dp0=%~dp0
+EXIT /b
+:start
+SETLOCAL
+CALL :find_dp0
+
+IF EXIST "%dp0%\node.exe" (
+  SET "_prog=%dp0%\node.exe"
+) ELSE (
+  SET "_prog=node"
+  SET PATHEXT=%PATHEXT:;.JS;=;%
+)
+
+endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%"  "%dp0%\node_modules\devbrain-cli\dist\bin.js" %*

package/dist/temp-prefix/devbrain.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/node_modules/devbrain-cli/dist/bin.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/node_modules/devbrain-cli/dist/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/node_modules/devbrain-cli/dist/bin.js" $args
+  } else {
+    & "node$exe"  "$basedir/node_modules/devbrain-cli/dist/bin.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

package/dist/temp-prefix/node_modules/devbrain-cli/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DevBrain Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/temp-prefix/node_modules/devbrain-cli/README.md

@@ -0,0 +1,26 @@
+# devbrain
+
+DevBrain is an offline-first CLI tool designed to provide persistent, deterministic project memory for AI assistants.
+
+## Installation
+
+```bash
+npm install -g devbrain-cli
+```
+
+## Quick Start
+
+1. Initialize DevBrain in your project:
+   ```bash
+   devbrain init
+   ```
+2. Scan the repository and generate memory:
+   ```bash
+   devbrain learn
+   ```
+3. Generate LLM-ready consolidated context output:
+   ```bash
+   devbrain context
+   ```
+
+For detailed documentation, community guidelines, and license details, please visit the [DevBrain GitHub repository](https://github.com/CodeItAlone/devbrain#readme).

package/dist/temp-prefix/node_modules/devbrain-cli/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};