readme-gen-analyzer 1.0.0

package/dist/utils/scriptsMarkdown.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildScriptsMarkdown = buildScriptsMarkdown;
+exports.formatWorkspaceScriptsForPrompt = formatWorkspaceScriptsForPrompt;
+/** Inline code content: escape backticks so markdown stays valid */
+function escapeInlineCode(s) {
+    return String(s).replace(/`/g, '\\`');
+}
+function packageManagerRun(pm) {
+    const p = (pm || 'npm').toLowerCase();
+    if (p === 'go mod' || p === 'go')
+        return { label: 'go', runWord: 'go run' };
+    if (p === 'poetry')
+        return { label: 'poetry', runWord: 'poetry run' };
+    if (p === 'uv')
+        return { label: 'uv', runWord: 'uv run' };
+    if (p === 'pdm')
+        return { label: 'pdm', runWord: 'pdm run' };
+    if (p === 'hatch')
+        return { label: 'hatch', runWord: 'hatch run' };
+    if (p === 'pip')
+        return { label: 'pip', runWord: 'python -m' };
+    if (p === 'pnpm')
+        return { label: 'pnpm', runWord: 'pnpm run' };
+    if (p === 'yarn')
+        return { label: 'yarn', runWord: 'yarn' };
+    if (p === 'bun')
+        return { label: 'bun', runWord: 'bun run' };
+    return { label: 'npm', runWord: 'npm run' };
+}
+/**
+ * Workspace script keys from PackageParser: "apps/api:dev" → dir apps/api, script dev.
+ * Plain keys: "build", "test" (no colon, or colon without path segments).
+ */
+function parseScriptKey(key) {
+    const i = key.indexOf(':');
+    if (i <= 0)
+        return { workspaceDir: null, scriptName: key };
+    const maybePath = key.slice(0, i);
+    const scriptName = key.slice(i + 1);
+    if (maybePath.includes('/') || maybePath.startsWith('packages\\') || maybePath.includes('\\')) {
+        const normalized = maybePath.replace(/\\/g, '/');
+        return { workspaceDir: normalized, scriptName };
+    }
+    // e.g. "npm:publish" — treat as single script name with colon
+    return { workspaceDir: null, scriptName: key };
+}
+function howToRun(pm, scriptKey, rawValue) {
+    const { runWord } = packageManagerRun(pm);
+    const { workspaceDir, scriptName } = parseScriptKey(scriptKey);
+    const value = rawValue.trim();
+    if (/^(go|python|pytest|uv|poetry|pdm|ruff|black|hatch)\s/i.test(value)) {
+        return { command: value };
+    }
+    if (workspaceDir) {
+        const cmd = `cd ${workspaceDir} && ${runWord} ${scriptName}`;
+        return {
+            command: cmd,
+            notes: value.startsWith('turbo ') ? 'turbo task' : undefined,
+        };
+    }
+    return { command: `${runWord} ${scriptName}` };
+}
+/**
+ * Markdown block for README / evidence: table + package manager line.
+ */
+function buildScriptsMarkdown(summary) {
+    const scripts = summary.scripts || {};
+    const entries = Object.entries(scripts);
+    if (entries.length === 0) {
+        const pm = (summary.packageManager || '').toLowerCase();
+        if (pm === 'go mod' || pm === 'go') {
+            return [
+                '_Detected: **Go modules**._',
+                '',
+                '| Task | Command |',
+                '| --- | --- |',
+                '| build | `go build ./...` |',
+                '| test | `go test ./...` |',
+                '| vet | `go vet ./...` |',
+                '| tidy | `go mod tidy` |',
+            ].join('\n');
+        }
+        if (['pip', 'poetry', 'uv', 'pdm', 'hatch'].includes(pm)) {
+            const install = pm === 'poetry'
+                ? 'poetry install'
+                : pm === 'uv'
+                    ? 'uv sync'
+                    : pm === 'pdm'
+                        ? 'pdm install'
+                        : pm === 'hatch'
+                            ? 'hatch env create'
+                            : 'pip install -r requirements.txt';
+            return [
+                `_Detected: **${pm}**._`,
+                '',
+                '| Task | Command |',
+                '| --- | --- |',
+                '| install | `' + install + '` |',
+                '| tests | `pytest` |',
+                '| types | `mypy .` _if configured_ |',
+            ].join('\n');
+        }
+        return null;
+    }
+    const { label } = packageManagerRun(summary.packageManager);
+    const lines = [
+        `_Detected package manager: **${label}**._`,
+        '',
+        '| Script | Definition | Run (from repo root) |',
+        '| --- | --- | --- |',
+    ];
+    for (const [key, rawVal] of entries) {
+        const def = escapeInlineCode(String(rawVal));
+        const { command, notes } = howToRun(summary.packageManager, key, String(rawVal));
+        const runCol = notes ? `\`${escapeInlineCode(command)}\` _(${notes})_` : `\`${escapeInlineCode(command)}\``;
+        lines.push(`| \`${escapeInlineCode(key)}\` | \`${def}\` | ${runCol} |`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Compact one-liner list for nested README prompts (per workspace).
+ */
+function formatWorkspaceScriptsForPrompt(scripts, workspaceDir, packageManager) {
+    const { runWord } = packageManagerRun(packageManager);
+    const rows = Object.entries(scripts).map(([name, val]) => {
+        const cmd = `cd ${workspaceDir} && ${runWord} ${name}`;
+        return `- **${name}**: \`${escapeInlineCode(String(val))}\` → \`${escapeInlineCode(cmd)}\``;
+    });
+    return rows.join('\n');
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "readme-gen-analyzer",
+  "version": "1.0.0",
+  "description": "Shared code analysis logic for readme-gen",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w"
+  },
+  "dependencies": {
+    "ignore": "^7.0.5",
+    "ts-morph": "^27.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.7",
+    "typescript": "^5.4.5"
+  }
+}

package/src/analyzers/ast-feature.detector.ts

@@ -0,0 +1,173 @@
+import { Project, SyntaxKind, CallExpression, PropertyAccessExpression } from 'ts-morph';
+
+export interface AstFeature {
+  name: string;
+  evidence: {
+    snippet: string;
+    file: string;
+  }[];
+}
+
+export class AstFeatureDetector {
+  public static detect(files: Record<string, string>): AstFeature[] {
+    const project = new Project({ useInMemoryFileSystem: true });
+    const features: Map<string, AstFeature> = new Map();
+
+    const addEvidence = (featureName: string, snippet: string, file: string) => {
+      if (!features.has(featureName)) {
+        features.set(featureName, { name: featureName, evidence: [] });
+      }
+      const feat = features.get(featureName)!;
+      if (feat.evidence.length < 5) { // Limit evidence to 5 snippets per feature
+        feat.evidence.push({ snippet, file });
+      }
+    };
+
+    for (const [filePath, content] of Object.entries(files)) {
+      if (!filePath.match(/\.(ts|js|tsx|jsx)$/)) continue;
+
+      const sourceFile = project.createSourceFile(filePath, content);
+      
+      // 1. Scan for Call Expressions (Mainly for app.get, mongoose.connect, etc.)
+      const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+      for (const call of callExpressions) {
+        const expression = call.getExpression();
+        const text = call.getText();
+        
+        // Pattern: app.get, router.post, etc.
+        if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+          const pae = expression as PropertyAccessExpression;
+          const name = pae.getName().toLowerCase();
+          const base = pae.getExpression().getText().toLowerCase();
+
+          // API Routes
+          if (['get', 'post', 'put', 'delete', 'patch', 'use'].includes(name)) {
+            if (['app', 'router', 'server', 'express'].includes(base)) {
+              addEvidence('API Endpoints', text.substring(0, 150), filePath);
+            }
+          }
+
+          // Database Integration (Mongoose, pg, MySQL)
+          if (name === 'connect' && (base === 'mongoose' || base === 'db')) {
+            addEvidence('Database Integration', text.substring(0, 150), filePath);
+          }
+          if (name === 'model' && base === 'mongoose') {
+            addEvidence('Database Integration', text.substring(0, 150), filePath);
+          }
+          if (name === 'createconnection' && (base === 'mysql' || base === 'db')) {
+            addEvidence('Database Integration', text.substring(0, 150), filePath);
+          }
+
+          // Authentication (JWT, bcrypt, passport)
+          if (['sign', 'verify'].includes(name) && base === 'jwt') {
+            addEvidence('Authentication', text.substring(0, 150), filePath);
+          }
+          if (['hash', 'compare'].includes(name) && base === 'bcrypt') {
+            addEvidence('Authentication', text.substring(0, 150), filePath);
+          }
+          if (['use', 'authenticate'].includes(name) && base === 'passport') {
+            addEvidence('Authentication', text.substring(0, 150), filePath);
+          }
+
+          // Environment Configuration
+          if (name === 'config' && base === 'dotenv') {
+            addEvidence('Environment Configuration', text.substring(0, 150), filePath);
+          }
+          if (name === 'get' && base === 'config') {
+            addEvidence('Environment Configuration', text.substring(0, 150), filePath);
+          }
+
+          // CLI Tool (Commander)
+          if (['command', 'option', 'parse', 'version'].includes(name) && ['program', 'cmd'].includes(base)) {
+            addEvidence('CLI Tool', text.substring(0, 150), filePath);
+          }
+        }
+
+        // 2. Scan for New Expressions (Prisma, pg Pool)
+        const newExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.NewExpression);
+        for (const newExpr of newExpressions) {
+          const newText = newExpr.getText().toLowerCase();
+          if (newText.includes('prismaclient')) {
+            addEvidence('Database Integration', newExpr.getText().substring(0, 150), filePath);
+          }
+          if (newText.includes('pool') || newText.includes('client')) {
+            addEvidence('Database Integration', newExpr.getText().substring(0, 150), filePath);
+          }
+        }
+
+        // 3. Scan for Property Access (process.env)
+        const propAccess = sourceFile.getDescendantsOfKind(SyntaxKind.PropertyAccessExpression);
+        for (const pae of propAccess) {
+          if (pae.getText().startsWith('process.env.')) {
+            addEvidence('Environment Configuration', pae.getText(), filePath);
+          }
+        }
+
+        // 4. Scan for Decorators (NestJS)
+        const decorators = sourceFile.getDescendantsOfKind(SyntaxKind.Decorator);
+        for (const dec of decorators) {
+          const decName = dec.getName().toLowerCase();
+          if (['get', 'post', 'put', 'delete', 'patch', 'controller'].includes(decName)) {
+            addEvidence('API Endpoints', dec.getText(), filePath);
+          }
+          if (['injectable'].includes(decName)) {
+            // Marker for service oriented architecture
+          }
+        }
+      }
+
+      // 5. File-path based API Route Detection (Next.js, etc.)
+      if (filePath.includes('pages/api/') || filePath.includes('app/api/')) {
+        addEvidence('API Endpoints', `File-based route: ${filePath}`, filePath);
+      }
+
+      // 6. Direct variable usage for CLI
+      if (content.includes('process.argv')) {
+        addEvidence('CLI Tool', 'process.argv', filePath);
+      }
+    }
+
+    for (const [filePath, content] of Object.entries(files)) {
+      if (filePath.endsWith('.py')) {
+        if (/@(?:app|router)\.(get|post|put|delete|patch)\s*\(/i.test(content)) {
+          addEvidence('API Endpoints', 'FastAPI/Starlette-style route decorators', filePath);
+        }
+        if (/flask|Flask\(__name__\)/.test(content) || /@app\.route\s*\(/i.test(content)) {
+          addEvidence('API Endpoints', 'Flask routes', filePath);
+        }
+        if (/django\.|from\s+django/.test(content)) {
+          addEvidence('Django application', 'Django imports', filePath);
+        }
+        if (/sqlalchemy|SQLAlchemy/.test(content)) {
+          addEvidence('Database Integration', 'SQLAlchemy', filePath);
+        }
+        if (/os\.getenv|os\.environ/.test(content)) {
+          addEvidence('Environment Configuration', 'os.getenv / os.environ', filePath);
+        }
+        if (/celery|Celery/.test(content)) {
+          addEvidence('Task queue', 'Celery', filePath);
+        }
+      }
+      if (filePath.endsWith('.go')) {
+        if (/gin-gonic\/gin|\.GET\s*\(|\.POST\s*\(/.test(content)) {
+          addEvidence('API Endpoints', 'Go HTTP handlers (gin / stdlib style)', filePath);
+        }
+        if (/gorm\.io|database\/sql|jackc\/pgx/.test(content)) {
+          addEvidence('Database Integration', 'Go database client', filePath);
+        }
+        if (/os\.Getenv/.test(content)) {
+          addEvidence('Environment Configuration', 'os.Getenv', filePath);
+        }
+        if (/spf13\/cobra/.test(content)) {
+          addEvidence('CLI Tool', 'Cobra CLI', filePath);
+        }
+        if (/grpc\.|google\.golang\.org\/grpc/.test(content)) {
+          addEvidence('gRPC', 'gRPC imports', filePath);
+        }
+      }
+    }
+
+    return Array.from(features.values());
+  }
+}

package/src/analyzers/definition.extractor.ts

@@ -0,0 +1,156 @@
+import { 
+  Project, 
+  SyntaxKind, 
+  ClassDeclaration, 
+  FunctionDeclaration, 
+  InterfaceDeclaration, 
+  TypeAliasDeclaration, 
+  ParameterDeclaration,
+  MethodDeclaration,
+  ArrowFunction,
+  Node
+} from 'ts-morph';
+import { PolyglotExtractors } from './polyglot.extractors';
+
+export class DefinitionExtractor {
+  public static extract(files: Record<string, string>): Record<string, string[]> {
+    const project = new Project({ useInMemoryFileSystem: true });
+    const result: Record<string, string[]> = {};
+
+    for (const [filePath, content] of Object.entries(files)) {
+      if (!filePath.match(/\.(ts|js|tsx|jsx)$/)) continue;
+      console.log(`[Analyzer] Parsing file for definitions: ${filePath}`);
+      project.createSourceFile(filePath, content);
+    }
+
+    project.getSourceFiles().forEach(sourceFile => {
+      const filePath = sourceFile.getFilePath();
+      const definitions: string[] = [];
+
+      // Extract Imports
+      sourceFile.getImportDeclarations().forEach(imp => {
+        const module = imp.getModuleSpecifierValue();
+        const names = imp.getNamedImports().map(n => n.getName()).join(', ');
+        if (names) definitions.push(`Import: { ${names} } from "${module}"`);
+        else if (imp.getDefaultImport()) definitions.push(`Import Default: ${imp.getDefaultImport()?.getText()} from "${module}"`);
+      });
+
+      // Recursive Extraction from all top-level nodes
+      sourceFile.forEachChild(node => {
+        this.walkNode(node, definitions);
+      });
+
+      // Interfaces/Types (Stay top-level mostly)
+      sourceFile.getInterfaces().forEach(intf => {
+        const name = intf.getName();
+        const properties = intf.getProperties().map(p => `${p.getName()}: ${p.getType().getText()}`).join(', ');
+        definitions.push(`Interface: ${name} { ${properties.substring(0, 200)} }`);
+      });
+
+      sourceFile.getTypeAliases().forEach(type => {
+        definitions.push(`Type Alias: ${type.getName()} = ${type.getType().getText().substring(0, 200)}`);
+      });
+
+      if (definitions.length > 0) {
+        const cleanPath = filePath.startsWith('/') ? filePath.substring(1) : filePath;
+        result[cleanPath] = definitions;
+      }
+    });
+
+    const polyglot = PolyglotExtractors.extractDefinitions(files);
+    for (const [p, defs] of Object.entries(polyglot)) {
+      if (!result[p]) result[p] = defs;
+      else result[p] = [...result[p]!, ...defs];
+    }
+
+    return result;
+  }
+
+  private static walkNode(node: Node, definitions: string[]) {
+    // Classes
+    if (Node.isClassDeclaration(node)) {
+      const name = node.getName() || "AnonymousClass";
+      definitions.push(`Class: ${name}`);
+      node.getMethods().forEach(m => definitions.push(`  ${this.formatSignature(m, 'Method')}`));
+      node.getConstructors().forEach(c => definitions.push(`  ${this.formatSignature(c, 'Constructor')}`));
+    }
+
+    // Functions
+    if (Node.isFunctionDeclaration(node)) {
+      const signature = this.formatSignature(node, 'Function');
+      console.log(`  [Extractor] Found Function: ${signature}`);
+      definitions.push(signature);
+    }
+
+    // Variable-based Functions (Arrow or Function Expressions)
+    if (Node.isVariableDeclaration(node)) {
+      const initializer = node.getInitializer();
+      if (initializer) {
+        if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) {
+          const name = node.getName();
+          const params = this.formatSignature(initializer, 'Function (assigned)');
+          console.log(`  [Extractor] Found Variable Function: ${name} ${params}`);
+          definitions.push(params);
+        } else if (Node.isObjectLiteralExpression(initializer)) {
+          // If it's a small object literal with methods, extract them
+          initializer.getProperties().forEach(prop => {
+            if (Node.isMethodDeclaration(prop) || Node.isPropertyAssignment(prop)) {
+              const propInit = Node.isPropertyAssignment(prop) ? prop.getInitializer() : null;
+              if (Node.isMethodDeclaration(prop) || (propInit && (Node.isArrowFunction(propInit) || Node.isFunctionExpression(propInit)))) {
+                const name = Node.isPropertyAssignment(prop) ? prop.getName() : (prop as any).getName();
+                const fn = Node.isPropertyAssignment(prop) ? (propInit as any) : prop;
+                definitions.push(`  Method (obj-prop): ${name}${this.formatParamsSnippet(fn)}`);
+              }
+            }
+          });
+        }
+      }
+    }
+
+    // Export Assignments
+    if (Node.isExportAssignment(node)) {
+      const expression = node.getExpression();
+      if (Node.isArrowFunction(expression) || Node.isFunctionExpression(expression)) {
+        definitions.push(`Export Default Function: ${this.formatSignature(expression, '')}`);
+      }
+    }
+
+    // Recurse into children to find nested functions (but not too deep into implementations)
+    if (!Node.isClassDeclaration(node) && !Node.isFunctionDeclaration(node) && !Node.isMethodDeclaration(node)) {
+      node.forEachChild(child => this.walkNode(child, definitions));
+    }
+  }
+
+  private static formatSignature(node: any, kind: string): string {
+    const name = node.getName?.() || "";
+    const params = this.formatParamsSnippet(node);
+    const asyncStr = node.isAsync?.() ? 'async ' : '';
+    return `${asyncStr}${kind}${name ? ': ' + name : ''}${params}`;
+  }
+
+  private static formatParamsSnippet(node: any): string {
+    const params = this.formatParams(node.getParameters?.() || []);
+    const returnType = this.safeGetReturnType(node);
+    return `(${params}) -> ${returnType}`;
+  }
+
+  private static formatParams(params: ParameterDeclaration[]): string {
+    return params.map(p => {
+      const name = p.getName();
+      const type = this.safeGetParamType(p);
+      return `${name}${p.isOptional() ? '?' : ''}: ${type}`;
+    }).join(', ');
+  }
+
+  private static safeGetParamType(p: ParameterDeclaration): string {
+    try {
+      return p.getTypeNode()?.getText() || p.getType().getText() || 'any';
+    } catch { return 'any'; }
+  }
+
+  private static safeGetReturnType(fn: any): string {
+    try {
+      return fn.getReturnTypeNode()?.getText() || fn.getReturnType().getText() || 'void';
+    } catch { return 'void'; }
+  }
+}

package/src/analyzers/dependency.analyzer.ts

@@ -0,0 +1,32 @@
+interface DependencyGroups {
+  core: string[];
+  database: string[];
+  testing: string[];
+  deployment: string[];
+}
+
+export class DependencyAnalyzer {
+  private static CORE = ['express', 'fastapi', 'flask', 'django', 'react', 'next', 'vue', 'nest', 'koa'];
+  private static DATABASE = ['mongoose', 'prisma', 'pg', 'mysql2', 'redis', 'sequelize', 'mongodb', 'psycopg2', 'sqlalchemy'];
+  private static TESTING = ['jest', 'mocha', 'chai', 'cypress', 'pytest', 'vitest', 'playwright'];
+  private static DEPLOYMENT = ['docker', 'aws-sdk', 'firebase', 'vercel', 'netlify', 'terraform'];
+
+  public static analyze(dependencies: string[]): DependencyGroups {
+    const groups: DependencyGroups = {
+      core: [],
+      database: [],
+      testing: [],
+      deployment: []
+    };
+
+    dependencies.forEach(dep => {
+      const lower = dep.toLowerCase();
+      if (this.CORE.some(c => lower.includes(c))) groups.core.push(dep);
+      if (this.DATABASE.some(d => lower.includes(d))) groups.database.push(dep);
+      if (this.TESTING.some(t => lower.includes(t))) groups.testing.push(dep);
+      if (this.DEPLOYMENT.some(d => lower.includes(d))) groups.deployment.push(dep);
+    });
+
+    return groups;
+  }
+}

package/src/analyzers/devops.analyzer.ts

@@ -0,0 +1,44 @@
+export class DevOpsAnalyzer {
+  public static analyze(files: Record<string, string>) {
+    const devOps: any = {};
+
+    // 1. Dockerfile
+    const dockerPath = Object.keys(files).find(f => f.toLowerCase().endsWith('dockerfile'));
+    if (dockerPath) {
+      const content = files[dockerPath];
+      devOps.docker = {
+        baseImage: content.match(/FROM\s+([^\s\n]+)/i)?.[1],
+        ports: [...content.matchAll(/EXPOSE\s+(\d+)/gi)].map(m => m[1]),
+        command: content.match(/CMD\s+\[?([^\]\n]+)\]?/i)?.[1]?.replace(/"/g, '')
+      };
+    }
+
+    // 2. Docker Compose
+    const composePath = Object.keys(files).find(f => f.toLowerCase().includes('docker-compose') && f.endsWith('.yml'));
+    if (composePath) {
+      const content = files[composePath];
+      const services = [...content.matchAll(/^\s+([a-z0-9_-]+):/gm)]
+        .map(m => m[1])
+        .filter(s => !['services', 'networks', 'volumes', 'version'].includes(s));
+      const networks = [...content.matchAll(/^\s+networks:\s*\n(\s+- [a-z0-9_-]+\n)+/gi)].length > 0 ? ['Enabled'] : [];
+      
+      devOps.compose = { services, networks };
+    }
+
+    // 3. GitHub Actions
+    const workflowPath = Object.keys(files).find(f => f.includes('.github/workflows') && f.endsWith('.yml'));
+    if (workflowPath) {
+      const content = files[workflowPath];
+      const jobs = [...content.matchAll(/^\s+([a-z0-9_-]+):/gm)]
+        .map(m => m[1])
+        .filter(j => !['jobs', 'on', 'workflow_dispatch', 'name'].includes(j));
+      
+      devOps.pipeline = {
+        provider: 'GitHub Actions',
+        jobs
+      };
+    }
+
+    return Object.keys(devOps).length > 0 ? devOps : undefined;
+  }
+}

package/src/analyzers/env.extractor.ts

@@ -0,0 +1,58 @@
+export interface EnvVar {
+  name: string;
+}
+
+export class EnvExtractor {
+  private static ENV_REGEX = /process\.env\.([a-zA-Z_][a-zA-Z0-9_]*)/g;
+
+  public static extract(files: Record<string, string>): string[] {
+    const envVars = new Set<string>();
+
+    for (const [filePath, content] of Object.entries(files)) {
+      // 1. From .env or .env.example
+      if (filePath.endsWith('.env') || filePath.endsWith('.env.example')) {
+        const lines = content.split('\n');
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith('#')) {
+            const match = trimmed.match(/^([^=]+)=/);
+            if (match) {
+              envVars.add(match[1].trim());
+            }
+          }
+        }
+      }
+
+      // 2. From code usage (process.env.VAR)
+      if (filePath.endsWith('.ts') || filePath.endsWith('.js')) {
+        let match;
+        while ((match = this.ENV_REGEX.exec(content)) !== null) {
+          envVars.add(match[1]);
+        }
+      }
+
+      if (filePath.endsWith('.py')) {
+        for (const m of content.matchAll(
+          /os\.(?:getenv|environ\.get)\(\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']/g,
+        )) {
+          envVars.add(m[1]!);
+        }
+        for (const m of content.matchAll(
+          /os\.environ\[\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']\s*\]/g,
+        )) {
+          envVars.add(m[1]!);
+        }
+      }
+
+      if (filePath.endsWith('.go')) {
+        for (const m of content.matchAll(
+          /os\.Getenv\(\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']\s*\)/g,
+        )) {
+          envVars.add(m[1]!);
+        }
+      }
+    }
+
+    return Array.from(envVars);
+  }
+}