devbrain-cli 0.1.0

package/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/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/bin.d.ts

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

package/dist/bin.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { InitCommand } from './commands/init.command.js';
+import { LearnCommand } from './commands/learn.command.js';
+import { ContextCommand } from './commands/context.command.js';
+import { DEVBRAIN_VERSION } from '@devbrain/shared';
+const program = new Command();
+program
+    .name('devbrain')
+    .description('DevBrain CLI: Persistent project memory for AI-assisted software development')
+    .version(DEVBRAIN_VERSION);
+program
+    .command('init')
+    .description('Initialize DevBrain project memory in the current workspace')
+    .option('-f, --force', 'Force reinitialization and overwrite existing config')
+    .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const cmd = new InitCommand();
+    await cmd.execute(cwd, !!options.debug, { force: !!options.force });
+});
+program
+    .command('learn')
+    .description('Scan repository files and update documentation memory deterministically')
+    .option('-d, --debug', 'Enable verbose debug outputs and print stack traces')
+    .option('--no-gitignore', 'Skip matching .gitignore exclude rules')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    const cmd = new LearnCommand();
+    await cmd.execute(cwd, !!options.debug, { respectGitignore: options.gitignore !== false });
+});
+program
+    .command('context')
+    .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) => {
+    const cwd = process.cwd();
+    const cmd = new ContextCommand();
+    await cmd.execute(cwd, !!options.debug, { raw: !!options.raw });
+});
+// Handle unknown commands
+program.on('command:*', () => {
+    console.error('Invalid command: %s\nUse --help for a list of available commands.', program.args.join(' '));
+    process.exit(1);
+});
+program.parse(process.argv);
+//# sourceMappingURL=bin.js.map

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

@@ -0,0 +1,16 @@
+import { CommandContext } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+interface ContextArgs {
+    raw?: boolean;
+}
+/**
+ * Command pipeline for "devbrain context".
+ */
+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 writeOutput(_context: CommandContext, output: string, _args: ContextArgs): Promise<void>;
+    protected reportResult(_context: CommandContext, output: string, args: ContextArgs): Promise<void>;
+}
+export {};

package/dist/commands/context.command.js

@@ -0,0 +1,36 @@
+import { join } from 'node:path';
+import { ValidationError, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, } from '@devbrain/shared';
+import { ContextService } from '@devbrain/core';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+/**
+ * Command pipeline for "devbrain context".
+ */
+export class ContextCommand 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 context".');
+        }
+    }
+    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 writeOutput(_context, output, _args) {
+        // Output prompt directly to stdout so it can be piped or copied
+        console.log(output);
+    }
+    async reportResult(_context, output, args) {
+        if (!args.raw) {
+            const lineCount = output.split('\n').length;
+            const charCount = output.length;
+            const approximateTokens = Math.ceil(charCount / 4);
+            this.logger.debug(`Consolidated AI Context Details: ${lineCount} lines, ${charCount} chars, ~${approximateTokens} tokens.`);
+        }
+    }
+}
+//# sourceMappingURL=context.command.js.map

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

@@ -0,0 +1,16 @@
+import { CommandContext } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+interface InitArgs {
+    force?: boolean;
+}
+/**
+ * Command pipeline for "devbrain init".
+ */
+export declare class InitCommand extends CommandPipeline<InitArgs> {
+    protected validate(context: CommandContext, args: InitArgs): Promise<void>;
+    protected createContext(context: CommandContext, _args: InitArgs): Promise<void>;
+    protected executeService(context: CommandContext, _args: InitArgs): Promise<void>;
+    protected writeOutput(_context: CommandContext, _output: any, _args: InitArgs): Promise<void>;
+    protected reportResult(context: CommandContext, _output: any, _args: InitArgs): Promise<void>;
+}
+export {};

package/dist/commands/init.command.js

@@ -0,0 +1,57 @@
+import { join, basename } from 'node:path';
+import { ValidationError, DEVBRAIN_VERSION, DEFAULT_IGNORE_PATTERNS, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, DEFAULT_MEMORY_DIR, } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+/**
+ * Command pipeline for "devbrain init".
+ */
+export class InitCommand extends CommandPipeline {
+    async validate(context, args) {
+        const configPath = join(context.cwd, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME);
+        if (!args.force && (await this.fsService.exists(configPath))) {
+            throw new ValidationError('DevBrain project is already initialized in this repository.', `Found configuration file at ${configPath}.`, 'Use the "--force" flag to reinitialize and overwrite the config.');
+        }
+    }
+    async createContext(context, _args) {
+        // Setup default config parameters
+        const projectName = basename(context.cwd);
+        context.config = {
+            version: DEVBRAIN_VERSION,
+            project: {
+                name: projectName.replace(/[-_]/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+            },
+            scanner: {
+                ignore: DEFAULT_IGNORE_PATTERNS,
+                followSymlinks: false,
+                respectGitignore: true,
+            },
+            memory: {
+                format: 'markdown',
+                directory: DEFAULT_MEMORY_DIR,
+            },
+        };
+    }
+    async executeService(context, _args) {
+        const devbrainPath = join(context.cwd, DEVBRAIN_DIR_NAME);
+        const configPath = join(devbrainPath, CONFIG_FILE_NAME);
+        const memoryPath = join(context.cwd, context.config.memory.directory);
+        // Create directories
+        await this.fsService.writeJson(configPath, context.config);
+        // Generate starter memory summary
+        const summaryPath = join(memoryPath, 'summary.md');
+        const initialSummary = [
+            `# Project Summary: ${context.config.project.name}`,
+            '',
+            '## Overview',
+            'This project has been initialized with DevBrain. Run "devbrain learn" to populate structured memory.',
+            '',
+        ].join('\n');
+        await this.fsService.write(summaryPath, initialSummary);
+    }
+    async writeOutput(_context, _output, _args) {
+        // No-op: files written in execution service
+    }
+    async reportResult(context, _output, _args) {
+        this.logger.success(`Initialized DevBrain project memory directory at ${join(context.cwd, DEVBRAIN_DIR_NAME)}`);
+    }
+}
+//# sourceMappingURL=init.command.js.map

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

@@ -0,0 +1,17 @@
+import { CommandContext } from '@devbrain/shared';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+interface LearnArgs {
+    respectGitignore?: boolean;
+}
+/**
+ * Command pipeline for "devbrain learn".
+ */
+export declare class LearnCommand extends CommandPipeline<LearnArgs> {
+    private filesList;
+    protected validate(context: CommandContext, _args: LearnArgs): Promise<void>;
+    protected createContext(context: CommandContext, args: LearnArgs): Promise<void>;
+    protected executeService(context: CommandContext, _args: LearnArgs): Promise<void>;
+    protected writeOutput(_context: CommandContext, _output: any, _args: LearnArgs): Promise<void>;
+    protected reportResult(context: CommandContext, _output: any, _args: LearnArgs): Promise<void>;
+}
+export {};

package/dist/commands/learn.command.js

@@ -0,0 +1,72 @@
+import { join } from 'node:path';
+import { ValidationError, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME, } from '@devbrain/shared';
+import { RepositoryScanner, AnalyzerRegistry, MemoryService, ReadmeAnalyzer, PackageJsonAnalyzer, TsconfigAnalyzer, GitAnalyzer, DockerfileAnalyzer, RequirementsTxtAnalyzer, PomXmlAnalyzer, BuildGradleAnalyzer, } from '@devbrain/core';
+import { CommandPipeline } from '../pipeline/command.pipeline.js';
+import ora from 'ora';
+/**
+ * Command pipeline for "devbrain learn".
+ */
+export class LearnCommand extends CommandPipeline {
+    filesList = [];
+    async validate(context, _args) {
+        const configPath = join(context.cwd, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME);
+        if (!(await this.fsService.exists(configPath))) {
+            throw new ValidationError('DevBrain is not initialized in this repository.', 'Configuration file config.json not found.', 'Run "devbrain init" before executing "devbrain learn".');
+        }
+    }
+    async createContext(context, args) {
+        const spinner = ora('Scanning repository files...').start();
+        try {
+            const scanner = new RepositoryScanner(this.fsService);
+            const respectGitignore = args.respectGitignore ?? context.config?.scanner.respectGitignore;
+            this.filesList = await scanner.scan(context.cwd, {
+                ignore: context.config?.scanner.ignore,
+                followSymlinks: context.config?.scanner.followSymlinks,
+                respectGitignore,
+            });
+            spinner.succeed(`Scanned repository: found ${this.filesList.length} files.`);
+        }
+        catch (error) {
+            spinner.fail('Scanning failed.');
+            throw error;
+        }
+    }
+    async executeService(context, _args) {
+        const spinner = ora('Analyzing code and generating memory files...').start();
+        try {
+            // Setup registry with default analyzers
+            const registry = new AnalyzerRegistry();
+            registry.register(new ReadmeAnalyzer(this.fsService));
+            registry.register(new PackageJsonAnalyzer(this.fsService));
+            registry.register(new TsconfigAnalyzer(this.fsService));
+            registry.register(new GitAnalyzer(this.fsService));
+            registry.register(new DockerfileAnalyzer(this.fsService));
+            registry.register(new RequirementsTxtAnalyzer(this.fsService));
+            registry.register(new PomXmlAnalyzer(this.fsService));
+            registry.register(new BuildGradleAnalyzer(this.fsService));
+            const projectContext = {
+                cwd: context.cwd,
+                files: this.filesList,
+                config: context.config,
+            };
+            // Execute analyzers
+            const analysis = await registry.runAll(projectContext);
+            // Generate memory files
+            const memoryService = new MemoryService(this.fsService);
+            const memoryDir = join(context.cwd, context.config.memory.directory);
+            await memoryService.generateMemory(analysis, memoryDir);
+            spinner.succeed('Memory documentation generated successfully.');
+        }
+        catch (error) {
+            spinner.fail('Analysis execution failed.');
+            throw error;
+        }
+    }
+    async writeOutput(_context, _output, _args) {
+        // No-op: files written in execution service
+    }
+    async reportResult(context, _output, _args) {
+        this.logger.success(`Repository documentation written to ${join(context.cwd, context.config.memory.directory)}`);
+    }
+}
+//# sourceMappingURL=learn.command.js.map

package/dist/pipeline/command.pipeline.d.ts

@@ -0,0 +1,28 @@
+import { CommandContext, DevBrainConfig } from '@devbrain/shared';
+import { FilesystemService } from '@devbrain/core';
+import { Logger } from '../ui/logger.js';
+/**
+ * Standard Command Pipeline lifecycle.
+ * Order: Validate -> Load Configuration -> Create Context -> Execute Service -> Write Output -> Report Result.
+ */
+export declare abstract class CommandPipeline<TArgs = any> {
+    protected readonly fsService: FilesystemService;
+    protected logger: Logger;
+    /**
+     * Runs the complete command lifecycle with error trapping and performance boundaries.
+     */
+    execute(cwd: string, debug: boolean, args: TArgs): Promise<void>;
+    protected abstract validate(context: CommandContext, args: TArgs): Promise<void>;
+    /**
+     * Helper that reads the local config.json.
+     */
+    protected loadConfiguration(context: CommandContext): Promise<DevBrainConfig | undefined>;
+    protected abstract createContext(context: CommandContext, args: TArgs): Promise<void>;
+    protected abstract executeService(context: CommandContext, args: TArgs): Promise<any>;
+    protected abstract writeOutput(context: CommandContext, output: any, args: TArgs): Promise<void>;
+    protected abstract reportResult(context: CommandContext, output: any, args: TArgs): Promise<void>;
+    /**
+     * Safely formats and displays errors. Prints stack traces only if debug mode is active.
+     */
+    protected handleError(error: any, debug: boolean): void;
+}

package/dist/pipeline/command.pipeline.js

@@ -0,0 +1,65 @@
+import { FilesystemService } from '@devbrain/core';
+import { Logger } from '../ui/logger.js';
+import { join } from 'node:path';
+import { CONFIG_FILE_NAME, DEVBRAIN_DIR_NAME } from '@devbrain/shared';
+/**
+ * Standard Command Pipeline lifecycle.
+ * Order: Validate -> Load Configuration -> Create Context -> Execute Service -> Write Output -> Report Result.
+ */
+export class CommandPipeline {
+    fsService = new FilesystemService();
+    logger = new Logger();
+    /**
+     * Runs the complete command lifecycle with error trapping and performance boundaries.
+     */
+    async execute(cwd, debug, args) {
+        this.logger = new Logger(debug);
+        const context = { cwd, debug };
+        try {
+            this.logger.debug('1. Running validations...');
+            await this.validate(context, args);
+            this.logger.debug('2. Loading configuration...');
+            context.config = await this.loadConfiguration(context);
+            this.logger.debug('3. Establishing context parameters...');
+            await this.createContext(context, args);
+            this.logger.debug('4. Executing business services...');
+            const startTime = Date.now();
+            const output = await this.executeService(context, args);
+            const durationMs = Date.now() - startTime;
+            this.logger.debug(`Execution completed in ${durationMs}ms`);
+            this.logger.debug('5. Persisting command output...');
+            await this.writeOutput(context, output, args);
+            this.logger.debug('6. Writing user progress report...');
+            await this.reportResult(context, output, args);
+        }
+        catch (error) {
+            this.handleError(error, debug);
+            process.exit(1);
+        }
+    }
+    /**
+     * Helper that reads the local config.json.
+     */
+    async loadConfiguration(context) {
+        const configPath = join(context.cwd, DEVBRAIN_DIR_NAME, CONFIG_FILE_NAME);
+        if (await this.fsService.exists(configPath)) {
+            return await this.fsService.readJson(configPath);
+        }
+        return undefined;
+    }
+    /**
+     * Safely formats and displays errors. Prints stack traces only if debug mode is active.
+     */
+    handleError(error, debug) {
+        if (error.formatReport && typeof error.formatReport === 'function') {
+            this.logger.error(error.formatReport());
+        }
+        else {
+            this.logger.error(error.message || 'An unexpected internal error occurred.');
+        }
+        if (debug && error.stack) {
+            console.error('\n' + error.stack);
+        }
+    }
+}
+//# sourceMappingURL=command.pipeline.js.map

package/dist/ui/logger.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CLI coloring and logging utility.
+ */
+export declare class Logger {
+    private readonly isDebugEnabled;
+    constructor(isDebugEnabled?: boolean);
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+    header(title: string): void;
+}

package/dist/ui/logger.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+/**
+ * CLI coloring and logging utility.
+ */
+export class Logger {
+    isDebugEnabled;
+    constructor(isDebugEnabled = false) {
+        this.isDebugEnabled = isDebugEnabled;
+    }
+    info(message) {
+        console.log(chalk.blue('ℹ') + ' ' + message);
+    }
+    success(message) {
+        console.log(chalk.green('✔') + ' ' + chalk.bold(message));
+    }
+    warn(message) {
+        console.log(chalk.yellow('⚠') + ' ' + chalk.yellow(message));
+    }
+    error(message) {
+        console.error(chalk.red('✖') + ' ' + chalk.red.bold(message));
+    }
+    debug(message) {
+        if (this.isDebugEnabled) {
+            console.log(chalk.gray('[DEBUG]') + ' ' + message);
+        }
+    }
+    header(title) {
+        console.log('\n' + chalk.magenta.bold('=== ' + title + ' ===') + '\n');
+    }
+}
+//# sourceMappingURL=logger.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzer.interface.d.ts

@@ -0,0 +1,10 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+/**
+ * Interface definition for repository analyzers.
+ */
+export interface Analyzer {
+    readonly id: string;
+    readonly name: string;
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzer.interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=analyzer.interface.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzer.registry.d.ts

@@ -0,0 +1,20 @@
+import { ProjectContext, AggregatedAnalysis } from '@devbrain/shared';
+import { Analyzer } from './analyzer.interface.js';
+/**
+ * Registry for managing and executing repository analyzer plugins.
+ */
+export declare class AnalyzerRegistry {
+    private readonly analyzers;
+    /**
+     * Registers a new analyzer plugin.
+     */
+    register(analyzer: Analyzer): void;
+    /**
+     * Returns copy of registered analyzers.
+     */
+    getAnalyzers(): Analyzer[];
+    /**
+     * Runs all registered analyzers that support the current project context and aggregates their results.
+     */
+    runAll(project: ProjectContext): Promise<AggregatedAnalysis>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzer.registry.js

@@ -0,0 +1,67 @@
+/**
+ * Registry for managing and executing repository analyzer plugins.
+ */
+export class AnalyzerRegistry {
+    analyzers = [];
+    /**
+     * Registers a new analyzer plugin.
+     */
+    register(analyzer) {
+        // Avoid duplicate registration
+        if (!this.analyzers.some((a) => a.id === analyzer.id)) {
+            this.analyzers.push(analyzer);
+        }
+    }
+    /**
+     * Returns copy of registered analyzers.
+     */
+    getAnalyzers() {
+        return [...this.analyzers];
+    }
+    /**
+     * Runs all registered analyzers that support the current project context and aggregates their results.
+     */
+    async runAll(project) {
+        const activeAnalyzersData = {};
+        const technologies = new Set();
+        const frameworks = new Set();
+        const metadata = {};
+        for (const analyzer of this.analyzers) {
+            try {
+                const isSupported = await analyzer.supports(project);
+                if (isSupported) {
+                    const result = await analyzer.analyze(project);
+                    activeAnalyzersData[analyzer.id] = result.data;
+                    // Pull dynamic attributes from analyzer output
+                    if (result.data.technologies && Array.isArray(result.data.technologies)) {
+                        for (const tech of result.data.technologies) {
+                            technologies.add(tech);
+                        }
+                    }
+                    if (result.data.frameworks && Array.isArray(result.data.frameworks)) {
+                        for (const fw of result.data.frameworks) {
+                            frameworks.add(fw);
+                        }
+                    }
+                    if (result.data.metadata && typeof result.data.metadata === 'object') {
+                        Object.assign(metadata, result.data.metadata);
+                    }
+                }
+            }
+            catch (error) {
+                activeAnalyzersData[analyzer.id] = {
+                    error: error.message || 'Analyzer failed during execution',
+                };
+            }
+        }
+        return {
+            projectName: project.config.project.name,
+            technologies: Array.from(technologies),
+            frameworks: Array.from(frameworks),
+            metadata,
+            files: project.files,
+            analyzers: activeAnalyzersData,
+        };
+    }
+}
+//# sourceMappingURL=analyzer.registry.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzers/build-gradle.analyzer.d.ts

@@ -0,0 +1,14 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+import { Analyzer } from '../analyzer.interface.js';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for Gradle build.gradle configuration files.
+ */
+export declare class BuildGradleAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "build-gradle";
+    readonly name = "Gradle Build Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/build-gradle.analyzer.js

@@ -0,0 +1,53 @@
+import { join } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for Gradle build.gradle configuration files.
+ */
+export class BuildGradleAnalyzer {
+    fsService;
+    id = 'build-gradle';
+    name = 'Gradle Build Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f === 'build.gradle' || f === 'build.gradle.kts');
+    }
+    async analyze(project) {
+        const file = project.files.find((f) => f === 'build.gradle' || f === 'build.gradle.kts');
+        const path = join(project.cwd, file);
+        const content = await this.fsService.read(path);
+        const dependencies = [];
+        const frameworks = [];
+        // Extract dependencies using simple regex matches (e.g. implementation 'group:name:version' or implementation("group:name:version"))
+        const depRegex = /(?:implementation|api|compileOnly|runtimeOnly)\s*\(?\s*['"]([^'"]+)['"]\s*\)?/g;
+        let match;
+        while ((match = depRegex.exec(content)) !== null) {
+            const depString = match[1];
+            dependencies.push(depString);
+            if (depString.includes('spring-boot') || depString.includes('springboot')) {
+                frameworks.push('Spring Boot');
+            }
+        }
+        const groupMatch = content.match(/group\s*=\s*['"]([^'"]+)['"]/);
+        const group = groupMatch ? groupMatch[1] : 'unknown';
+        const versionMatch = content.match(/version\s*=\s*['"]([^'"]+)['"]/);
+        const version = versionMatch ? versionMatch[1] : 'unknown';
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                group,
+                version,
+                dependencies,
+                frameworks,
+                technologies: ['Java', 'Gradle'],
+                metadata: {
+                    projectLanguage: 'Java',
+                    projectFramework: frameworks[0] || 'Java Gradle base',
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=build-gradle.analyzer.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzers/docker.analyzer.d.ts

@@ -0,0 +1,14 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+import { Analyzer } from '../analyzer.interface.js';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for Dockerfile.
+ */
+export declare class DockerfileAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "dockerfile";
+    readonly name = "Dockerfile Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}