devbrain-cli 0.2.0 → 0.3.0

package/README.md

@@ -1,26 +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).
+# 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/bin.js

@@ -6,6 +6,7 @@ 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 { SearchCommand } from './commands/search.command.js';
 import { DEVBRAIN_VERSION } from '@devbrain/shared';
 const program = new Command();
 program
@@ -29,6 +30,7 @@ program
     .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')
+    .option('--repair', 'Repair and rebuild vector index from scratch')
     .action(async (options) => {
     const cwd = process.cwd();
     const cmd = new LearnCommand();
@@ -36,17 +38,28 @@ program
         force: !!options.force,
         silent: !!options.silent,
         respectGitignore: options.gitignore !== false,
+        repair: !!options.repair,
     });
 });
 program
-    .command('context')
+    .command('context [query]')
     .description('Consolidate persistent documentation memory into an optimized prompt context')
     .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
     .option('-r, --raw', 'Omit debug and formatting statistics in output')
-    .action(async (options) => {
+    .action(async (query, options) => {
     const cwd = process.cwd();
     const cmd = new ContextCommand();
-    await cmd.execute(cwd, !!options.debug, { raw: !!options.raw });
+    await cmd.execute(cwd, !!options.debug, { raw: !!options.raw, query });
+});
+program
+    .command('search <query>')
+    .description('Semantically search repository memories for relevant information')
+    .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .option('--top <number>', 'Number of top results to return', (v) => parseInt(v, 10))
+    .action(async (query, options) => {
+    const cwd = process.cwd();
+    const cmd = new SearchCommand();
+    await cmd.execute(cwd, !!options.debug, { query, top: options.top });
 });
 program
     .command('status')

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

@@ -2,6 +2,7 @@ import { CommandContext } from '@devbrain/shared';
 import { CommandPipeline } from '../pipeline/command.pipeline.js';
 interface ContextArgs {
     raw?: boolean;
+    query?: string;
 }
 /**
  * Command pipeline for "devbrain context".
@@ -9,7 +10,7 @@ interface ContextArgs {
 export declare class ContextCommand extends CommandPipeline<ContextArgs> {
     protected validate(context: CommandContext, _args: ContextArgs): Promise<void>;
     protected createContext(_context: CommandContext, _args: ContextArgs): Promise<void>;
-    protected executeService(context: CommandContext, _args: ContextArgs): Promise<string>;
+    protected executeService(context: CommandContext, args: ContextArgs): Promise<string>;
     protected writeOutput(_context: CommandContext, output: string, _args: ContextArgs): Promise<void>;
     protected reportResult(_context: CommandContext, output: string, args: ContextArgs): Promise<void>;
 }

package/dist/commands/context.command.js

@@ -15,10 +15,48 @@ export class ContextCommand extends CommandPipeline {
     async createContext(_context, _args) {
         // No-op: context built from memory files
     }
-    async executeService(context, _args) {
-        const memoryDir = join(context.cwd, context.config.memory.directory);
-        const contextService = new ContextService(this.fsService);
-        return await contextService.buildContext(memoryDir);
+    async executeService(context, args) {
+        if (args.query) {
+            const dbPath = join(context.cwd, DEVBRAIN_DIR_NAME, 'vectors.db');
+            // Fallback if vectors.db doesn't exist yet
+            if (!(await this.fsService.exists(dbPath))) {
+                this.logger.warn('Vector store database not found. Returning full repository context. Run "devbrain learn" to initialize the vector database.');
+                const memoryDir = join(context.cwd, context.config.memory.directory);
+                const contextService = new ContextService(this.fsService);
+                return await contextService.buildContext(memoryDir);
+            }
+            // Initialize retriever components
+            const { SQLiteVectorStore, TransformersProvider, RankingEngine, SemanticRetriever, ContextBuilder } = await import('@devbrain/core');
+            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);
+                const contextBuilder = new ContextBuilder();
+                // Retrieve recent commits from history
+                let recentCommits = [];
+                try {
+                    const { HistoryManager } = await import('@devbrain/core');
+                    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 = context.config?.semanticSearch?.topK ?? 8;
+                const results = await retriever.searchRelevantMemories(args.query, topK, recentCommits);
+                return contextBuilder.buildContext(args.query, results);
+            }
+            finally {
+                vectorStore.close();
+            }
+        }
+        else {
+            const memoryDir = join(context.cwd, context.config.memory.directory);
+            const contextService = new ContextService(this.fsService);
+            return await contextService.buildContext(memoryDir);
+        }
     }
     async writeOutput(_context, output, _args) {
         // Output prompt directly to stdout so it can be piped or copied

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

@@ -4,6 +4,7 @@ interface LearnArgs {
     force?: boolean;
     silent?: boolean;
     respectGitignore?: boolean;
+    repair?: boolean;
 }
 /**
  * Command pipeline for "devbrain learn".
@@ -21,6 +22,8 @@ export declare class LearnCommand extends CommandPipeline<LearnArgs> {
     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>;
+    private synchronizeProjectMemory;
+    private synchronizeVectorIndex;
     protected writeOutput(_context: CommandContext, _output: any, _args: LearnArgs): Promise<void>;
     protected reportResult(context: CommandContext, output: any, args: LearnArgs): Promise<void>;
 }

package/dist/commands/learn.command.js

@@ -1,6 +1,7 @@
-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 { GitService, LockManager, LoggerService, HistoryManager, DependencyResolver, MemoryEngine, MemoryService, ContextService, RepositoryScanner, } 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';
 /**
@@ -57,7 +58,6 @@ export class LearnCommand extends CommandPipeline {
     }
     async executeService(context, args) {
         const isSilent = !!args.silent;
-        const forceFull = !!args.force;
         // 1. Acquire Lock
         const acquired = await this.lockManager.acquireLock();
         if (!acquired) {
@@ -78,32 +78,36 @@ export class LearnCommand extends CommandPipeline {
                 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'));
+            // 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;
-            // 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,
@@ -116,7 +120,6 @@ export class LearnCommand extends CommandPipeline {
                     ...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) {
@@ -132,7 +135,6 @@ export class LearnCommand extends CommandPipeline {
                 }
             }
             this.stats.filesCount = analysis.files.length;
-            // 4. Update documentation formats if enabled
             const memoryDir = join(context.cwd, context.config.memory.directory);
             if (context.config.documentation_generation !== false) {
                 if (spinner)
@@ -144,7 +146,6 @@ export class LearnCommand extends CommandPipeline {
                     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,
@@ -155,14 +156,130 @@ export class LearnCommand extends CommandPipeline {
                 };
                 await this.historyManager.addCommitEntry(historyEntry);
             }
+        }
+        else {
             if (spinner) {
-                spinner.succeed(`Successfully learned changes (${this.stats.strategy} scan, ${this.stats.filesCount} files).`);
+                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}`);
+                }
             }
-            await this.loggerService.success(`Completed learning session: ${this.stats.strategy} scan.`, isSilent ? 'git-hook.log' : 'devbrain.log');
         }
         finally {
-            // 6. Release Lock
-            await this.lockManager.releaseLock();
+            vectorStore.close();
         }
     }
     async writeOutput(_context, _output, _args) {

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/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 {};