devbrain-cli 0.2.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/filesystem/filesystem.service.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Service for safe filesystem operations.
+ */
+export declare class FilesystemService {
+    /**
+     * Check if a path exists.
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Reads contents of a file as a string.
+     */
+    read(path: string): Promise<string>;
+    /**
+     * Writes content to a file, creating directories recursively.
+     */
+    write(path: string, content: string): Promise<void>;
+    /**
+     * Atomically writes file content by writing to a temporary file then renaming.
+     */
+    writeAtomic(path: string, content: string): Promise<void>;
+    /**
+     * Reads and parses a JSON file.
+     */
+    readJson<T>(path: string): Promise<T>;
+    /**
+     * Writes JSON data to a file (optionally atomically).
+     */
+    writeJson(path: string, data: any, indent?: number): Promise<void>;
+}