@ateriss_/aiv-cli 1.0.1 → 1.0.3

package/src/cli/commands/review.ts

@@ -2,12 +2,12 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
 import { resolveConfig, loadRules, getGithubToken, isInitialized } from '../../config';
-import type { ResolvedConfig } from '../../types';
+import type { ResolvedConfig, ReviewResult } from '../../types';
 import { GithubClient } from '../../git/github';
 import { detectRepoInfo } from '../../git/utils';
 import { Orchestrator } from '../../orchestrator';
 import { ContextManager, refreshContextFiles } from '../../context/manager';
-import { renderReview } from '../renderer';
+import { renderReview, buildAivComment } from '../renderer';
 import { selectPR, selectPostReviewAction, confirmMerge, selectMergeStrategy } from '../selector';
 import { t } from '../../i18n';
 
@@ -26,16 +26,16 @@ export interface RunReviewOptions {
 export async function runReview(opts: RunReviewOptions): Promise<void> {
   const { prNumber, owner, repo, config, token } = opts;
   const rules = loadRules();
+  const auto = !opts.agents;
   const activeAgents = opts.agents ?? ['business', 'architecture', 'security'];
+  const client = new GithubClient(token);
 
   console.log(chalk.bold(t().reviewTitle(prNumber)));
   console.log(chalk.dim(`  ${t().reviewAccount(config.github.accountName, config.github.token_env)}\n`));
 
   const fetchSpinner = ora(t().reviewFetching(prNumber, `${owner}/${repo}`)).start();
   let prDiff: Awaited<ReturnType<GithubClient['getPRDiff']>>;
-
   try {
-    const client = new GithubClient(token);
     prDiff = await client.getPRDiff(owner, repo, prNumber);
     fetchSpinner.succeed(t().reviewLoaded(chalk.cyan(prDiff.pr.title), prDiff.files.length));
   } catch (e: any) {
@@ -43,61 +43,112 @@ export async function runReview(opts: RunReviewOptions): Promise<void> {
     return;
   }
 
+  const result = await resolveResult(client, { owner, repo, prNumber }, { config, rules, agents: activeAgents, auto }, prDiff, opts.json);
+  if (!result) return;
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  renderReview(result);
+  if (!process.stdout.isTTY) return;
+
+  const action = await selectPostReviewAction(t().postReviewSelectAction);
+  if (action === 'skip') return;
+
+  if (action === 'post_comment') {
+    await doPostComment(client, owner, repo, prNumber, result);
+    return;
+  }
+
+  const submitted = await doSubmitReview(client, owner, repo, prNumber, action);
+  if (!submitted) return;
+
+  if (action === 'approve') {
+    await doApproveFlow(client, owner, repo, prNumber, result);
+  }
+}
+
+interface RepoRef { owner: string; repo: string; prNumber: number; }
+interface AgentOpts { config: ResolvedConfig; rules: ReturnType<typeof loadRules>; agents: string[]; auto: boolean; }
+
+async function resolveResult(
+  client: GithubClient,
+  ref: RepoRef,
+  agentOpts: AgentOpts,
+  prDiff: Awaited<ReturnType<GithubClient['getPRDiff']>>,
+  json?: boolean,
+): Promise<ReviewResult | null> {
+  const { config, rules, agents: activeAgents, auto } = agentOpts;
+  const { owner, repo, prNumber } = ref;
+  if (!json && process.stdout.isTTY) {
+    const cached = await client.findAivReview(owner, repo, prNumber);
+    if (cached) {
+      console.log(chalk.cyan(`\n  ${t().reviewCachedFound}`));
+      const useCached = await confirmMerge(t().reviewCachedUse);
+      if (useCached) {
+        console.log(chalk.dim(`  ${t().reviewCachedUsing}`));
+        return cached;
+      }
+      console.log(chalk.dim(`  ${t().reviewCachedSkipping}`));
+    }
+  }
+
   const ctxSpinner = ora(t().reviewLoadingContext).start();
   const context = new ContextManager(process.cwd()).buildReviewContext(prDiff);
   ctxSpinner.succeed(t().reviewContextLoaded);
-
   console.log(chalk.dim(t().reviewRunningAgents(activeAgents.join(', '))));
 
   try {
-    const result = await new Orchestrator(config, rules).run(prDiff, context, activeAgents);
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-    renderReview(result);
+    return await new Orchestrator(config, rules).run(prDiff, context, activeAgents, auto);
   } catch (e: any) {
     console.log(chalk.red(t().reviewFailed(e.message)));
-    return;
+    return null;
   }
+}
 
-  if (!process.stdout.isTTY) return;
-
-  const action = await selectPostReviewAction(t().postReviewSelectAction);
-  if (action === 'skip') return;
+async function doPostComment(client: GithubClient, owner: string, repo: string, prNumber: number, result: ReviewResult): Promise<void> {
+  const spinner = ora(t().postReviewPostingComment).start();
+  try {
+    await client.postComment(owner, repo, prNumber, buildAivComment(result));
+    spinner.succeed(chalk.green(t().postReviewCommentPosted(prNumber)));
+  } catch (e: any) {
+    spinner.fail(chalk.red(t().postReviewCommentFailed(e.message)));
+  }
+}
 
+async function doSubmitReview(client: GithubClient, owner: string, repo: string, prNumber: number, action: 'approve' | 'request_changes'): Promise<boolean> {
   const event = action === 'approve' ? 'APPROVE' : 'REQUEST_CHANGES';
-  const submitSpinner = ora(t().postReviewSubmitting).start();
-
+  const spinner = ora(t().postReviewSubmitting).start();
   try {
-    await new GithubClient(token).submitReview(owner, repo, prNumber, event);
-    if (action === 'approve') {
-      submitSpinner.succeed(chalk.green(t().postReviewApproved(prNumber)));
-    } else {
-      submitSpinner.succeed(chalk.yellow(t().postReviewChangesRequested(prNumber)));
-    }
+    await client.submitReview(owner, repo, prNumber, event);
+    const msg = action === 'approve' ? t().postReviewApproved(prNumber) : t().postReviewChangesRequested(prNumber);
+    const color = action === 'approve' ? chalk.green : chalk.yellow;
+    spinner.succeed(color(msg));
+    return true;
   } catch (e: any) {
-    submitSpinner.fail(chalk.red(t().postReviewFailed(e.message)));
-    return;
+    spinner.fail(chalk.red(t().postReviewFailed(e.message)));
+    return false;
   }
+}
 
-  if (action === 'approve') {
-    const wantsMerge = await confirmMerge(t().postReviewMergeConfirm);
-    if (wantsMerge) {
-      const strategy = await selectMergeStrategy(t().postReviewSelectMerge);
-      const mergeSpinner = ora(t().postReviewMerging(prNumber)).start();
-      try {
-        await new GithubClient(token).mergePR(owner, repo, prNumber, strategy);
-        mergeSpinner.succeed(chalk.green(t().postReviewMerged(prNumber)));
-      } catch (e: any) {
-        mergeSpinner.fail(chalk.red(t().postReviewMergeFailed(e.message)));
-      }
+async function doApproveFlow(client: GithubClient, owner: string, repo: string, prNumber: number, result: ReviewResult): Promise<void> {
+  const wantsMerge = await confirmMerge(t().postReviewMergeConfirm);
+  if (wantsMerge) {
+    await doPostComment(client, owner, repo, prNumber, result);
+    const strategy = await selectMergeStrategy(t().postReviewSelectMerge);
+    const mergeSpinner = ora(t().postReviewMerging(prNumber)).start();
+    try {
+      await client.mergePR(owner, repo, prNumber, strategy);
+      mergeSpinner.succeed(chalk.green(t().postReviewMerged(prNumber)));
+    } catch (e: any) {
+      mergeSpinner.fail(chalk.red(t().postReviewMergeFailed(e.message)));
     }
-
-    const refreshSpinner = ora(t().postReviewRefreshing).start();
-    await refreshContextFiles(process.cwd());
-    refreshSpinner.succeed(chalk.green(t().postReviewRefreshed));
   }
+  const refreshSpinner = ora(t().postReviewRefreshing).start();
+  await refreshContextFiles(process.cwd());
+  refreshSpinner.succeed(chalk.green(t().postReviewRefreshed));
 }
 
 // ─── CLI command ──────────────────────────────────────────────────────────────

package/src/cli/renderer.ts

@@ -2,6 +2,67 @@ import chalk from 'chalk';
 import { ReviewResult, AgentFinding } from '../types';
 import { t } from '../i18n';
 
+const SEVERITY_EMOJI: Record<string, string> = {
+  critical: '🔴', high: '🟠', medium: '🟡', low: '🔵', info: '⚪',
+};
+
+const RISK_EMOJI: Record<string, string> = {
+  CRITICAL: '🔴', HIGH: '🟠', MEDIUM: '🟡', LOW: '🟢',
+};
+
+export function buildAivComment(result: ReviewResult): string {
+  const encoded = Buffer.from(JSON.stringify(result)).toString('base64');
+  const header = `<!-- aiv-review:${encoded} -->`;
+
+  const riskEmoji = RISK_EMOJI[result.riskLabel] ?? '⚪';
+  const lines: string[] = [
+    header,
+    '',
+    `## 🤖 aiv Review — PR #${result.prNumber} · ${result.prTitle}`,
+    '',
+    `**Risk Score:** ${riskEmoji} \`${result.riskScore}/100 ${result.riskLabel}\` · Generated: ${result.generatedAt}`,
+    '',
+    '---',
+    '',
+    '### Executive Summary',
+    result.executiveSummary,
+  ];
+
+  if (result.securityIssues.length > 0) {
+    lines.push('', '---', '', '### 🔴 Security Issues');
+    for (const f of result.securityIssues) lines.push(...findingMd(f));
+  }
+  if (result.businessRisks.length > 0) {
+    lines.push('', '---', '', '### 🟡 Business Risks');
+    for (const f of result.businessRisks) lines.push(...findingMd(f));
+  }
+  if (result.architectureIssues.length > 0) {
+    lines.push('', '---', '', '### 🔵 Architecture Issues');
+    for (const f of result.architectureIssues) lines.push(...findingMd(f));
+  }
+  if (result.possibleRegressions.length > 0) {
+    lines.push('', '---', '', '### ⚠️ Possible Regressions');
+    for (const r of result.possibleRegressions) lines.push(`- ${r}`);
+  }
+
+  lines.push('', '---', '', '<details>', '<summary>Agent Summaries</summary>', '');
+  for (const a of result.agents) {
+    lines.push(`**${a.agentName.toUpperCase()}** \`[${a.riskScore}/100]\``, a.summary, '');
+  }
+  lines.push('</details>', '', '---', '*Generated by [aiv](https://www.npmjs.com/package/@ateriss_/aiv-cli)*');
+
+  return lines.join('\n');
+}
+
+function findingMd(f: AgentFinding): string[] {
+  const emoji = SEVERITY_EMOJI[f.severity] ?? '⚪';
+  const out = [`\n**${emoji} [${f.severity.toUpperCase()}] ${f.title}**`];
+  if (f.file) out.push(`\`${f.file}\``);
+  out.push(f.description);
+  if (f.suggestion) out.push(`> 💡 ${f.suggestion}`);
+  return out;
+}
+
 export function renderReview(result: ReviewResult): void {
   const tr = t();
   const riskColor = riskChalk(result.riskLabel);

package/src/cli/selector.ts

@@ -42,7 +42,7 @@ export async function selectPR(prs: PullRequest[], message: string): Promise<Pul
   return selected === CANCEL ? null : (prs.find(pr => pr.number === selected) ?? null);
 }
 
-export type PostReviewAction = 'approve' | 'request_changes' | 'skip';
+export type PostReviewAction = 'approve' | 'request_changes' | 'post_comment' | 'skip';
 export type MergeStrategy = 'merge' | 'squash' | 'rebase';
 
 export async function selectPostReviewAction(message: string): Promise<PostReviewAction> {
@@ -53,12 +53,13 @@ export async function selectPostReviewAction(message: string): Promise<PostRevie
     name: 'action',
     message,
     choices: [
-      { name: chalk.green('✔  Approve PR'),        value: 'approve',          short: 'Approve' },
-      { name: chalk.yellow('⚑  Request Changes'),  value: 'request_changes',  short: 'Request Changes' },
+      { name: chalk.green('✔  Approve PR'),             value: 'approve',          short: 'Approve' },
+      { name: chalk.yellow('⚑  Request Changes'),       value: 'request_changes',  short: 'Request Changes' },
+      { name: chalk.cyan('💬  Post as PR comment'),     value: 'post_comment',     short: 'Post Comment' },
       new inquirer.Separator('─'.repeat(42)),
-      { name: chalk.dim('↩  Skip'),                value: 'skip',             short: 'Skip' },
+      { name: chalk.dim('↩  Skip'),                     value: 'skip',             short: 'Skip' },
     ],
-    pageSize: 4,
+    pageSize: 5,
     loop: false,
   }]);
 
@@ -93,13 +94,65 @@ export async function selectMergeStrategy(message: string): Promise<MergeStrateg
   return answers['strategy'] as MergeStrategy;
 }
 
+export type PrecheckAction = 'create_pr' | 'save_checklist' | 'skip';
+
+export async function selectPrecheckAction(message: string, needsPush: boolean, hasFindings: boolean): Promise<PrecheckAction> {
+  const inquirer = await getInquirer();
+  const prLabel = needsPush
+    ? chalk.cyan('🚀  Push y crear PR en GitHub')
+    : chalk.cyan('🚀  Crear PR en GitHub');
+
+  const checklistChoice = hasFindings
+    ? [{ name: chalk.yellow('📋  Guardar checklist en .aiv/'), value: 'save_checklist', short: 'Guardar Checklist' }]
+    : [];
+
+  const choices = [
+    { name: prLabel, value: 'create_pr', short: 'Crear PR' },
+    ...checklistChoice,
+    new inquirer.Separator('─'.repeat(42)),
+    { name: chalk.dim('↩  Skip'), value: 'skip', short: 'Skip' },
+  ];
+
+  const answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message,
+    choices,
+    pageSize: 4,
+    loop: false,
+  }]);
+  return answers['action'] as PrecheckAction;
+}
+
+export async function promptPRDetails(defaultTitle: string): Promise<{ title: string; body: string }> {
+  const inquirer = await getInquirer();
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'title',
+      message: 'PR title:',
+      default: defaultTitle,
+    },
+    {
+      type: 'input',
+      name: 'body',
+      message: 'PR description (optional, Enter to skip):',
+      default: '',
+    },
+  ]);
+  return {
+    title: answers['title'] as string,
+    body: answers['body'] as string,
+  };
+}
+
 export async function confirmReview(pr: PullRequest, label: string): Promise<boolean> {
   const inquirer = await getInquirer();
 
   const answers = await inquirer.prompt([{
     type: 'confirm',
     name: 'ok',
-    message: `${label} ${chalk.cyan(`#${pr.number}`)} — ${pr.title}?`,
+    message: `${label} ${chalk.cyan('#' + pr.number)} — ${pr.title}?`,
     default: true,
   }]);
 

package/src/context/generator.ts

@@ -3,8 +3,23 @@ import * as path from 'node:path';
 import { LLMProvider } from '../providers/base';
 import { treePath } from '../config';
 
-const IGNORED = new Set(['node_modules', '.git', 'dist', 'build', '.aiv', '.next', 'coverage']);
-const SOURCE_EXT = /\.(ts|js|tsx|jsx|py|go|java|rb|php|cs|rs)$/;
+const IGNORED = new Set(['node_modules', '.git', 'dist', 'build', '.aiv', '.next', 'coverage', '.cache', 'out', '__pycache__']);
+const SOURCE_EXT = /\.(ts|js|tsx|jsx|py|go|java|rb|php|cs|rs|kt|swift)$/;
+const CONFIG_EXT = /\.(json|yaml|yml|toml|env\.example|env\.sample)$/;
+
+const EDITORIAL_HEADER = `<!-- =========================================================
+  aiv context.md — auto-generated by \`aiv context generate\`
+
+  READ THIS FILE and edit it before your first review.
+  The more accurate this file is, the better the AI findings will be.
+
+  Key sections to review:
+    - Business Rules: these directly drive agent findings — add real invariants
+    - Sensitive Zones: add any path that handles money, auth, or PII
+    - Architecture: correct any wrong assumptions about your layer structure
+========================================================= -->
+
+`;
 
 export async function generateContextAndRules(
   cwd: string,
@@ -14,61 +29,98 @@ export async function generateContextAndRules(
 
   const treeFile = treePath(cwd);
   const treeData = fs.existsSync(treeFile)
-    ? fs.readFileSync(treeFile, 'utf8').slice(0, 6000)
+    ? fs.readFileSync(treeFile, 'utf8').slice(0, 10000)
     : '(tree not available — run aiv context refresh first)';
 
-  const pkgInfo  = readPackageJson(cwd);
-  const samples  = readSampleFiles(cwd);
+  const pkgInfo   = readPackageJson(cwd);
+  const readme    = readReadme(cwd);
+  const configs   = readConfigFiles(cwd);
+  const sources   = readSourceFiles(cwd);
 
-  const userMessage = `
-Project name: ${name}
+  const userMessage = `Project name: ${name}
 
-package.json summary:
+## package.json
 ${pkgInfo}
 
-Project file tree (tree.json):
+## README (if present)
+${readme}
+
+## Config files (tsconfig, env.example, etc.)
+${configs}
+
+## Project file tree
 ${treeData}
 
-Sample source files:
-${samples}
-
-Generate context.md and rules.yml suitable for AI PR reviewers for this project.
-Return ONLY valid JSON with exactly these two fields:
-{
-  "context": "<full context.md content as a string>",
-  "rules": "<full rules.yml content as a string>"
-}`;
-
-  const systemPrompt = `You are an expert software architect.
-Given a project's structure, dependencies, and sample code, produce:
-
-1. context.md — Markdown file with these sections:
-   ## Architecture — overall pattern (monorepo, monolith, microservices, layers, etc.)
-   ## Modules — key modules or directories and their responsibilities
-   ## Technologies — main frameworks and libraries in use
-   ## Critical Dependencies — security-sensitive or infrastructure packages
-   ## Sensitive Zones — paths that require extra scrutiny (auth, payments, migrations, etc.)
-   ## Business Rules — inferred invariants the codebase enforces (edit this section after generation)
-   ## System Summary — one paragraph description
-
-2. rules.yml — YAML file with:
-   sensitive_modules: [list of folder/module names that are sensitive]
-   business_rules:
-     <module>:
-       required_calls: [functions that must always be called in this module]
-       required_checks: [validations that must be present]
-       forbidden_patterns: [patterns that must never appear]
-
-Be specific. Infer real module names from the file tree. Do not invent generic placeholders.
-Return ONLY the JSON object — no explanation, no markdown fences.`;
+## Source files sample
+${sources}
+
+Analyze this project thoroughly and generate context.md and rules.yml for AI PR reviewers.
+Return ONLY valid JSON: { "context": "<context.md content>", "rules": "<rules.yml content>" }`;
+
+  const systemPrompt = `You are an expert software architect analyzing a codebase to generate AI reviewer context.
+
+Your output must help AI agents understand:
+1. How the project is structured and what each layer/module does
+2. What business domain it operates in and what invariants must hold
+3. Which parts are security-sensitive or require extra care
+4. What architectural patterns the project follows (so deviations can be flagged)
+
+Generate two files:
+
+### context.md — include ALL of these sections:
+
+## Business Context
+Describe the business domain (e-commerce, fintech, healthcare, SaaS, etc.) and what the system does.
+State the most critical business invariants — rules that must NEVER be violated (e.g., "balances must never go negative", "all payments require an audit log").
+
+## Architecture
+Describe the overall pattern: monolith/microservices/monorepo, layering (handlers → services → repositories), module structure, main data flows.
+Name the layers explicitly so agents can flag violations.
+
+## Modules
+List each significant module/directory with a one-line description of its responsibility.
+
+## Technologies
+Main frameworks, ORMs, auth libraries, messaging systems, etc.
+
+## Critical Dependencies
+Security-sensitive packages (auth, crypto, payments, HTTP clients).
+
+## Sensitive Zones
+Exact file paths or directories that handle: authentication, payments/billing, PII, database migrations, permissions.
+Format as a list: "- src/auth/ — JWT issuance and session management"
+
+## Business Rules
+IMPORTANT: infer real domain rules from the code. Examples:
+- "All mutations in src/payments/ must call auditLog()"
+- "User balance must only be modified via BalanceService, never directly"
+- "Orders cannot transition from COMPLETED to any other state"
+Be specific. Vague rules produce vague findings.
+
+## System Summary
+Two-sentence description of what the system does and who uses it.
+
+### rules.yml — infer real module names and rules:
+
+sensitive_modules: [list actual folder names that are sensitive]
+business_rules:
+  <real_module_name>:
+    required_calls: [actual function names that must be called]
+    required_checks: [actual validation functions/guards]
+    forbidden_patterns: [actual antipatterns found or expected]
+
+Use only real names from the file tree. No generic placeholders like "your-module".
+Return ONLY the JSON object — no markdown fences, no explanation outside the JSON.`;
 
   const response = await provider.complete(
     [{ role: 'user', content: userMessage }],
     systemPrompt,
-    4000,
+    6000,
   );
 
-  return parseResponse(response.content);
+  const result = parseResponse(response.content);
+  result.context = EDITORIAL_HEADER + result.context;
+  return result;
 }
 
 function parseResponse(raw: string): { context: string; rules: string } {
@@ -92,47 +144,91 @@ function readPackageJson(cwd: string): string {
   if (!fs.existsSync(file)) return '(not found)';
   try {
     const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
-    const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).slice(0, 30);
-    return `name: ${pkg.name ?? '?'}\nscripts: ${Object.keys(pkg.scripts ?? {}).join(', ')}\ndependencies: ${deps.join(', ')}`;
+    const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+    return `name: ${pkg.name ?? '?'}\nversion: ${pkg.version ?? '?'}\nscripts: ${Object.keys(pkg.scripts ?? {}).join(', ')}\ndependencies (${deps.length}): ${deps.join(', ')}`;
   } catch {
     return '(unreadable)';
   }
 }
 
-function readSampleFiles(cwd: string): string {
-  const srcRoots = ['src', 'app', 'lib', 'packages', 'modules']
+function readReadme(cwd: string): string {
+  for (const name of ['README.md', 'readme.md', 'README.txt', 'README']) {
+    const file = path.join(cwd, name);
+    if (fs.existsSync(file)) {
+      try { return fs.readFileSync(file, 'utf8').slice(0, 3000); } catch {}
+    }
+  }
+  return '(not found)';
+}
+
+function readConfigFiles(cwd: string): string {
+  const candidates = [
+    'tsconfig.json', 'jsconfig.json',
+    '.env.example', '.env.sample', '.env.template',
+    'docker-compose.yml', 'docker-compose.yaml',
+    'angular.json', 'nest-cli.json', 'vite.config.ts', 'vite.config.js',
+    'next.config.js', 'next.config.ts',
+  ];
+
+  const parts: string[] = [];
+  for (const name of candidates) {
+    const file = path.join(cwd, name);
+    if (!fs.existsSync(file)) continue;
+    try {
+      const content = fs.readFileSync(file, 'utf8').slice(0, 800);
+      parts.push(`--- ${name} ---\n${content}`);
+    } catch {}
+    if (parts.length >= 4) break;
+  }
+  return parts.join('\n\n') || '(none found)';
+}
+
+function readSourceFiles(cwd: string): string {
+  const srcRoots = ['src', 'app', 'lib', 'packages', 'modules', 'server', 'api']
     .map(d => path.join(cwd, d))
     .filter(d => { try { return fs.statSync(d).isDirectory(); } catch { return false; } });
 
   const files: string[] = [];
-  for (const root of srcRoots.slice(0, 2)) {
-    collectSourceFiles(root, files);
-    if (files.length >= 12) break;
+
+  // Prioritize key files: services, controllers, models, auth, guards, interceptors
+  const priority = /\.(service|controller|model|entity|repository|guard|middleware|interceptor|router|handler|resolver)\.(ts|js)$/i;
+
+  for (const root of srcRoots) {
+    collectSourceFiles(root, files, priority);
+  }
+  for (const root of srcRoots) {
+    collectSourceFiles(root, files, null);
+    if (files.length >= 40) break;
   }
 
-  return files.slice(0, 12).map(f => {
+  const unique = [...new Set(files)].slice(0, 40);
+  return unique.map(f => {
     const rel = path.relative(cwd, f);
-    const content = fs.readFileSync(f, 'utf8').slice(0, 400);
+    const content = fs.readFileSync(f, 'utf8').slice(0, 600);
     return `--- ${rel} ---\n${content}`;
-  }).join('\n\n').slice(0, 7000);
+  }).join('\n\n').slice(0, 20000);
 }
 
-function collectSourceFiles(dir: string, out: string[], depth = 0): void {
-  if (depth > 3 || out.length >= 12) return;
+function collectSourceFiles(dir: string, out: string[], filter: RegExp | null, depth = 0): void {
+  if (depth > 5 || out.length >= 40) return;
   let entries: string[];
   try { entries = fs.readdirSync(dir); } catch { return; }
 
   for (const entry of entries) {
     if (IGNORED.has(entry)) continue;
-    const full = path.join(dir, entry);
-    try {
-      const stat = fs.statSync(full);
-      if (stat.isFile() && SOURCE_EXT.test(entry)) {
-        out.push(full);
-      } else if (stat.isDirectory()) {
-        collectSourceFiles(full, out, depth + 1);
-      }
-    } catch {}
-    if (out.length >= 12) break;
+    processEntry(path.join(dir, entry), entry, out, filter, depth);
+    if (out.length >= 40) break;
   }
 }
+
+function processEntry(full: string, name: string, out: string[], filter: RegExp | null, depth: number): void {
+  try {
+    const stat = fs.statSync(full);
+    if (stat.isFile()) {
+      const matches = filter ? filter.test(name) : SOURCE_EXT.test(name);
+      if (matches && !out.includes(full)) out.push(full);
+    } else if (stat.isDirectory()) {
+      collectSourceFiles(full, out, filter, depth + 1);
+    }
+  } catch {}
+}