devbrain-cli 0.1.0 → 0.2.0

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

@@ -0,0 +1,89 @@
+import { join } from 'node:path';
+import { unlink, stat } from 'node:fs/promises';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+import { DEVBRAIN_DIR_NAME, LOCK_FILE_NAME } from '@devbrain/shared';
+export class LockManager {
+    cwd;
+    fsService;
+    lockPath;
+    staleTimeoutMs = 10 * 60 * 1000; // 10 minutes
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.lockPath = join(cwd, DEVBRAIN_DIR_NAME, LOCK_FILE_NAME);
+    }
+    /**
+     * Attempts to acquire the lock. Returns true if acquired, false otherwise.
+     */
+    async acquireLock() {
+        try {
+            if (await this.fsService.exists(this.lockPath)) {
+                // Check if the lock is stale
+                const isStale = await this.checkIfStale();
+                if (isStale) {
+                    // Release the stale lock
+                    await this.releaseLock();
+                }
+                else {
+                    return false;
+                }
+            }
+            // Write current timestamp
+            const timestamp = Date.now().toString();
+            await this.fsService.writeAtomic(this.lockPath, timestamp);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Releases the lock by deleting the lock file.
+     */
+    async releaseLock() {
+        try {
+            if (await this.fsService.exists(this.lockPath)) {
+                await unlink(this.lockPath);
+            }
+        }
+        catch {
+            // Ignore errors during release
+        }
+    }
+    /**
+     * Checks if a lock currently exists and is active (not stale).
+     */
+    async isLocked() {
+        try {
+            if (await this.fsService.exists(this.lockPath)) {
+                const isStale = await this.checkIfStale();
+                return !isStale;
+            }
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    async checkIfStale() {
+        try {
+            const stats = await stat(this.lockPath);
+            const fileAgeMs = Date.now() - stats.mtimeMs;
+            if (fileAgeMs > this.staleTimeoutMs) {
+                return true;
+            }
+            // Or read timestamp from file content
+            const content = await this.fsService.read(this.lockPath);
+            const timestamp = parseInt(content.trim(), 10);
+            if (!isNaN(timestamp)) {
+                return Date.now() - timestamp > this.staleTimeoutMs;
+            }
+            return false;
+        }
+        catch {
+            // If we cannot check, assume it is stale to prevent locking out permanently
+            return true;
+        }
+    }
+}
+//# sourceMappingURL=lock.manager.js.map

package/node_modules/@devbrain/core/dist/engine/logger.service.d.ts

@@ -0,0 +1,16 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class LoggerService {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly logDir;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Log a message with a timestamp and log level to a specific file.
+     */
+    log(message: string, level?: string, fileName?: string): Promise<void>;
+    info(message: string, fileName?: string): Promise<void>;
+    success(message: string, fileName?: string): Promise<void>;
+    warn(message: string, fileName?: string): Promise<void>;
+    error(message: string, fileName?: string): Promise<void>;
+    debug(message: string, fileName?: string): Promise<void>;
+}

package/node_modules/@devbrain/core/dist/engine/logger.service.js

@@ -0,0 +1,49 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, LOGS_DIR_NAME } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export class LoggerService {
+    cwd;
+    fsService;
+    logDir;
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.logDir = join(cwd, DEVBRAIN_DIR_NAME, LOGS_DIR_NAME);
+    }
+    /**
+     * Log a message with a timestamp and log level to a specific file.
+     */
+    async log(message, level = 'INFO', fileName = 'devbrain.log') {
+        try {
+            const timestamp = new Date().toISOString();
+            const logLine = `[${timestamp}] [${level}] ${message}\n`;
+            const targetPath = join(this.logDir, fileName);
+            // Create logs directory if it does not exist
+            if (!(await this.fsService.exists(this.logDir))) {
+                const { mkdir } = await import('node:fs/promises');
+                await mkdir(this.logDir, { recursive: true });
+            }
+            const { appendFile } = await import('node:fs/promises');
+            await appendFile(targetPath, logLine, 'utf8');
+        }
+        catch {
+            // Fallback silently if logging fails to prevent interrupting operations
+        }
+    }
+    async info(message, fileName = 'devbrain.log') {
+        await this.log(message, 'INFO', fileName);
+    }
+    async success(message, fileName = 'devbrain.log') {
+        await this.log(message, 'SUCCESS', fileName);
+    }
+    async warn(message, fileName = 'devbrain.log') {
+        await this.log(message, 'WARN', fileName);
+    }
+    async error(message, fileName = 'devbrain.log') {
+        await this.log(message, 'ERROR', fileName);
+    }
+    async debug(message, fileName = 'devbrain.log') {
+        await this.log(message, 'DEBUG', fileName);
+    }
+}
+//# sourceMappingURL=logger.service.js.map

package/node_modules/@devbrain/core/dist/engine/memory.engine.d.ts

@@ -0,0 +1,30 @@
+import { AggregatedAnalysis, DevBrainConfig } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class MemoryEngine {
+    private readonly cwd;
+    private readonly config;
+    private readonly fsService;
+    private readonly memoryPath;
+    private readonly registry;
+    constructor(cwd: string, config: DevBrainConfig, fsService?: FilesystemService);
+    /**
+     * Loads memory.json or runs a full scan to create it.
+     */
+    loadMemory(): Promise<AggregatedAnalysis>;
+    /**
+     * Persists memory.json.
+     */
+    saveMemory(memory: AggregatedAnalysis): Promise<void>;
+    /**
+     * Run a full project scan.
+     */
+    runFullScan(): Promise<AggregatedAnalysis>;
+    /**
+     * Performs an incremental learning phase on modified/deleted/renamed files.
+     */
+    incrementalLearn(modifiedFiles: string[], deletedFiles: string[], renamedFiles: {
+        from: string;
+        to: string;
+    }[]): Promise<AggregatedAnalysis>;
+    private mergeIncrementalResults;
+}

package/node_modules/@devbrain/core/dist/engine/memory.engine.js

@@ -0,0 +1,200 @@
+import { join } from 'node:path';
+import { DEVBRAIN_DIR_NAME, MEMORY_FILE_NAME } from '@devbrain/shared';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+import { AnalyzerRegistry } from '../analysis/analyzer.registry.js';
+import { ReadmeAnalyzer } from '../analysis/analyzers/readme.analyzer.js';
+import { PackageJsonAnalyzer } from '../analysis/analyzers/package-json.analyzer.js';
+import { TsconfigAnalyzer } from '../analysis/analyzers/tsconfig.analyzer.js';
+import { GitAnalyzer } from '../analysis/analyzers/git.analyzer.js';
+import { DockerfileAnalyzer } from '../analysis/analyzers/docker.analyzer.js';
+import { RequirementsTxtAnalyzer } from '../analysis/analyzers/requirements-txt.analyzer.js';
+import { PomXmlAnalyzer } from '../analysis/analyzers/pom-xml.analyzer.js';
+import { BuildGradleAnalyzer } from '../analysis/analyzers/build-gradle.analyzer.js';
+import { SourceCodeAnalyzer } from '../analysis/analyzers/source-code.analyzer.js';
+import { RepositoryScanner } from '../analysis/scanner.js';
+export class MemoryEngine {
+    cwd;
+    config;
+    fsService;
+    memoryPath;
+    registry;
+    constructor(cwd, config, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.config = config;
+        this.fsService = fsService;
+        this.memoryPath = join(cwd, DEVBRAIN_DIR_NAME, MEMORY_FILE_NAME);
+        // Setup analyzer registry
+        this.registry = new AnalyzerRegistry();
+        this.registry.register(new ReadmeAnalyzer(this.fsService));
+        this.registry.register(new PackageJsonAnalyzer(this.fsService));
+        this.registry.register(new TsconfigAnalyzer(this.fsService));
+        this.registry.register(new GitAnalyzer(this.fsService));
+        this.registry.register(new DockerfileAnalyzer(this.fsService));
+        this.registry.register(new RequirementsTxtAnalyzer(this.fsService));
+        this.registry.register(new PomXmlAnalyzer(this.fsService));
+        this.registry.register(new BuildGradleAnalyzer(this.fsService));
+        this.registry.register(new SourceCodeAnalyzer(this.fsService));
+    }
+    /**
+     * Loads memory.json or runs a full scan to create it.
+     */
+    async loadMemory() {
+        try {
+            if (await this.fsService.exists(this.memoryPath)) {
+                return await this.fsService.readJson(this.memoryPath);
+            }
+        }
+        catch {
+            // Fall through to full scan if error
+        }
+        // Run full scan if no memory file
+        return await this.runFullScan();
+    }
+    /**
+     * Persists memory.json.
+     */
+    async saveMemory(memory) {
+        await this.fsService.writeJson(this.memoryPath, memory);
+    }
+    /**
+     * Run a full project scan.
+     */
+    async runFullScan() {
+        const scanner = new RepositoryScanner(this.fsService);
+        const files = await scanner.scan(this.cwd, {
+            ignore: this.config.scanner.ignore,
+            followSymlinks: this.config.scanner.followSymlinks,
+            respectGitignore: this.config.scanner.respectGitignore,
+        });
+        const projectContext = {
+            cwd: this.cwd,
+            files,
+            config: this.config,
+        };
+        const analysis = await this.registry.runAll(projectContext);
+        await this.saveMemory(analysis);
+        return analysis;
+    }
+    /**
+     * Performs an incremental learning phase on modified/deleted/renamed files.
+     */
+    async incrementalLearn(modifiedFiles, deletedFiles, renamedFiles) {
+        const memory = await this.loadMemory();
+        // 1. Process deletions
+        const deletedSet = new Set(deletedFiles);
+        for (const rename of renamedFiles) {
+            deletedSet.add(rename.from);
+        }
+        // Filter memory files list
+        memory.files = memory.files.filter((f) => !deletedSet.has(f));
+        // Handle source code file removal from modules cache
+        if (memory.analyzers['source-code']) {
+            const scData = memory.analyzers['source-code'];
+            if (scData.modules) {
+                scData.modules = scData.modules.filter((m) => !deletedSet.has(m.filePath));
+            }
+            if (scData.apis) {
+                scData.apis = scData.apis.filter((a) => !deletedSet.has(a.file));
+            }
+        }
+        // 2. Process renames (add the 'to' file)
+        for (const rename of renamedFiles) {
+            if (!memory.files.includes(rename.to)) {
+                memory.files.push(rename.to);
+            }
+        }
+        // 3. Process modifications and additions
+        const filesToAnalyze = [...modifiedFiles, ...renamedFiles.map((r) => r.to)];
+        // Add unique entries to files list
+        for (const file of filesToAnalyze) {
+            if (!memory.files.includes(file)) {
+                memory.files.push(file);
+            }
+        }
+        if (filesToAnalyze.length > 0) {
+            const projectContext = {
+                cwd: this.cwd,
+                files: filesToAnalyze,
+                config: this.config,
+            };
+            const incrementalAnalysis = await this.registry.runAll(projectContext);
+            // Merge incremental analysis results back to main memory
+            this.mergeIncrementalResults(memory, incrementalAnalysis, filesToAnalyze);
+        }
+        // Re-aggregate globals from updated source code modules
+        if (memory.analyzers['source-code']) {
+            const scData = memory.analyzers['source-code'];
+            const dbEntities = new Set();
+            const authMethods = new Set();
+            const extServices = new Set();
+            if (scData.modules) {
+                for (const mod of scData.modules) {
+                    if (mod.type === 'model' && mod.classes) {
+                        for (const c of mod.classes)
+                            dbEntities.add(c);
+                    }
+                    // Scan for Auth in name
+                    if (/auth|jwt|passport|login|session/i.test(mod.name)) {
+                        authMethods.add('Token/Credentials');
+                    }
+                    // imports
+                    if (mod.imports) {
+                        for (const imp of mod.imports) {
+                            if (['axios', 'stripe', 'twilio', 'aws-sdk', 'redis', '@google-cloud/'].some(s => imp.includes(s))) {
+                                extServices.add(imp);
+                            }
+                        }
+                    }
+                }
+            }
+            scData.databaseEntities = Array.from(dbEntities);
+            scData.authMethods = Array.from(authMethods);
+            scData.externalServices = Array.from(extServices);
+        }
+        await this.saveMemory(memory);
+        return memory;
+    }
+    mergeIncrementalResults(main, inc, analyzedFiles) {
+        // Merge core lists
+        main.technologies = Array.from(new Set([...main.technologies, ...inc.technologies]));
+        main.frameworks = Array.from(new Set([...main.frameworks, ...inc.frameworks]));
+        Object.assign(main.metadata, inc.metadata);
+        const analyzedSet = new Set(analyzedFiles);
+        // Merge analyzer blocks
+        for (const [id, incData] of Object.entries(inc.analyzers)) {
+            if (incData.error)
+                continue;
+            if (id === 'source-code') {
+                if (!main.analyzers['source-code']) {
+                    main.analyzers['source-code'] = { modules: [], apis: [] };
+                }
+                const mainSc = main.analyzers['source-code'];
+                // Remove existing items for analyzed files
+                if (mainSc.modules) {
+                    mainSc.modules = mainSc.modules.filter((m) => !analyzedSet.has(m.filePath));
+                }
+                else {
+                    mainSc.modules = [];
+                }
+                if (mainSc.apis) {
+                    mainSc.apis = mainSc.apis.filter((a) => !analyzedSet.has(a.file));
+                }
+                else {
+                    mainSc.apis = [];
+                }
+                // Add new items
+                if (incData.modules) {
+                    mainSc.modules.push(...incData.modules);
+                }
+                if (incData.apis) {
+                    mainSc.apis.push(...incData.apis);
+                }
+            }
+            else {
+                // Configuration files analyzers return repo-wide details, overwrite them
+                main.analyzers[id] = incData;
+            }
+        }
+    }
+}
+//# sourceMappingURL=memory.engine.js.map

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

@@ -0,0 +1,42 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class GitService {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly git;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Check if the directory is a valid git repository.
+     */
+    isGitRepository(): Promise<boolean>;
+    /**
+     * Retrieve the current HEAD commit hash.
+     */
+    getCurrentCommitHash(): Promise<string | null>;
+    /**
+     * Get the list of modified/added/deleted files between two commits.
+     */
+    getChangedFiles(sinceHash: string, toHash?: string): Promise<{
+        modified: string[];
+        deleted: string[];
+        renamed: {
+            from: string;
+            to: string;
+        }[];
+    }>;
+    /**
+     * Get the commit message of the specified commit hash.
+     */
+    getCommitMessage(hash: string): Promise<string>;
+    /**
+     * Install post-commit Git hook.
+     */
+    installHook(hookName?: string): Promise<void>;
+    /**
+     * Remove post-commit Git hook.
+     */
+    removeHook(hookName?: string): Promise<void>;
+    /**
+     * Check if hook is installed and managed by DevBrain.
+     */
+    isHookInstalled(hookName?: string): Promise<boolean>;
+}

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

@@ -0,0 +1,192 @@
+import { join } from 'node:path';
+import { chmod } from 'node:fs/promises';
+import { simpleGit } from 'simple-git';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export class GitService {
+    cwd;
+    fsService;
+    git;
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.git = simpleGit({ baseDir: cwd });
+    }
+    /**
+     * Check if the directory is a valid git repository.
+     */
+    async isGitRepository() {
+        try {
+            return await this.git.checkIsRepo();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Retrieve the current HEAD commit hash.
+     */
+    async getCurrentCommitHash() {
+        try {
+            const hash = await this.git.revparse(['HEAD']);
+            return hash.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get the list of modified/added/deleted files between two commits.
+     */
+    async getChangedFiles(sinceHash, toHash = 'HEAD') {
+        try {
+            // Get raw diff summary
+            const diffSummary = await this.git.diffSummary([sinceHash, toHash]);
+            const modified = [];
+            const deleted = [];
+            const renamed = [];
+            for (const file of diffSummary.files) {
+                // simple-git's diffSummary indicates file operations
+                if (file.file.includes(' => ')) {
+                    // File rename format: path/to/{old => new}/file or old => new
+                    const renameMatch = file.file.match(/^(.*?)\{(.*?) => (.*?)\}(.*)$/) ||
+                        file.file.match(/^(.*?) => (.*)$/);
+                    if (renameMatch) {
+                        let from = '';
+                        let to = '';
+                        if (renameMatch.length === 5) {
+                            const prefix = renameMatch[1];
+                            const oldPart = renameMatch[2];
+                            const newPart = renameMatch[3];
+                            const suffix = renameMatch[4];
+                            from = `${prefix}${oldPart}${suffix}`.replace('//', '/');
+                            to = `${prefix}${newPart}${suffix}`.replace('//', '/');
+                        }
+                        else {
+                            from = renameMatch[1].trim();
+                            to = renameMatch[2].trim();
+                        }
+                        renamed.push({ from, to });
+                    }
+                    else {
+                        // Fallback if regex mismatch
+                        modified.push(file.file);
+                    }
+                }
+                else {
+                    // Check if deleted
+                    // In git diff-tree or summary, we check if changes are deletions
+                    // diffSummary includes changes. We can verify if the file exists locally to confirm status.
+                    const exists = await this.fsService.exists(join(this.cwd, file.file));
+                    if (!exists) {
+                        deleted.push(file.file);
+                    }
+                    else {
+                        modified.push(file.file);
+                    }
+                }
+            }
+            return { modified, deleted, renamed };
+        }
+        catch {
+            return { modified: [], deleted: [], renamed: [] };
+        }
+    }
+    /**
+     * Get the commit message of the specified commit hash.
+     */
+    async getCommitMessage(hash) {
+        try {
+            const message = await this.git.show(['-s', '--format=%B', hash]);
+            return message.trim();
+        }
+        catch {
+            return 'No commit message';
+        }
+    }
+    /**
+     * Install post-commit Git hook.
+     */
+    async installHook(hookName = 'post-commit') {
+        const hooksDir = join(this.cwd, '.git', 'hooks');
+        if (!(await this.fsService.exists(hooksDir))) {
+            throw new Error('Not a Git repository or hooks directory is missing.');
+        }
+        const hookPath = join(hooksDir, hookName);
+        // Construct robust POSIX shell script template that executes async
+        const hookContent = [
+            '#!/bin/sh',
+            '# DevBrain Autonomous Git Memory Engine Hook',
+            '',
+            '# Set base path',
+            'PROJECT_DIR="$(pwd)"',
+            'LOG_FILE="$PROJECT_DIR/.devbrain/logs/git-hook.log"',
+            'LOCK_FILE="$PROJECT_DIR/.devbrain/.lock"',
+            '',
+            'mkdir -p "$PROJECT_DIR/.devbrain/logs"',
+            '',
+            '# Run in background to not block commit',
+            '(',
+            '  # Check lock file',
+            '  if [ -f "$LOCK_FILE" ]; then',
+            '    echo "$(date): Skip execution: Another DevBrain process is running." >> "$LOG_FILE"',
+            '    exit 0',
+            '  fi',
+            '',
+            '  echo "$(date): Triggering incremental learn..." >> "$LOG_FILE"',
+            '',
+            '  # Resolve and run devbrain',
+            '  if [ -f "$PROJECT_DIR/node_modules/.bin/devbrain" ]; then',
+            '    "$PROJECT_DIR/node_modules/.bin/devbrain" learn --silent >> "$LOG_FILE" 2>&1',
+            '  elif command -v devbrain >/dev/null 2>&1; then',
+            '    devbrain learn --silent >> "$LOG_FILE" 2>&1',
+            '  else',
+            '    npx --no-install devbrain learn --silent >> "$LOG_FILE" 2>&1',
+            '  fi',
+            '  ',
+            '  # Log result status code',
+            '  STATUS=$?',
+            '  if [ $STATUS -ne 0 ]; then',
+            '    echo "$(date): Error: DevBrain execution failed with code $STATUS" >> "$LOG_FILE"',
+            '  else',
+            '    echo "$(date): DevBrain learning updated successfully." >> "$LOG_FILE"',
+            '  fi',
+            ') >/dev/null 2>&1 &',
+            '',
+            'exit 0',
+        ].join('\n') + '\n';
+        await this.fsService.write(hookPath, hookContent);
+        // Make script executable
+        try {
+            await chmod(hookPath, 0o755);
+        }
+        catch {
+            // Mode modification might fail on Windows, fallback silently
+        }
+    }
+    /**
+     * Remove post-commit Git hook.
+     */
+    async removeHook(hookName = 'post-commit') {
+        const hookPath = join(this.cwd, '.git', 'hooks', hookName);
+        if (await this.fsService.exists(hookPath)) {
+            const content = await this.fsService.read(hookPath);
+            // Only delete if it's managed by DevBrain
+            if (content.includes('DevBrain Autonomous')) {
+                const { unlink } = await import('node:fs/promises');
+                await unlink(hookPath);
+            }
+        }
+    }
+    /**
+     * Check if hook is installed and managed by DevBrain.
+     */
+    async isHookInstalled(hookName = 'post-commit') {
+        const hookPath = join(this.cwd, '.git', 'hooks', hookName);
+        if (await this.fsService.exists(hookPath)) {
+            const content = await this.fsService.read(hookPath);
+            return content.includes('DevBrain Autonomous');
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=git.service.js.map

package/node_modules/@devbrain/core/dist/index.d.ts

@@ -4,6 +4,12 @@ export { Analyzer } from './analysis/analyzer.interface.js';
 export { AnalyzerRegistry } from './analysis/analyzer.registry.js';
 export { MemoryService } from './memory/memory.service.js';
 export { ContextService } from './context/context.service.js';
+export { GitService } from './git/git.service.js';
+export { LockManager } from './engine/lock.manager.js';
+export { LoggerService } from './engine/logger.service.js';
+export { HistoryManager } from './engine/history.manager.js';
+export { DependencyResolver } from './engine/dependency.resolver.js';
+export { MemoryEngine } from './engine/memory.engine.js';
 export { ReadmeAnalyzer } from './analysis/analyzers/readme.analyzer.js';
 export { PackageJsonAnalyzer } from './analysis/analyzers/package-json.analyzer.js';
 export { TsconfigAnalyzer } from './analysis/analyzers/tsconfig.analyzer.js';
@@ -12,3 +18,4 @@ export { DockerfileAnalyzer } from './analysis/analyzers/docker.analyzer.js';
 export { RequirementsTxtAnalyzer } from './analysis/analyzers/requirements-txt.analyzer.js';
 export { PomXmlAnalyzer } from './analysis/analyzers/pom-xml.analyzer.js';
 export { BuildGradleAnalyzer } from './analysis/analyzers/build-gradle.analyzer.js';
+export { SourceCodeAnalyzer } from './analysis/analyzers/source-code.analyzer.js';

package/node_modules/@devbrain/core/dist/index.js

@@ -4,6 +4,12 @@ export { RepositoryScanner } from './analysis/scanner.js';
 export { AnalyzerRegistry } from './analysis/analyzer.registry.js';
 export { MemoryService } from './memory/memory.service.js';
 export { ContextService } from './context/context.service.js';
+export { GitService } from './git/git.service.js';
+export { LockManager } from './engine/lock.manager.js';
+export { LoggerService } from './engine/logger.service.js';
+export { HistoryManager } from './engine/history.manager.js';
+export { DependencyResolver } from './engine/dependency.resolver.js';
+export { MemoryEngine } from './engine/memory.engine.js';
 // Concrete Analyzer exports
 export { ReadmeAnalyzer } from './analysis/analyzers/readme.analyzer.js';
 export { PackageJsonAnalyzer } from './analysis/analyzers/package-json.analyzer.js';
@@ -13,4 +19,5 @@ export { DockerfileAnalyzer } from './analysis/analyzers/docker.analyzer.js';
 export { RequirementsTxtAnalyzer } from './analysis/analyzers/requirements-txt.analyzer.js';
 export { PomXmlAnalyzer } from './analysis/analyzers/pom-xml.analyzer.js';
 export { BuildGradleAnalyzer } from './analysis/analyzers/build-gradle.analyzer.js';
+export { SourceCodeAnalyzer } from './analysis/analyzers/source-code.analyzer.js';
 //# sourceMappingURL=index.js.map

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

@@ -1,8 +1,5 @@
 import { AggregatedAnalysis } from '@devbrain/shared';
 import { FilesystemService } from '../filesystem/filesystem.service.js';
-/**
- * Service responsible for generating deterministic, human-readable markdown project documentation.
- */
 export declare class MemoryService {
     private readonly fsService;
     constructor(fsService?: FilesystemService);
@@ -10,6 +7,12 @@ export declare class MemoryService {
      * Generates memory markdown files and writes them to the specified directory.
      */
     generateMemory(analysis: AggregatedAnalysis, memoryDir: string): Promise<void>;
+    /**
+     * Section-based markdown writer to prevent redundant Git diffs.
+     */
+    private writeSectionBasedMarkdown;
+    private parseSections;
+    private buildProjectMemory;
     private buildSummary;
     private buildStack;
     private buildArchitecture;