devbrain-cli 0.1.0 → 0.2.0

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/node_modules/@devbrain/core/dist/analysis/analyzers/source-code.analyzer.d.ts

@@ -0,0 +1,24 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+import { Analyzer } from '../analyzer.interface.js';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+export interface SourceModule {
+    filePath: string;
+    name: string;
+    type: 'service' | 'controller' | 'route' | 'model' | 'other';
+    classes: string[];
+    functions: string[];
+    imports: string[];
+}
+export interface SourceApi {
+    method: string;
+    path: string;
+    file: string;
+}
+export declare class SourceCodeAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "source-code";
+    readonly name = "Source Code Structure Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/source-code.analyzer.js

@@ -0,0 +1,126 @@
+import { join, extname, basename } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+export class SourceCodeAnalyzer {
+    fsService;
+    id = 'source-code';
+    name = 'Source Code Structure Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        // Supports if there are any TS/JS source files in the project list
+        return project.files.some((f) => /\.(ts|js|tsx|jsx)$/.test(f) && !f.includes('node_modules') && !f.includes('dist'));
+    }
+    async analyze(project) {
+        const modules = [];
+        const apis = [];
+        const databaseEntities = new Set();
+        const authMethods = new Set();
+        const externalServices = new Set();
+        // Process only TS/JS source files up to a reasonable limit (e.g. 500 files for speed)
+        const sourceFiles = project.files
+            .filter((f) => /\.(ts|js|tsx|jsx)$/.test(f) && !f.includes('node_modules') && !f.includes('dist') && !f.endsWith('.test.ts') && !f.endsWith('.spec.ts'))
+            .slice(0, 500);
+        for (const file of sourceFiles) {
+            try {
+                const fullPath = join(project.cwd, file);
+                const content = await this.fsService.read(fullPath);
+                const baseName = basename(file);
+                const ext = extname(file);
+                const nameWithoutExt = baseName.slice(0, -ext.length);
+                // 1. Determine Module Type
+                let type = 'other';
+                if (/controller/i.test(nameWithoutExt))
+                    type = 'controller';
+                else if (/service/i.test(nameWithoutExt))
+                    type = 'service';
+                else if (/route/i.test(nameWithoutExt))
+                    type = 'route';
+                else if (/model/i.test(nameWithoutExt) || /entity/i.test(nameWithoutExt))
+                    type = 'model';
+                // 2. Classes
+                const classes = [];
+                const classRegex = /class\s+([A-Za-z0-9_]+)/g;
+                let match;
+                while ((match = classRegex.exec(content)) !== null) {
+                    classes.push(match[1]);
+                    if (type === 'model') {
+                        databaseEntities.add(match[1]);
+                    }
+                }
+                // 3. Functions
+                const functions = [];
+                const funcRegex = /(?:export\s+)?(?:async\s+)?function\s+([A-Za-z0-9_]+)/g;
+                while ((match = funcRegex.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+                const arrowFuncRegex = /(?:const|let|var)\s+([A-Za-z0-9_]+)\s*=\s*(?:async\s*)?\((?:[^)]*)\)\s*=>/g;
+                while ((match = arrowFuncRegex.exec(content)) !== null) {
+                    functions.push(match[1]);
+                }
+                // 4. Imports / External Services
+                const imports = [];
+                const importRegex = /(?:import|require)\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+                while ((match = importRegex.exec(content)) !== null) {
+                    const importSource = match[1];
+                    imports.push(importSource);
+                    // Detect external service integrations
+                    if (['axios', 'stripe', 'twilio', 'aws-sdk', 'redis', '@google-cloud/'].some(s => importSource.includes(s))) {
+                        externalServices.add(importSource);
+                    }
+                }
+                // 5. API Endpoints
+                // Match express-like router: router.get('/path', ...) or app.post('/path', ...)
+                const expressApiRegex = /(?:app|router|route|express)\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]/gi;
+                while ((match = expressApiRegex.exec(content)) !== null) {
+                    apis.push({
+                        method: match[1].toUpperCase(),
+                        path: match[2],
+                        file,
+                    });
+                }
+                // Match NestJS decorators: @Get('/path') or @Post()
+                const nestApiDecoratorRegex = /@(Get|Post|Put|Delete|Patch)\s*\(\s*(?:['"]([^'"]+)['"])?/g;
+                while ((match = nestApiDecoratorRegex.exec(content)) !== null) {
+                    apis.push({
+                        method: match[1].toUpperCase(),
+                        path: match[2] || '/',
+                        file,
+                    });
+                }
+                // 6. Authentication detection
+                if (/jwt|passport|bcrypt|oauth|session|authHeader|bearer/i.test(content)) {
+                    if (content.includes('jwt') || content.includes('JWT'))
+                        authMethods.add('JWT');
+                    if (content.includes('oauth') || content.includes('OAuth'))
+                        authMethods.add('OAuth');
+                    if (content.includes('session'))
+                        authMethods.add('Session-based');
+                }
+                modules.push({
+                    filePath: file,
+                    name: nameWithoutExt,
+                    type,
+                    classes,
+                    functions: functions.slice(0, 15), // cap function list
+                    imports,
+                });
+            }
+            catch {
+                // Skip unparseable files
+            }
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                modules,
+                apis: apis.slice(0, 100), // cap API endpoints
+                databaseEntities: Array.from(databaseEntities),
+                authMethods: Array.from(authMethods),
+                externalServices: Array.from(externalServices),
+            },
+        };
+    }
+}
+//# sourceMappingURL=source-code.analyzer.js.map

package/node_modules/@devbrain/core/dist/context/context.service.d.ts

@@ -1,17 +1,16 @@
+import { AggregatedAnalysis } from '@devbrain/shared';
 import { FilesystemService } from '../filesystem/filesystem.service.js';
-/**
- * Service responsible for reading generated project memory and consolidating it into an optimized AI prompt context.
- */
 export declare class ContextService {
     private readonly fsService;
     constructor(fsService?: FilesystemService);
     /**
-     * Reads memory markdown files, validates existence, and compiles them into a single token-efficient string.
+     * Generates and writes context.md to the target directory.
      */
-    buildContext(memoryDir: string): Promise<string>;
+    generateContext(analysis: AggregatedAnalysis, memoryDir: string): Promise<string>;
     /**
-     * Formats and converts absolute top-level headers (#) to sub-headers (##)
-     * to maintain a single root h1 structure and optimizes whitespaces.
+     * Reads project memory and compiles it into a single token-efficient string.
      */
+    buildContext(memoryDir: string): Promise<string>;
+    private buildContextString;
     private normalizeHeadings;
 }

package/node_modules/@devbrain/core/dist/context/context.service.js

@@ -1,18 +1,48 @@
-import { join } from 'node:path';
+import { join, dirname, basename } from 'node:path';
+import { CONTEXT_FILE_NAME, MEMORY_FILE_NAME, ValidationError, } from '@devbrain/shared';
 import { FilesystemService } from '../filesystem/filesystem.service.js';
-import { ValidationError } from '@devbrain/shared';
-/**
- * Service responsible for reading generated project memory and consolidating it into an optimized AI prompt context.
- */
 export class ContextService {
     fsService;
     constructor(fsService = new FilesystemService()) {
         this.fsService = fsService;
     }
     /**
-     * Reads memory markdown files, validates existence, and compiles them into a single token-efficient string.
+     * Generates and writes context.md to the target directory.
+     */
+    async generateContext(analysis, memoryDir) {
+        const targetDir = basename(memoryDir) === 'memory' ? dirname(memoryDir) : memoryDir;
+        const contextPath = join(targetDir, CONTEXT_FILE_NAME);
+        const contextContent = this.buildContextString(analysis);
+        const fileContent = [
+            '<!-- ⚠️ THIS FILE IS AUTO-GENERATED BY DEVBRAIN. -->',
+            '<!-- DO NOT EDIT. YOUR CHANGES WILL BE OVERWRITTEN. -->',
+            '',
+            contextContent,
+        ].join('\n');
+        await this.fsService.writeAtomic(contextPath, fileContent);
+        return contextContent;
+    }
+    /**
+     * Reads project memory and compiles it into a single token-efficient string.
      */
     async buildContext(memoryDir) {
+        const targetDir = basename(memoryDir) === 'memory' ? dirname(memoryDir) : memoryDir;
+        const jsonPath = join(targetDir, MEMORY_FILE_NAME);
+        // If memory.json exists, build context from it
+        if (await this.fsService.exists(jsonPath)) {
+            try {
+                const analysis = await this.fsService.readJson(jsonPath);
+                return this.buildContextString(analysis);
+            }
+            catch {
+                // Fall back to folder scanning if parsing fails
+            }
+        }
+        // Ensure memory folder exists if memory.json is not present (backward compatibility check)
+        if (!(await this.fsService.exists(memoryDir))) {
+            throw new ValidationError('Project memory directory not found.', `The directory ${memoryDir} does not exist.`, 'Run "devbrain learn" to scan the repository and populate the memory files first.');
+        }
+        // Fallback: Read individual .md files (v0.1 structure)
         const files = [
             'summary.md',
             'stack.md',
@@ -22,17 +52,13 @@ export class ContextService {
             'timeline.md',
         ];
         const parts = [];
-        // Ensure memory folder exists
-        if (!(await this.fsService.exists(memoryDir))) {
-            throw new ValidationError('Project memory directory not found.', `The directory ${memoryDir} does not exist.`, 'Run "devbrain learn" to scan the repository and populate the memory files first.');
-        }
         parts.push('<!-- START OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
         parts.push('# DEVBRAIN PROJECT CONTEXT INDEX');
         parts.push('');
         for (const file of files) {
             const filePath = join(memoryDir, file);
             if (!(await this.fsService.exists(filePath))) {
-                continue; // Skip missing files gracefully or use a warning comment
+                continue;
             }
             const content = await this.fsService.read(filePath);
             const formatted = this.normalizeHeadings(file, content);
@@ -42,17 +68,77 @@ export class ContextService {
         parts.push('<!-- END OF DEVBRAIN AI ASSISTANT CONTEXT SCHEMA -->');
         return parts.join('\n');
     }
-    /**
-     * Formats and converts absolute top-level headers (#) to sub-headers (##)
-     * to maintain a single root h1 structure and optimizes whitespaces.
-     */
+    buildContextString(analysis) {
+        const readmeData = analysis.analyzers.readme || {};
+        const packageJsonData = analysis.analyzers['package-json'] || {};
+        const tsconfigData = analysis.analyzers.tsconfig || {};
+        const gitData = analysis.analyzers.git || {};
+        const sourceCodeData = analysis.analyzers['source-code'] || {};
+        const projectName = analysis.projectName || packageJsonData.name || 'unnamed-project';
+        const overview = readmeData.description || 'No description available.';
+        const filesCount = analysis.files.length;
+        const keyFiles = analysis.files.filter((f) => f.includes('package.json') ||
+            f.includes('tsconfig.json') ||
+            f.includes('routes') ||
+            f.includes('controller') ||
+            f.includes('service') ||
+            f.includes('model') ||
+            f.includes('entity')).slice(0, 30);
+        const modules = (sourceCodeData.modules || [])
+            .map((m) => `- Module: \`${m.name}\` (Type: ${m.type}, File: \`${m.filePath}\`)\n  Classes: [${m.classes.join(', ')}]\n  Functions: [${m.functions.join(', ')}]`)
+            .join('\n');
+        const apis = (sourceCodeData.apis || [])
+            .map((a) => `- ${a.method} ${a.path}`)
+            .join('\n');
+        const dbs = (sourceCodeData.databaseEntities || []).map((d) => `- Model: ${d}`).join('\n');
+        const auths = (sourceCodeData.authMethods || []).map((a) => `- Auth: ${a}`).join('\n');
+        const externals = (sourceCodeData.externalServices || []).map((e) => `- Service: ${e}`).join('\n');
+        const commits = (gitData.recentCommits || [])
+            .slice(0, 3)
+            .map((c) => `- [${c.hash}] ${c.message}`)
+            .join('\n');
+        return [
+            '# DEVBRAIN AI CONTEXT',
+            '',
+            `## Project: ${projectName}`,
+            overview,
+            '',
+            `## Tech Stack & Language`,
+            `- Core Languages: ${analysis.technologies.join(', ') || 'None detected'}`,
+            `- Frameworks: ${analysis.frameworks.join(', ') || 'None detected'}`,
+            `- TS Compiler Target: ${tsconfigData.target || 'N/A'}`,
+            `- Strict Mode: ${tsconfigData.strict ? 'Enabled' : 'Disabled'}`,
+            '',
+            '## Project Architecture & Modules',
+            modules || '- No specific source code modules identified.',
+            '',
+            '## API Endpoints',
+            apis || '- No routes detected.',
+            '',
+            '## Database & Schemas',
+            dbs || '- No database models identified.',
+            '',
+            '## Authentication Systems',
+            auths || '- Default token/credentials handling.',
+            '',
+            '## Third-Party Integrations',
+            externals || '- No external API integrations.',
+            '',
+            `## Repository Structure (${filesCount} total files)`,
+            'Important files:',
+            keyFiles.map((kf) => `- \`${kf}\``).join('\n') || '- No critical files highlighted.',
+            '',
+            '## Recent Changes',
+            commits || '- No git commit log available.',
+            '',
+        ].join('\n');
+    }
     normalizeHeadings(fileName, content) {
         const sectionName = fileName.replace('.md', '').toUpperCase();
         const lines = content.split('\n');
         const processedLines = [`## SECTION: ${sectionName}`, ''];
         for (let line of lines) {
             line = line.trimEnd();
-            // Translate root header # to second-level ##
             if (line.startsWith('# ')) {
                 processedLines.push(`### ${line.substring(2)}`);
             }

package/node_modules/@devbrain/core/dist/engine/dependency.resolver.d.ts

@@ -0,0 +1,12 @@
+export declare class DependencyResolver {
+    private readonly coreConfigs;
+    /**
+     * Resolves the full list of files to analyze based on blast-radius rules.
+     */
+    resolveBlastRadius(changedFiles: string[], projectFiles: string[]): {
+        resolvedFiles: string[];
+        isFullScan: boolean;
+    };
+    private expandControllerBlastRadius;
+    private expandEntityBlastRadius;
+}

package/node_modules/@devbrain/core/dist/engine/dependency.resolver.js

@@ -0,0 +1,101 @@
+import { basename, extname } from 'node:path';
+export class DependencyResolver {
+    coreConfigs = new Set([
+        'package.json',
+        'tsconfig.json',
+        'docker-compose.yml',
+        '.env.example',
+        'schema.prisma',
+        'pom.xml',
+        'build.gradle',
+        '.gitignore',
+        '.eslintrc.json',
+        '.prettierrc',
+    ]);
+    /**
+     * Resolves the full list of files to analyze based on blast-radius rules.
+     */
+    resolveBlastRadius(changedFiles, projectFiles) {
+        // 1. Check for core configuration changes
+        for (const file of changedFiles) {
+            const name = basename(file);
+            if (this.coreConfigs.has(name) || name.startsWith('.env')) {
+                return { resolvedFiles: projectFiles, isFullScan: true };
+            }
+        }
+        const resolved = new Set();
+        for (const file of changedFiles) {
+            // Add the file itself
+            resolved.add(file);
+            const base = basename(file);
+            const ext = extname(file);
+            const nameWithoutExt = base.slice(0, -ext.length);
+            // Check if it's a source code file (JS, TS, Python, Go, Java, C#, PHP, Ruby, etc.)
+            const isSourceFile = /\.(ts|js|tsx|jsx|py|go|java|cs|php|rb)$/.test(ext);
+            if (!isSourceFile) {
+                continue;
+            }
+            // Check category: Controller
+            if (/controller/i.test(nameWithoutExt)) {
+                const prefix = nameWithoutExt.replace(/controller/i, '').toLowerCase();
+                if (prefix) {
+                    this.expandControllerBlastRadius(prefix, projectFiles, resolved);
+                }
+            }
+            // Check category: Entity / Model
+            else if (/entity/i.test(nameWithoutExt) ||
+                /model/i.test(nameWithoutExt) ||
+                file.includes('/entities/') ||
+                file.includes('/models/') ||
+                // A simple filename in a src/models or entities dir, or standard short names
+                /^[A-Z][a-zA-Z0-9]*$/.test(nameWithoutExt) // e.g. User.ts, Product.ts
+            ) {
+                // Extract prefix (e.g. UserEntity -> User, user.model -> user)
+                let prefix = nameWithoutExt
+                    .replace(/entity/i, '')
+                    .replace(/model/i, '')
+                    .toLowerCase();
+                // If it's a single word capitalized like User.ts, prefix is user
+                if (!prefix) {
+                    prefix = nameWithoutExt.toLowerCase();
+                }
+                this.expandEntityBlastRadius(prefix, projectFiles, resolved);
+            }
+        }
+        // Filter resolved files to ensure they exist in the current project files list
+        const projectFilesSet = new Set(projectFiles);
+        const finalFiles = Array.from(resolved).filter((f) => projectFilesSet.has(f));
+        return { resolvedFiles: finalFiles, isFullScan: false };
+    }
+    expandControllerBlastRadius(prefix, projectFiles, resolved) {
+        // Find related services and routes
+        for (const file of projectFiles) {
+            const base = basename(file).toLowerCase();
+            if (base.includes(prefix)) {
+                if (base.includes('service') || base.includes('route') || base.includes('controller')) {
+                    resolved.add(file);
+                }
+            }
+        }
+    }
+    expandEntityBlastRadius(prefix, projectFiles, resolved) {
+        // Find related repositories, DTOs, services, schemas
+        for (const file of projectFiles) {
+            const base = basename(file).toLowerCase();
+            if (base.includes(prefix)) {
+                if (base.includes('repository') ||
+                    base.includes('dto') ||
+                    base.includes('service') ||
+                    base.includes('entity') ||
+                    base.includes('model') ||
+                    base.includes('schema')) {
+                    resolved.add(file);
+                }
+            }
+            else if (base.includes('schema.prisma') || base.includes('schema.sql')) {
+                resolved.add(file);
+            }
+        }
+    }
+}
+//# sourceMappingURL=dependency.resolver.js.map

package/node_modules/@devbrain/core/dist/engine/history.manager.d.ts

@@ -0,0 +1,24 @@
+import { HistorySchema, CommitHistoryEntry } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class HistoryManager {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly historyPath;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Loads the current history or returns an empty default schema.
+     */
+    loadHistory(): Promise<HistorySchema>;
+    /**
+     * Persists the history schema.
+     */
+    saveHistory(history: HistorySchema): Promise<void>;
+    /**
+     * Adds an entry to commit history and updates lastProcessedCommit.
+     */
+    addCommitEntry(entry: CommitHistoryEntry): Promise<void>;
+    /**
+     * Gets the last processed commit hash.
+     */
+    getLastProcessedCommit(): Promise<string | null>;
+}

package/node_modules/@devbrain/core/dist/engine/history.manager.js

@@ -0,0 +1,64 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, HISTORY_FILE_NAME } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export class HistoryManager {
+    cwd;
+    fsService;
+    historyPath;
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.historyPath = join(cwd, DEVBRAIN_DIR_NAME, HISTORY_FILE_NAME);
+    }
+    /**
+     * Loads the current history or returns an empty default schema.
+     */
+    async loadHistory() {
+        try {
+            if (await this.fsService.exists(this.historyPath)) {
+                return await this.fsService.readJson(this.historyPath);
+            }
+        }
+        catch {
+            // Fall through to default if reading/parsing fails
+        }
+        return {
+            lastProcessedCommit: '',
+            commits: [],
+        };
+    }
+    /**
+     * Persists the history schema.
+     */
+    async saveHistory(history) {
+        await this.fsService.writeJson(this.historyPath, history);
+    }
+    /**
+     * Adds an entry to commit history and updates lastProcessedCommit.
+     */
+    async addCommitEntry(entry) {
+        const history = await this.loadHistory();
+        // Check if commit already processed to avoid duplicates
+        const index = history.commits.findIndex((c) => c.commitHash === entry.commitHash);
+        if (index !== -1) {
+            history.commits[index] = entry;
+        }
+        else {
+            history.commits.unshift(entry); // Prepend so new commits are first
+        }
+        history.lastProcessedCommit = entry.commitHash;
+        // Limit log entries to keep history.json reasonably sized (e.g. max 500 entries)
+        if (history.commits.length > 500) {
+            history.commits = history.commits.slice(0, 500);
+        }
+        await this.saveHistory(history);
+    }
+    /**
+     * Gets the last processed commit hash.
+     */
+    async getLastProcessedCommit() {
+        const history = await this.loadHistory();
+        return history.lastProcessedCommit || null;
+    }
+}
+//# sourceMappingURL=history.manager.js.map

package/node_modules/@devbrain/core/dist/engine/lock.manager.d.ts

@@ -0,0 +1,21 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class LockManager {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly lockPath;
+    private readonly staleTimeoutMs;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Attempts to acquire the lock. Returns true if acquired, false otherwise.
+     */
+    acquireLock(): Promise<boolean>;
+    /**
+     * Releases the lock by deleting the lock file.
+     */
+    releaseLock(): Promise<void>;
+    /**
+     * Checks if a lock currently exists and is active (not stale).
+     */
+    isLocked(): Promise<boolean>;
+    private checkIfStale;
+}