devbrain-cli 0.1.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/.bin/fxparser.ps1

@@ -0,0 +1,28 @@
+#!/usr/bin/env pwsh
+$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent
+
+$exe=""
+if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) {
+  # Fix case when both the Windows and Linux builds of Node
+  # are installed in the same directory
+  $exe=".exe"
+}
+$ret=0
+if (Test-Path "$basedir/node$exe") {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "$basedir/node$exe"  "$basedir/../fast-xml-parser/src/cli/cli.js" $args
+  } else {
+    & "$basedir/node$exe"  "$basedir/../fast-xml-parser/src/cli/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+} else {
+  # Support pipeline input
+  if ($MyInvocation.ExpectingInput) {
+    $input | & "node$exe"  "$basedir/../fast-xml-parser/src/cli/cli.js" $args
+  } else {
+    & "node$exe"  "$basedir/../fast-xml-parser/src/cli/cli.js" $args
+  }
+  $ret=$LASTEXITCODE
+}
+exit $ret

package/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/analysis/analyzer.interface.js

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

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

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