readme-gen-analyzer 1.0.0

package/src/analyzers/example.analyzer.ts

@@ -0,0 +1,96 @@
+import { Project, SyntaxKind, CallExpression } from 'ts-morph';
+
+export class ExampleAnalyzer {
+  public static analyze(files: Record<string, string>) {
+    const examples: any[] = [];
+    const project = new Project({ useInMemoryFileSystem: true });
+
+    for (const [filePath, content] of Object.entries(files)) {
+      if (filePath.endsWith('.py') && this.isPythonTestPath(filePath)) {
+        this.collectPythonTests(filePath, content, examples);
+        continue;
+      }
+      if (filePath.endsWith('_test.go')) {
+        this.collectGoTests(filePath, content, examples);
+        continue;
+      }
+      if (!filePath.match(/\.(test|spec)\.(ts|js|jsx|tsx)$/) && !filePath.includes('__tests__')) continue;
+      
+      const sourceFile = project.createSourceFile(filePath, content);
+      const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+
+      for (const call of callExpressions) {
+        const name = call.getExpression().getText().toLowerCase();
+        if (['it', 'test'].includes(name)) {
+          const args = call.getArguments();
+          if (args.length >= 2) {
+            const description = args[0].getText().replace(/['"`]/g, '');
+            const body = args[1].getText();
+            
+            // Heuristic for "Good" examples: contain multiple calls or interesting snippets
+            const isInteresting = body.includes('await') || body.includes('expect') || body.split('\n').length > 5;
+            
+            if (isInteresting && examples.length < 15) {
+              const cleanBody = body.replace(/^\(\) => \{|\}$|^\(async \(\) => \{|\}$/g, '').trim();
+              examples.push({
+                description,
+                code: cleanBody,
+                file: filePath
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return examples.length > 0 ? examples : undefined;
+  }
+
+  private static isPythonTestPath(filePath: string): boolean {
+    const base = filePath.split('/').pop() || '';
+    if (base.startsWith('test_') && base.endsWith('.py')) return true;
+    if (filePath.includes('/tests/') || filePath.includes('/test/')) return true;
+    return false;
+  }
+
+  private static collectPythonTests(
+    filePath: string,
+    content: string,
+    examples: any[],
+  ) {
+    const re = /^(async\s+)?def\s+(test_\w+)\s*\([^)]*\):/gm;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(content)) !== null) {
+      if (examples.length >= 15) break;
+      const start = m.index;
+      const next = content.indexOf('\ndef ', start + 5);
+      const block = content.slice(
+        start,
+        next === -1 ? Math.min(start + 800, content.length) : Math.min(next, start + 800),
+      );
+      examples.push({
+        description: m[2]!,
+        code: block.trim(),
+        file: filePath,
+      });
+    }
+  }
+
+  private static collectGoTests(
+    filePath: string,
+    content: string,
+    examples: any[],
+  ) {
+    const re = /^func\s+(Test\w+)\s*\(/gm;
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(content)) !== null) {
+      if (examples.length >= 15) break;
+      const block = content.slice(m.index, m.index + 700);
+      examples.push({
+        description: m[1]!,
+        code: block.trim(),
+        file: filePath,
+      });
+    }
+  }
+}

package/src/analyzers/feature.detector.ts

@@ -0,0 +1,65 @@
+export class FeatureDetector {
+  private static FEATURE_MAP: Record<string, string> = {
+    'express': 'REST API Framework',
+    'fastify': 'High-performance REST API',
+    'react': 'Frontend Development',
+    'next': 'Server-side Rendering',
+    'mongoose': 'MongoDB Database Support',
+    'prisma': 'Modern Database ORM',
+    'jest': 'Automated Unit Testing',
+    'cypress': 'End-to-End Testing',
+    'docker': 'Containerization Support',
+    'passport': 'Authentication & Authorization',
+    'jsonwebtoken': 'JWT Auth Tokens',
+    'axios': 'External API Integration',
+    'dotenv': 'Environment Configuration',
+    'typescript': 'Static Type Safety',
+    'turbo': 'Monorepo Pipeline Management',
+    'stripe': 'Payment Processing',
+    'redis': 'Cache & Session Management',
+    'socket.io': 'Real-time Communication',
+    'nest': 'Enterprise-grade Architecture',
+    'fastapi': 'High-performance Python API',
+    'flask': 'Lightweight Python Web Services',
+    'django': 'Full-stack Python Framework',
+    'starlette': 'ASGI Python framework',
+    'uvicorn': 'ASGI server',
+    'gunicorn': 'WSGI HTTP server',
+    'celery': 'Distributed task queue',
+    'sqlalchemy': 'SQL toolkit / ORM',
+    'pydantic': 'Data validation',
+    'httpx': 'HTTP client',
+    'requests': 'HTTP client',
+    'boto3': 'AWS SDK',
+    'pytest': 'Python testing',
+    'ruff': 'Python linter/formatter',
+    'black': 'Python formatter',
+    'gin-gonic/gin': 'Gin HTTP framework',
+    'labstack/echo': 'Echo web framework',
+    'gofiber/fiber': 'Fiber web framework',
+    'go-chi/chi': 'chi router',
+    'gorilla/mux': 'Gorilla mux router',
+    'google.golang.org/grpc': 'gRPC',
+    'grpc-go': 'gRPC Go',
+    'spf13/cobra': 'Cobra CLI',
+    'gorm.io/gorm': 'GORM ORM',
+    'testify': 'Go assertions/mocks',
+  };
+
+  public static detect(dependencies: string[], devDependencies: string[], hasDocker: boolean, hasRoutes: boolean): string[] {
+    const features = new Set<string>();
+    const allDeps = [...dependencies, ...devDependencies].map(d => d.toLowerCase());
+
+    for (const [dep, feature] of Object.entries(this.FEATURE_MAP)) {
+      if (allDeps.some(d => d.includes(dep))) {
+        features.add(feature);
+      }
+    }
+
+    if (hasDocker) features.add('Docker Container Environments');
+    if (hasRoutes) features.add('API Endpoint Management');
+    if (dependencies.length > 0) features.add('Dependency-driven development');
+
+    return Array.from(features);
+  }
+}

package/src/analyzers/package.parser.ts

@@ -0,0 +1,364 @@
+export interface PackageMetadata {
+  name: string;
+  version: string;
+  description: string;
+  scripts: Record<string, string>;
+  dependencies: {
+    production: string[];
+    development: string[];
+    peer: string[];
+  };
+  frameworks: string[];
+  packageManager: string;
+}
+
+export class PackageParser {
+  public static async parse(files: Record<string, string>): Promise<PackageMetadata | null> {
+    const packageFiles = Object.keys(files).filter(f => f.endsWith('package.json'));
+    
+    if (packageFiles.length > 0) {
+      return this.parseMultipleNode(packageFiles, files);
+    }
+
+    const req = files['requirements.txt'] || '';
+    const pyproject = files['pyproject.toml'] || '';
+    if (req || pyproject) {
+      return this.parsePython(req, pyproject);
+    }
+    if (files['go.mod']) {
+      return this.parseGo(files['go.mod']);
+    }
+    return null;
+  }
+
+  private static parseMultipleNode(packagePaths: string[], allFiles: Record<string, string>): PackageMetadata {
+    const mergedScripts: Record<string, string> = {};
+    const mergedDeps = new Set<string>();
+    const mergedDevDeps = new Set<string>();
+    const mergedPeerDeps = new Set<string>();
+    const mergedFrameworks = new Set<string>();
+    
+    let primaryName = '';
+    let primaryDescription = '';
+    let primaryVersion = '0.0.0';
+
+    // Sort paths by depth (shallowest first) to pick primary metadata from root
+    const sortedPaths = [...packagePaths].sort((a, b) => a.split('/').length - b.split('/').length);
+
+    sortedPaths.forEach((path, index) => {
+      try {
+        const pkg = JSON.parse(allFiles[path]);
+        // Normalize path for splitting
+        const normalizedPath = path.replace(/\\/g, '/');
+        const parts = normalizedPath.split('/');
+        
+        // If it's a nested package (e.g., apps/api/package.json), prefix with the directory path
+        let prefix = '';
+        if (parts.length > 1) {
+          const dirParts = parts.slice(0, -1);
+          prefix = dirParts.join('/') + ':';
+        }
+
+        // If no primary metadata yet, or if current one is more descriptive, pick it
+        if (!primaryName || (index === 0 && pkg.name)) {
+          primaryName = pkg.name || primaryName;
+          primaryDescription = pkg.description || primaryDescription;
+          primaryVersion = pkg.version || primaryVersion;
+        }
+
+        // Merge scripts with prefix if not root
+        if (pkg.scripts) {
+          Object.entries(pkg.scripts as Record<string, string>).forEach(([name, cmd]) => {
+            const key = prefix ? `${prefix}${name}` : name;
+            mergedScripts[key] = cmd;
+          });
+        }
+
+        // Merge dependencies
+        if (pkg.dependencies) {
+          Object.keys(pkg.dependencies).forEach(d => {
+            mergedDeps.add(d);
+            this.detectFramework(d, mergedFrameworks);
+          });
+        }
+        if (pkg.devDependencies) {
+          Object.keys(pkg.devDependencies).forEach(d => mergedDevDeps.add(d));
+        }
+        if (pkg.peerDependencies) {
+          Object.keys(pkg.peerDependencies).forEach(d => mergedPeerDeps.add(d));
+        }
+      } catch (e) {
+        console.warn(`Failed to parse ${path}:`, e);
+      }
+    });
+
+    let packageManager = 'npm';
+    if (Object.keys(allFiles).some(f => f.includes('pnpm-lock.yaml'))) packageManager = 'pnpm';
+    else if (Object.keys(allFiles).some(f => f.includes('yarn.lock'))) packageManager = 'yarn';
+    else if (Object.keys(allFiles).some(f => f.endsWith('bun.lockb'))) packageManager = 'bun';
+
+    return {
+      name: primaryName || 'Unknown Node Project',
+      version: primaryVersion,
+      description: primaryDescription,
+      scripts: mergedScripts,
+      dependencies: {
+        production: Array.from(mergedDeps),
+        development: Array.from(mergedDevDeps),
+        peer: Array.from(mergedPeerDeps),
+      },
+      frameworks: Array.from(mergedFrameworks),
+      packageManager,
+    };
+  }
+
+  private static detectFramework(dep: string, frameworks: Set<string>) {
+    const frameworkMap: Record<string, string> = {
+      'express': 'Express',
+      'react': 'React',
+      'next': 'Next.js',
+      'vue': 'Vue',
+      '@nestjs/core': 'NestJS',
+      'koa': 'Koa',
+      'fastify': 'Fastify',
+      'socket.io': 'Socket.io',
+      'mongoose': 'Mongoose',
+      'prisma': 'Prisma',
+      'tailwindcss': 'TailwindCSS',
+      'vite': 'Vite'
+    };
+
+    if (frameworkMap[dep]) frameworks.add(frameworkMap[dep]);
+  }
+
+  private static parsePython(reqs: string, pyproject: string): PackageMetadata {
+    const py = pyproject ? this.parsePyProjectToml(pyproject) : null;
+    const reqDeps = this.parseRequirementsTxt(reqs);
+    const prod = Array.from(
+      new Set([...(py?.deps || []), ...reqDeps]),
+    );
+    const dev = py?.devDeps || [];
+
+    const frameworks = this.detectPythonFrameworks(prod, dev, pyproject + reqs);
+
+    const scripts: Record<string, string> = { ...py?.scripts };
+    if (frameworks.includes('Django') && !scripts['manage']) {
+      scripts['manage'] = 'python manage.py <command>';
+    }
+
+    const packageManager = this.detectPythonPm(pyproject);
+
+    return {
+      name: py?.name || 'Python Project',
+      version: py?.version || '1.0.0',
+      description: py?.description || '',
+      scripts,
+      dependencies: {
+        production: prod,
+        development: dev,
+        peer: [],
+      },
+      frameworks,
+      packageManager,
+    };
+  }
+
+  private static detectPythonPm(pyproject: string): string {
+    if (!pyproject) return 'pip';
+    if (/\[tool\.poetry\]/i.test(pyproject)) return 'poetry';
+    if (/\[tool\.uv\]/i.test(pyproject) || /uv\.lock/i.test(pyproject))
+      return 'uv';
+    if (/\[tool\.pdm\]/i.test(pyproject)) return 'pdm';
+    if (/\[tool\.hatch\]/i.test(pyproject)) return 'hatch';
+    return 'pip';
+  }
+
+  private static parseRequirementsTxt(content: string): string[] {
+    const names: string[] = [];
+    for (const line of content.split('\n')) {
+      const name = this.parseRequirementLine(line);
+      if (name) names.push(name);
+    }
+    return names;
+  }
+
+  /** pip / requirements.txt line → distribution name */
+  private static parseRequirementLine(line: string): string | null {
+    const t = line.trim();
+    if (!t || t.startsWith('#') || t.startsWith('-')) return null;
+    const head = t.split(/[;#]/)[0]!.trim();
+    if (!head) return null;
+    const noVersion = head.split(/\s*[<>=~!]/)[0]!.trim();
+    const noExtra = noVersion.split(/[\[]/)[0]!.trim();
+    const name = noExtra.split(/[@\s]/)[0]!.trim();
+    if (!name || !/^[a-zA-Z0-9._-]+$/.test(name)) return null;
+    return name;
+  }
+
+  private static parsePyProjectToml(content: string): {
+    name?: string;
+    version?: string;
+    description?: string;
+    deps: string[];
+    devDeps: string[];
+    scripts: Record<string, string>;
+  } {
+    const deps: string[] = [];
+    const devDeps: string[] = [];
+    const scripts: Record<string, string> = {};
+    let name: string | undefined;
+    let version: string | undefined;
+    let description: string | undefined;
+
+    let section = '';
+    const lines = content.split('\n');
+    for (const raw of lines) {
+      const line = raw.split('#')[0]!.trim();
+      const sec = line.match(/^\[([^\]]+)\]/);
+      if (sec) {
+        section = sec[1]!.toLowerCase();
+        continue;
+      }
+      if (section === 'project') {
+        const nm = line.match(/^name\s*=\s*["']([^"']+)["']/i);
+        const ver = line.match(/^version\s*=\s*["']([^"']+)["']/i);
+        const desc = line.match(/^description\s*=\s*["']([^"']*)["']/i);
+        if (nm) name = nm[1];
+        if (ver) version = ver[1];
+        if (desc) description = desc[1];
+      }
+      if (
+        section === 'tool.poetry.dependencies' ||
+        section === 'tool.poetry.group.dev.dependencies'
+      ) {
+        const depKey = line.match(/^([a-zA-Z0-9_.-]+)\s*=/);
+        if (depKey && depKey[1]!.toLowerCase() !== 'python') {
+          if (section.includes('dev')) devDeps.push(depKey[1]!);
+          else deps.push(depKey[1]!);
+        }
+      }
+      if (section === 'tool.poetry.scripts') {
+        const sc = line.match(/^([a-zA-Z0-9_.-]+)\s*=\s*["']([^"']+)["']/);
+        if (sc) scripts[sc[1]!] = sc[2]!;
+      }
+    }
+
+    return { name, version, description, deps, devDeps, scripts };
+  }
+
+  private static detectPythonFrameworks(
+    prod: string[],
+    dev: string[],
+    raw: string,
+  ): string[] {
+    const all = [...prod, ...dev].map((d) => d.toLowerCase());
+    const text = raw.toLowerCase();
+    const frameworks: string[] = [];
+    const add = (f: string) => {
+      if (!frameworks.includes(f)) frameworks.push(f);
+    };
+    const has = (s: string) =>
+      all.some((d) => d.includes(s)) || text.includes(s);
+    if (has('fastapi')) add('FastAPI');
+    if (has('flask')) add('Flask');
+    if (has('django')) add('Django');
+    if (has('starlette')) add('Starlette');
+    if (has('tornado')) add('Tornado');
+    if (has('sanic')) add('Sanic');
+    if (has('litestar')) add('Litestar');
+    if (has('sqlalchemy')) add('SQLAlchemy');
+    if (has('pydantic')) add('Pydantic');
+    if (has('celery')) add('Celery');
+    if (has('pytest')) add('pytest');
+    return frameworks;
+  }
+
+  private static parseGo(content: string): PackageMetadata {
+    const lines = content.split('\n');
+    const moduleLine = lines.find((l) => l.trim().startsWith('module '));
+    const name = moduleLine
+      ? moduleLine.replace(/^\s*module\s+/, '').trim().split(/\s+/)[0]!
+      : 'Go Project';
+
+    const modules = this.parseGoRequireBlock(content);
+    const frameworks = this.detectGoFrameworks(modules);
+
+    const scripts: Record<string, string> = {
+      build: 'go build ./...',
+      test: 'go test ./...',
+      vet: 'go vet ./...',
+      mod: 'go mod tidy',
+    };
+
+    return {
+      name,
+      version: '1.0.0',
+      description: '',
+      scripts,
+      dependencies: {
+        production: modules,
+        development: [],
+        peer: [],
+      },
+      frameworks,
+      packageManager: 'go mod',
+    };
+  }
+
+  private static parseGoRequireBlock(content: string): string[] {
+    const mods: string[] = [];
+    const lines = content.split('\n');
+    let inBlock = false;
+    for (const raw of lines) {
+      const line = raw.trim();
+      if (line.startsWith('require (')) {
+        inBlock = true;
+        continue;
+      }
+      if (inBlock && line === ')') {
+        inBlock = false;
+        continue;
+      }
+      if (inBlock && line && !line.startsWith('//') && !line.startsWith('replace ')) {
+        const modPath = line.split(/\s+/)[0]!;
+        if (modPath) mods.push(modPath);
+        continue;
+      }
+      if (line.startsWith('require ') && !line.includes('(')) {
+        const rest = line.replace(/^require\s+/, '').trim();
+        const modPath = rest.split(/\s+/)[0]!;
+        if (modPath && !modPath.startsWith('//')) mods.push(modPath);
+      }
+    }
+    return Array.from(new Set(mods));
+  }
+
+  private static detectGoFrameworks(modules: string[]): string[] {
+    const frameworks: string[] = [];
+    const add = (f: string) => {
+      if (!frameworks.includes(f)) frameworks.push(f);
+    };
+    const s = modules.join(' ').toLowerCase();
+    const pairs: [string, string][] = [
+      ['gin-gonic/gin', 'Gin'],
+      ['labstack/echo', 'Echo'],
+      ['gofiber/fiber', 'Fiber'],
+      ['go-chi/chi', 'chi'],
+      ['gorilla/mux', 'Gorilla mux'],
+      ['google.golang.org/grpc', 'gRPC'],
+      ['grpc-go', 'gRPC'],
+      ['grpc/grpc-go', 'gRPC'],
+      ['spf13/cobra', 'Cobra'],
+      ['spf13/viper', 'Viper'],
+      ['stretchr/testify', 'testify'],
+      ['jackc/pgx', 'pgx'],
+      ['go-redis/redis', 'Redis'],
+      ['gorm.io/gorm', 'GORM'],
+      ['entgo.io/ent', 'Ent'],
+    ];
+    for (const [needle, label] of pairs) {
+      if (s.includes(needle)) add(label);
+    }
+    return frameworks;
+  }
+}

package/src/analyzers/polyglot.extractors.ts

@@ -0,0 +1,169 @@
+/** Same shape as RouteExtractor Route */
+export interface PolyglotRoute {
+  method: string;
+  path: string;
+  file: string;
+  snippet?: string;
+}
+
+/** Routes & API surface for Python (FastAPI, Flask, Starlette-style) and Go (net/http, gin, echo, chi, mux, fiber). */
+export class PolyglotExtractors {
+  public static extractRoutes(files: Record<string, string>): PolyglotRoute[] {
+    const routes: PolyglotRoute[] = [];
+    for (const [filePath, content] of Object.entries(files)) {
+      if (filePath.endsWith(".py")) {
+        routes.push(...this.pythonRoutes(filePath, content));
+      } else if (filePath.endsWith(".go")) {
+        routes.push(...this.goRoutes(filePath, content));
+      }
+    }
+    return routes;
+  }
+
+  public static extractDefinitions(
+    files: Record<string, string>,
+  ): Record<string, string[]> {
+    const result: Record<string, string[]> = {};
+    for (const [filePath, content] of Object.entries(files)) {
+      if (filePath.endsWith(".py")) {
+        const defs = this.pythonDefinitions(content);
+        if (defs.length) result[filePath] = defs;
+      } else if (filePath.endsWith(".go")) {
+        const defs = this.goDefinitions(content);
+        if (defs.length) result[filePath] = defs;
+      }
+    }
+    return result;
+  }
+
+  private static pythonRoutes(file: string, content: string): PolyglotRoute[] {
+    const out: PolyglotRoute[] = [];
+    const lines = content.split("\n");
+
+    // FastAPI / Starlette: @app.get("/path") @router.post(  APIRouter
+    const decRe =
+      /@(?:app|router|api|route)\.(get|post|put|delete|patch|options|head)\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    let m: RegExpExecArray | null;
+    while ((m = decRe.exec(content)) !== null) {
+      out.push({
+        method: m[1]!.toUpperCase(),
+        path: m[2]!,
+        file,
+        snippet: this.snip(lines, m.index),
+      });
+    }
+
+    // Flask: @app.route("/x", methods=['GET','POST'])
+    const flaskRe = /@\w+\.route\s*\(\s*["'`]([^"'`]+)["'`]/gi;
+    while ((m = flaskRe.exec(content)) !== null) {
+      const methods = this.flaskMethodsNear(content, m.index);
+      for (const method of methods) {
+        out.push({
+          method,
+          path: m[1]!,
+          file,
+          snippet: this.snip(lines, m.index),
+        });
+      }
+    }
+
+    // Django path() re_path()
+    const djangoPath =
+      /(?:path|re_path)\s*\(\s*["']([^"']+)["']\s*,/g;
+    while ((m = djangoPath.exec(content)) !== null) {
+      out.push({
+        method: "GET",
+        path: m[1]!,
+        file,
+        snippet: this.snip(lines, m.index),
+      });
+    }
+
+    return out.slice(0, 200);
+  }
+
+  private static flaskMethodsNear(content: string, idx: number): string[] {
+    const slice = content.slice(idx, idx + 400);
+    const mm = slice.match(/methods\s*=\s*\[([^\]]+)\]/i);
+    if (!mm) return ["GET"];
+    const raw = mm[1]!;
+    const methods: string[] = [];
+    const part = raw.matchAll(/['"](GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)['"]/gi);
+    for (const x of part) methods.push(x[1]!.toUpperCase());
+    return methods.length ? methods : ["GET"];
+  }
+
+  private static goRoutes(file: string, content: string): PolyglotRoute[] {
+    const out: PolyglotRoute[] = [];
+    const lines = content.split("\n");
+
+    // gin/echo/fiber/chi style: .Get("/path" .POST("/path"
+    const methodPath =
+      /\.(Get|Post|Put|Delete|Patch|Options|Head|Connect|Trace)\s*\(\s*["']([^"']+)["']/gi;
+    let m: RegExpExecArray | null;
+    while ((m = methodPath.exec(content)) !== null) {
+      out.push({
+        method: m[1]!.toUpperCase(),
+        path: m[2]!,
+        file,
+        snippet: this.snip(lines, m.index),
+      });
+    }
+
+    // stdlib
+    const handleFunc = /HandleFunc\s*\(\s*["']([^"']+)["']/gi;
+    while ((m = handleFunc.exec(content)) !== null) {
+      out.push({
+        method: "GET",
+        path: m[1]!,
+        file,
+        snippet: this.snip(lines, m.index),
+      });
+    }
+
+    return out.slice(0, 200);
+  }
+
+  private static pythonDefinitions(content: string): string[] {
+    const defs: string[] = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const t = line.trim();
+      if (/^class\s+[A-Za-z_][\w]*/.test(t)) {
+        defs.push(`Class: ${t.slice(0, 200)}`);
+        continue;
+      }
+      if (/^(async\s+)?def\s+[A-Za-z_][\w]*\s*\(/.test(t)) {
+        defs.push(`Function: ${t.slice(0, 200)}`);
+      }
+    }
+    return defs.slice(0, 80);
+  }
+
+  private static goDefinitions(content: string): string[] {
+    const defs: string[] = [];
+    const funcRe = /^func\s+.+$/gm;
+    let m: RegExpExecArray | null;
+    while ((m = funcRe.exec(content)) !== null) {
+      const line = m[0]!.trim();
+      if (line.length > 8) defs.push(`Func: ${line.slice(0, 220)}`);
+    }
+    const typeRe = /^type\s+\w+\s+(struct|interface)\b.*/gm;
+    while ((m = typeRe.exec(content)) !== null) {
+      defs.push(`Type: ${m[0]!.trim().slice(0, 200)}`);
+    }
+    return defs.slice(0, 80);
+  }
+
+  private static snip(lines: string[], charIndex: number): string | undefined {
+    let pos = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const next = pos + lines[i]!.length + 1;
+      if (charIndex < next) {
+        return lines[i]!.trim().slice(0, 200);
+      }
+      pos = next;
+    }
+    return undefined;
+  }
+}