devbrain-cli 0.1.0

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

@@ -0,0 +1,38 @@
+import { join } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for Dockerfile.
+ */
+export class DockerfileAnalyzer {
+    fsService;
+    id = 'dockerfile';
+    name = 'Dockerfile Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f === 'Dockerfile' || f.endsWith('.dockerfile'));
+    }
+    async analyze(project) {
+        const dockerfile = project.files.find((f) => f === 'Dockerfile' || f.endsWith('.dockerfile'));
+        const path = join(project.cwd, dockerfile);
+        const content = await this.fsService.read(path);
+        const fromMatch = content.match(/^FROM\s+(.+)$/im);
+        const baseImage = fromMatch ? fromMatch[1].trim() : 'unknown';
+        const ports = [];
+        const portMatches = content.matchAll(/^EXPOSE\s+(.+)$/gim);
+        for (const match of portMatches) {
+            ports.push(...match[1].trim().split(/\s+/));
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                baseImage,
+                exposedPorts: ports,
+                technologies: ['Docker'],
+            },
+        };
+    }
+}
+//# sourceMappingURL=docker.analyzer.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzers/git.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 Git repository metrics.
+ */
+export declare class GitAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "git";
+    readonly name = "Git Repository Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/git.analyzer.js

@@ -0,0 +1,54 @@
+import { join } from 'node:path';
+import { simpleGit } from 'simple-git';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for Git repository metrics.
+ */
+export class GitAnalyzer {
+    fsService;
+    id = 'git';
+    name = 'Git Repository Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        // Check if .git directory/metadata exists
+        const gitHeadPath = join(project.cwd, '.git/HEAD');
+        return await this.fsService.exists(gitHeadPath);
+    }
+    async analyze(project) {
+        const git = simpleGit({ baseDir: project.cwd });
+        let branch = 'unknown';
+        let commits = [];
+        let remotes = [];
+        try {
+            const status = await git.status();
+            branch = status.current || 'unknown';
+            const log = await git.log({ maxCount: 5 });
+            commits = log.all.map((c) => ({
+                hash: c.hash.substring(0, 7),
+                date: c.date,
+                message: c.message,
+                author: c.author_name,
+            }));
+            const rawRemotes = await git.getRemotes(true);
+            remotes = rawRemotes.map((r) => ({
+                name: r.name,
+                refs: r.refs,
+            }));
+        }
+        catch {
+            // Graceful fallback if git commands fail
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                branch,
+                recentCommits: commits,
+                remotes,
+            },
+        };
+    }
+}
+//# sourceMappingURL=git.analyzer.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzers/package-json.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 package.json files.
+ */
+export declare class PackageJsonAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "package-json";
+    readonly name = "package.json Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

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

@@ -0,0 +1,72 @@
+import { join } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for package.json files.
+ */
+export class PackageJsonAnalyzer {
+    fsService;
+    id = 'package-json';
+    name = 'package.json Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f === 'package.json');
+    }
+    async analyze(project) {
+        const packageJsonFile = project.files.find((f) => f === 'package.json');
+        const packageJsonPath = join(project.cwd, packageJsonFile);
+        const data = await this.fsService.readJson(packageJsonPath);
+        const name = data.name || 'unnamed';
+        const version = data.version || '0.0.0';
+        const scripts = Object.keys(data.scripts || {});
+        const dependencies = Object.keys(data.dependencies || {});
+        const devDependencies = Object.keys(data.devDependencies || {});
+        // Infer technologies and frameworks
+        const technologies = ['Node.js'];
+        const frameworks = [];
+        if (devDependencies.includes('typescript') || dependencies.includes('typescript')) {
+            technologies.push('TypeScript');
+        }
+        else {
+            technologies.push('JavaScript');
+        }
+        const frameworkMap = {
+            next: 'Next.js',
+            react: 'React',
+            vue: 'Vue',
+            nuxt: 'Nuxt',
+            svelte: 'Svelte',
+            express: 'Express',
+            fastify: 'Fastify',
+            hono: 'Hono',
+            nest: 'NestJS',
+        };
+        const allDeps = [...dependencies, ...devDependencies];
+        for (const [depKey, fwName] of Object.entries(frameworkMap)) {
+            if (allDeps.some((d) => d.includes(depKey))) {
+                frameworks.push(fwName);
+            }
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                name,
+                version,
+                scripts,
+                dependencies: data.dependencies || {},
+                devDependencies: data.devDependencies || {},
+                engines: data.engines || {},
+                workspaces: data.workspaces || null,
+                technologies,
+                frameworks,
+                metadata: {
+                    projectLanguage: technologies.includes('TypeScript') ? 'TypeScript' : 'JavaScript',
+                    projectFramework: frameworks[0] || 'Node.js base',
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=package-json.analyzer.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzers/pom-xml.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 Maven pom.xml configuration files.
+ */
+export declare class PomXmlAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "pom-xml";
+    readonly name = "Maven POM Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/pom-xml.analyzer.js

@@ -0,0 +1,70 @@
+import { join } from 'node:path';
+import { XMLParser } from 'fast-xml-parser';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for Maven pom.xml configuration files.
+ */
+export class PomXmlAnalyzer {
+    fsService;
+    id = 'pom-xml';
+    name = 'Maven POM Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f === 'pom.xml');
+    }
+    async analyze(project) {
+        const file = project.files.find((f) => f === 'pom.xml');
+        const path = join(project.cwd, file);
+        const content = await this.fsService.read(path);
+        let groupId = 'unknown';
+        let artifactId = 'unknown';
+        let version = 'unknown';
+        const dependencies = [];
+        const frameworks = [];
+        try {
+            const parser = new XMLParser();
+            const xml = parser.parse(content);
+            const projectNode = xml.project || {};
+            groupId = projectNode.groupId || projectNode.parent?.groupId || 'unknown';
+            artifactId = projectNode.artifactId || 'unknown';
+            version = projectNode.version || projectNode.parent?.version || 'unknown';
+            // Parse dependencies
+            let depsList = projectNode.dependencies?.dependency;
+            if (depsList) {
+                if (!Array.isArray(depsList)) {
+                    depsList = [depsList];
+                }
+                for (const dep of depsList) {
+                    if (dep.artifactId) {
+                        dependencies.push(dep.artifactId);
+                        if (dep.artifactId.includes('spring-boot')) {
+                            frameworks.push('Spring Boot');
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Graceful fallback
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                groupId,
+                artifactId,
+                version,
+                dependencies,
+                frameworks,
+                technologies: ['Java', 'Maven'],
+                metadata: {
+                    projectLanguage: 'Java',
+                    projectFramework: frameworks[0] || 'Java Maven base',
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=pom-xml.analyzer.js.map

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

@@ -0,0 +1,17 @@
+import { ProjectContext, AnalysisResult } from '@devbrain/shared';
+import { Analyzer } from '../analyzer.interface.js';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for README files.
+ */
+export declare class ReadmeAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "readme";
+    readonly name = "README.md Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+    private extractTitle;
+    private extractSections;
+    private extractDescription;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/readme.analyzer.js

@@ -0,0 +1,65 @@
+import { join } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for README files.
+ */
+export class ReadmeAnalyzer {
+    fsService;
+    id = 'readme';
+    name = 'README.md Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f.toLowerCase() === 'readme.md');
+    }
+    async analyze(project) {
+        const readmeFile = project.files.find((f) => f.toLowerCase() === 'readme.md');
+        const readmePath = join(project.cwd, readmeFile);
+        const content = await this.fsService.read(readmePath);
+        const title = this.extractTitle(content);
+        const sections = this.extractSections(content);
+        const description = this.extractDescription(content);
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                title,
+                description,
+                sections,
+            },
+        };
+    }
+    extractTitle(content) {
+        const titleMatch = content.match(/^#\s+(.+)$/m);
+        return titleMatch ? titleMatch[1].trim() : 'Untitled Project';
+    }
+    extractSections(content) {
+        const sectionMatches = content.matchAll(/^##\s+(.+)$/gm);
+        return Array.from(sectionMatches).map((m) => m[1].trim());
+    }
+    extractDescription(content) {
+        const lines = content.split('\n');
+        let foundTitle = false;
+        const descriptionParagraphs = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('# ')) {
+                foundTitle = true;
+                continue;
+            }
+            if (foundTitle) {
+                if (trimmed.startsWith('## ') || trimmed.startsWith('# ')) {
+                    break; // Next section starts, stop extracting description
+                }
+                if (trimmed && !trimmed.startsWith('!') && !trimmed.startsWith('[')) {
+                    descriptionParagraphs.push(trimmed);
+                    if (descriptionParagraphs.length >= 2)
+                        break; // Limit to first two descriptive paragraphs
+                }
+            }
+        }
+        return descriptionParagraphs.join(' ');
+    }
+}
+//# sourceMappingURL=readme.analyzer.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzers/requirements-txt.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 Python requirements.txt files.
+ */
+export declare class RequirementsTxtAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "requirements-txt";
+    readonly name = "Python Requirements Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/requirements-txt.analyzer.js

@@ -0,0 +1,62 @@
+import { join } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for Python requirements.txt files.
+ */
+export class RequirementsTxtAnalyzer {
+    fsService;
+    id = 'requirements-txt';
+    name = 'Python Requirements Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f === 'requirements.txt');
+    }
+    async analyze(project) {
+        const file = project.files.find((f) => f === 'requirements.txt');
+        const path = join(project.cwd, file);
+        const content = await this.fsService.read(path);
+        const dependencies = [];
+        const lines = content.split(/\r?\n/);
+        for (let line of lines) {
+            line = line.trim();
+            if (!line || line.startsWith('#')) {
+                continue;
+            }
+            // Simple parse: package==version, package>=version, etc.
+            const match = line.match(/^([a-zA-Z0-9_\-[\]]+)/);
+            if (match) {
+                dependencies.push(match[1]);
+            }
+        }
+        // Infer frameworks
+        const frameworks = [];
+        const frameworkMap = {
+            django: 'Django',
+            fastapi: 'FastAPI',
+            flask: 'Flask',
+            tornado: 'Tornado',
+        };
+        for (const dep of dependencies) {
+            const lowerDep = dep.toLowerCase();
+            if (frameworkMap[lowerDep]) {
+                frameworks.push(frameworkMap[lowerDep]);
+            }
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                dependencies,
+                frameworks,
+                technologies: ['Python'],
+                metadata: {
+                    projectLanguage: 'Python',
+                    projectFramework: frameworks[0] || 'Python base',
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=requirements-txt.analyzer.js.map

package/node_modules/@devbrain/core/dist/analysis/analyzers/tsconfig.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 tsconfig.json configurations.
+ */
+export declare class TsconfigAnalyzer implements Analyzer {
+    private readonly fsService;
+    readonly id = "tsconfig";
+    readonly name = "TypeScript Configuration Analyzer";
+    constructor(fsService?: FilesystemService);
+    supports(project: ProjectContext): Promise<boolean>;
+    analyze(project: ProjectContext): Promise<AnalysisResult>;
+}

package/node_modules/@devbrain/core/dist/analysis/analyzers/tsconfig.analyzer.js

@@ -0,0 +1,47 @@
+import { join } from 'node:path';
+import { FilesystemService } from '../../filesystem/filesystem.service.js';
+/**
+ * Analyzer for tsconfig.json configurations.
+ */
+export class TsconfigAnalyzer {
+    fsService;
+    id = 'tsconfig';
+    name = 'TypeScript Configuration Analyzer';
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    async supports(project) {
+        return project.files.some((f) => f === 'tsconfig.json');
+    }
+    async analyze(project) {
+        const tsconfigFile = project.files.find((f) => f === 'tsconfig.json');
+        const tsconfigPath = join(project.cwd, tsconfigFile);
+        const rawContent = await this.fsService.read(tsconfigPath);
+        // Strip comments to allow parsing json with comments
+        const cleanJson = rawContent.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '$1').trim();
+        let compilerOptions = {};
+        let references = [];
+        try {
+            const parsed = JSON.parse(cleanJson);
+            compilerOptions = parsed.compilerOptions || {};
+            references = parsed.references || [];
+        }
+        catch {
+            // Fallback if parsing fails
+        }
+        return {
+            analyzerId: this.id,
+            analyzerName: this.name,
+            data: {
+                target: compilerOptions.target || 'default',
+                module: compilerOptions.module || 'default',
+                moduleResolution: compilerOptions.moduleResolution || 'default',
+                strict: compilerOptions.strict ?? false,
+                jsx: compilerOptions.jsx || 'none',
+                referencesCount: references.length,
+                technologies: ['TypeScript'],
+            },
+        };
+    }
+}
+//# sourceMappingURL=tsconfig.analyzer.js.map

package/node_modules/@devbrain/core/dist/analysis/scanner.d.ts

@@ -0,0 +1,21 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export interface ScanOptions {
+    ignore?: string[];
+    followSymlinks?: boolean;
+    respectGitignore?: boolean;
+}
+/**
+ * Service for scanning repositories and finding files while respecting configuration filters.
+ */
+export declare class RepositoryScanner {
+    private readonly fsService;
+    constructor(fsService?: FilesystemService);
+    /**
+     * Scans a workspace directory recursively and returns all matching relative file paths.
+     */
+    scan(cwd: string, options?: ScanOptions): Promise<string[]>;
+    /**
+     * Helper to translate standard .gitignore patterns into fast-glob rules.
+     */
+    private parseGitignore;
+}

package/node_modules/@devbrain/core/dist/analysis/scanner.js

@@ -0,0 +1,81 @@
+import fg from 'fast-glob';
+import { join } from 'node:path';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+import { DEFAULT_IGNORE_PATTERNS } from '@devbrain/shared';
+/**
+ * Service for scanning repositories and finding files while respecting configuration filters.
+ */
+export class RepositoryScanner {
+    fsService;
+    constructor(fsService = new FilesystemService()) {
+        this.fsService = fsService;
+    }
+    /**
+     * Scans a workspace directory recursively and returns all matching relative file paths.
+     */
+    async scan(cwd, options = {}) {
+        const ignoreList = [...(options.ignore || DEFAULT_IGNORE_PATTERNS)];
+        // Respect .gitignore if configured
+        if (options.respectGitignore !== false) {
+            const gitignorePath = join(cwd, '.gitignore');
+            if (await this.fsService.exists(gitignorePath)) {
+                try {
+                    const gitignoreContent = await this.fsService.read(gitignorePath);
+                    const gitignoreRules = this.parseGitignore(gitignoreContent);
+                    ignoreList.push(...gitignoreRules);
+                }
+                catch {
+                    // Fallback silently if gitignore reading fails
+                }
+            }
+        }
+        // fast-glob parameters
+        const files = await fg('**/*', {
+            cwd,
+            ignore: ignoreList,
+            followSymbolicLinks: options.followSymlinks ?? false,
+            dot: true, // Scan hidden files like .gitignore or .git
+            onlyFiles: true,
+        });
+        return files;
+    }
+    /**
+     * Helper to translate standard .gitignore patterns into fast-glob rules.
+     */
+    parseGitignore(content) {
+        const rules = [];
+        const lines = content.split(/\r?\n/);
+        for (let line of lines) {
+            line = line.trim();
+            // Skip empty lines and comments
+            if (!line || line.startsWith('#')) {
+                continue;
+            }
+            // Negative patterns are not directly handled by basic fast-glob ignores,
+            // but simple exclusions are translated.
+            let pattern = line;
+            if (pattern.startsWith('!')) {
+                continue; // Skip negative ignores for simplicity in scanner v0.1
+            }
+            if (pattern.startsWith('/')) {
+                pattern = pattern.substring(1);
+            }
+            // If it has no slash and is not a wildcard, it can be anywhere in the directory hierarchy
+            if (!pattern.includes('/')) {
+                rules.push(`**/${pattern}`);
+                rules.push(`**/${pattern}/**`);
+            }
+            else {
+                if (pattern.endsWith('/')) {
+                    rules.push(`${pattern}**`);
+                }
+                else {
+                    rules.push(pattern);
+                    rules.push(`${pattern}/**`);
+                }
+            }
+        }
+        return rules;
+    }
+}
+//# sourceMappingURL=scanner.js.map

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

@@ -0,0 +1,17 @@
+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.
+     */
+    buildContext(memoryDir: string): Promise<string>;
+    /**
+     * Formats and converts absolute top-level headers (#) to sub-headers (##)
+     * to maintain a single root h1 structure and optimizes whitespaces.
+     */
+    private normalizeHeadings;
+}