openreport 0.1.0

package/src/pipeline/runner.ts

@@ -0,0 +1,526 @@
+import { streamText } from "ai";
+import type { LanguageModelV1 } from "ai";
+import { ProgressTracker } from "./progress.js";
+import { combineReport, countFindings, type CombineOptions } from "./combiner.js";
+import { getAgentById, getAgentsForReportType } from "../agents/registry.js";
+import { buildFileTree, fileTreeToString, flattenFileTree } from "../ingestion/file-tree.js";
+import { getRelevantFilePaths } from "../ingestion/context-selector.js";
+import { detectProject } from "../utils/project-detector.js";
+import { PipelineError } from "../errors.js";
+import { debugLog } from "../utils/debug.js";
+import { getErrorMessage } from "../utils/format.js";
+import type {
+  AgentId,
+  SubReport,
+  FullReport,
+  FileTreeNode,
+  ProjectClassification,
+} from "../types/index.js";
+import type { OpenReportConfig } from "../config/schema.js";
+import { preReadAllFiles, buildContextInfo, type SharedContext } from "./context.js";
+import { createBaseTools, createExtendedTools } from "../tools/index.js";
+import {
+  runOrchestratorAgent,
+  runAgentWithTools,
+  runAgentWithCli,
+  withRetry,
+} from "./agent-runner.js";
+import { extractSubReport } from "./extraction.js";
+import { isCliModel } from "../config/cli-model.js";
+
+export interface RunPipelineOptions {
+  projectRoot: string;
+  reportType: string;
+  model: LanguageModelV1;
+  modelId: string;
+  config: OpenReportConfig;
+  progress: ProgressTracker;
+  signal?: AbortSignal;
+  generateTodoList?: boolean;
+}
+
+// Yield to event loop so React/Ink can render between phases
+const tick = () => new Promise<void>((r) => setTimeout(r, 0));
+
+// ── Phase 1: Scan project ─────────────────────────────────────────────
+
+interface ScanResult {
+  fileTree: FileTreeNode[];
+  fileTreeString: string;
+}
+
+async function scanProject(
+  projectRoot: string,
+  config: OpenReportConfig,
+  progress: ProgressTracker
+): Promise<ScanResult> {
+  progress.setPhase("scanning");
+  await tick();
+
+  const fileTree = await buildFileTree(projectRoot, {
+    maxDepth: config.scan.maxDepth,
+    extraIgnore: config.scan.exclude,
+    maxFileSize: config.scan.maxFileSize,
+  });
+  const fileTreeString = fileTreeToString(fileTree);
+
+  return { fileTree, fileTreeString };
+}
+
+// ── Phase 2: Classify project ─────────────────────────────────────────
+
+interface ClassifyResult {
+  classification: ProjectClassification;
+  projectName: string;
+  applicableAgents: AgentId[];
+}
+
+async function classifyProject(
+  projectRoot: string,
+  reportType: string,
+  progress: ProgressTracker
+): Promise<ClassifyResult> {
+  progress.setPhase("classifying");
+  await tick();
+
+  const classification = await detectProject(projectRoot);
+  const projectName = classification.framework
+    ? `${classification.framework} ${classification.projectType}`
+    : classification.language;
+
+  const agentIds = getAgentsForReportType(reportType);
+  const applicableAgents = agentIds.filter((id) => {
+    const def = getAgentById(id);
+    return def ? def.relevantFor(classification) : false;
+  });
+
+  return { classification, projectName, applicableAgents };
+}
+
+// ── Phase 3: Pre-read project files ───────────────────────────────────
+
+async function preReadFiles(
+  projectRoot: string,
+  applicableAgents: AgentId[],
+  fileTree: FileTreeNode[],
+  fileTreeString: string,
+  classification: ProjectClassification,
+  config: OpenReportConfig,
+  progress: ProgressTracker
+): Promise<SharedContext> {
+  progress.setPhase("pre-reading");
+  await tick();
+
+  const allRelevantPaths = new Set<string>();
+  const agentFilePaths = new Map<string, string[]>();
+  for (const agentId of applicableAgents) {
+    const paths = getRelevantFilePaths(agentId, fileTree);
+    agentFilePaths.set(agentId, paths);
+    for (const p of paths) {
+      allRelevantPaths.add(p);
+    }
+  }
+
+  progress.setPhaseDetail(`${allRelevantPaths.size} unique files for ${applicableAgents.length} agents`);
+  const fileSizes = new Map<string, number>();
+  for (const node of flattenFileTree(fileTree)) {
+    if (node.size !== undefined) {
+      fileSizes.set(node.path, node.size);
+    }
+  }
+  const fileContents = await preReadAllFiles(projectRoot, [...allRelevantPaths], 30, 8000, fileSizes);
+  progress.setPhaseDetail(`${fileContents.size} files loaded, shared across ${applicableAgents.length} agents`);
+  await tick();
+
+  // Create tool instances once, shared across all agents
+  const baseTools = createBaseTools(projectRoot);
+  const extendedTools = createExtendedTools(projectRoot);
+
+  return {
+    classification,
+    fileTreeString,
+    fileTree,
+    fileContents,
+    contextInfo: buildContextInfo(classification, fileTreeString, [...allRelevantPaths]),
+    orchestratorAnalysis: "",
+    baseTools,
+    extendedTools,
+    agentFilePaths,
+  };
+}
+
+// ── Phase 4: Orchestrator global analysis ─────────────────────────────
+
+async function runOrchestrator(
+  model: LanguageModelV1,
+  sharedContext: SharedContext,
+  config: OpenReportConfig,
+  progress: ProgressTracker,
+  signal?: AbortSignal
+): Promise<SharedContext> {
+  progress.setPhase("analyzing");
+  await tick();
+  progress.setPhaseDetail("Producing project overview...");
+
+  const orchestratorAnalysis = await runOrchestratorAgent(
+    model,
+    sharedContext,
+    config,
+    progress,
+    signal
+  );
+  progress.setPhaseDetail(`Done (${orchestratorAnalysis.length} chars)`);
+  await tick();
+
+  return { ...sharedContext, orchestratorAnalysis };
+}
+
+// ── Phase 5: Run agents ───────────────────────────────────────────────
+
+async function executeAgents(
+  applicableAgents: AgentId[],
+  model: LanguageModelV1,
+  projectRoot: string,
+  sharedContext: SharedContext,
+  config: OpenReportConfig,
+  progress: ProgressTracker,
+  signal?: AbortSignal
+): Promise<SubReport[]> {
+  progress.setPhase("running-agents");
+  await tick();
+
+  // Register agents in progress tracker
+  for (const id of applicableAgents) {
+    const def = getAgentById(id);
+    if (def) {
+      progress.registerAgent(id, def.name);
+    }
+  }
+  await tick();
+
+  const useCli = isCliModel(model);
+  const maxConcurrency = config.agents.maxConcurrency;
+
+  // Choose the right runner function based on provider type
+  const runAgent = useCli ? runAgentWithCli : runAgentWithTools;
+
+  // Pool-based concurrency with indexed results for deterministic ordering
+  const results = new Map<string, SubReport>();
+  const executing = new Set<Promise<void>>();
+  for (const agentId of applicableAgents) {
+    if (signal?.aborted) break;
+
+    const p = runAgent(
+      agentId,
+      model,
+      projectRoot,
+      sharedContext,
+      config,
+      progress,
+      signal
+    ).then((result) => {
+      if (result) {
+        results.set(agentId, result);
+      }
+    }).catch((err) => {
+      debugLog("pipeline:agentPool", err);
+    }).finally(() => {
+      executing.delete(p);
+    });
+    executing.add(p);
+
+    if (executing.size >= maxConcurrency) {
+      await Promise.race(executing);
+    }
+  }
+  await Promise.all(executing);
+
+  // Return results in the original agent order
+  const subReports: SubReport[] = [];
+  for (const agentId of applicableAgents) {
+    const report = results.get(agentId);
+    if (report) {
+      subReports.push(report);
+    }
+  }
+  return subReports;
+}
+
+// ── Phase 5.5: Generate todo list from findings ───────────────────────
+
+async function executeTodoAgent(
+  model: LanguageModelV1,
+  subReports: SubReport[],
+  config: OpenReportConfig,
+  progress: ProgressTracker,
+  signal?: AbortSignal
+): Promise<SubReport | null> {
+  const allFindings = subReports.flatMap((r) => r.findings);
+  if (allFindings.length === 0) {
+    debugLog("pipeline:todo", "No findings to generate todo list from, skipping");
+    return null;
+  }
+
+  progress.setPhase("generating-todo");
+  await tick();
+
+  const agentDef = getAgentById("todo-generator");
+  if (!agentDef) {
+    debugLog("pipeline:todo", "todo-generator agent not found in registry");
+    return null;
+  }
+
+  progress.registerAgent("todo-generator", agentDef.name);
+  progress.updateAgentStatus("todo-generator", "running", "Generating todo list...");
+
+  const findingsText = allFindings
+    .map(
+      (f, i) =>
+        `${i + 1}. [${f.severity.toUpperCase()}] (${f.category}) ${f.title}: ${f.description}${f.files?.length ? ` | Files: ${f.files.join(", ")}` : ""}${f.recommendation ? ` | Recommendation: ${f.recommendation}` : ""} | Effort: ${f.effort}`
+    )
+    .join("\n");
+
+  const prompt = `${agentDef.systemPrompt}
+
+## Findings from Analysis (${allFindings.length} total)
+
+${findingsText}
+
+## Instructions
+Generate the prioritized todo list based on these findings. Wrap your entire response in <report> tags with valid JSON matching this structure:
+{
+  "agentId": "todo-generator",
+  "title": "Action Plan & Todo List",
+  "summary": "<brief summary of the action plan>",
+  "sections": [
+    { "heading": "<section title>", "content": "<markdown content>" }
+  ],
+  "findings": []
+}`;
+
+  try {
+    const result = await withRetry(async () => {
+      const response = await streamText({
+        model,
+        prompt,
+        maxSteps: 1,
+        maxTokens: config.agents.maxTokens,
+        temperature: config.agents.temperature,
+        abortSignal: signal,
+      });
+
+      const chunks: string[] = [];
+      for await (const chunk of response.textStream) {
+        chunks.push(chunk);
+        progress.addStreamText(chunk, "todo-generator");
+      }
+      return chunks.join("");
+    });
+
+    const report = extractSubReport("todo-generator", agentDef.name, result, 0);
+    progress.updateAgentStatus("todo-generator", "completed", "Done");
+    return report;
+  } catch (err) {
+    debugLog("pipeline:todo", err);
+    progress.updateAgentStatus("todo-generator", "failed", getErrorMessage(err));
+    return null;
+  }
+}
+
+// ── Phase 6: Generate executive summary ───────────────────────────────
+
+async function generateExecutiveSummary(
+  model: LanguageModelV1,
+  subReports: SubReport[],
+  projectName: string,
+  classification: ProjectClassification,
+  progress: ProgressTracker,
+  signal?: AbortSignal
+): Promise<string> {
+  await tick();
+  progress.setPhase("combining");
+
+  if (subReports.length === 0) {
+    return "Report generation completed.";
+  }
+
+  const allFindings = subReports.flatMap((r) => r.findings);
+  const findingSummary = countFindings(allFindings);
+  progress.setPhaseDetail(`${subReports.length} sub-reports, ${allFindings.length} findings`);
+
+  const summaryPrompt = `You are a senior technical lead writing an executive summary for a code analysis report.
+
+## Project: ${projectName}
+## Classification
+${JSON.stringify(classification, null, 2)}
+
+## Sub-Report Summaries
+${subReports.map((r) => `### ${r.title}\n${r.summary}\n\nKey sections: ${r.sections.map((s) => s.heading).join(", ")}`).join("\n\n")}
+
+## All Findings (${allFindings.length} total)
+${allFindings.map((f) => `- [${f.severity.toUpperCase()}] ${f.title}: ${f.description} (effort: ${f.effort})`).join("\n")}
+
+## Finding Breakdown
+- Critical: ${findingSummary.critical}
+- Warning: ${findingSummary.warning}
+- Info: ${findingSummary.info}
+- Suggestion: ${findingSummary.suggestion}
+
+Write a comprehensive executive summary in markdown with these sections:
+1. **Project Health Overview** - Overall assessment, grade justification
+2. **Key Strengths** - What the project does well
+3. **Critical Issues** - Top priority items requiring immediate attention
+4. **Cross-Cutting Concerns** - Patterns/issues found by multiple analysis angles
+5. **Top Recommendations** - Prioritized action items by impact/effort ratio
+
+Be specific, reference actual findings, and provide actionable insights. Write 4-6 paragraphs.`;
+
+  try {
+    const result = await streamText({
+      model,
+      prompt: summaryPrompt,
+      maxSteps: 1,
+      maxTokens: 2000,
+      temperature: 0.3,
+      abortSignal: signal,
+    });
+
+    const chunks: string[] = [];
+    for await (const chunk of result.textStream) {
+      chunks.push(chunk);
+    }
+    return chunks.join("");
+  } catch (e) {
+    debugLog("pipeline:executiveSummary", e);
+    return "Executive summary generation failed. Please review individual sections below.";
+  }
+}
+
+// ── Phase 7: Combine and save ─────────────────────────────────────────
+
+function combineAndFinalize(
+  projectName: string,
+  projectRoot: string,
+  reportType: string,
+  modelId: string,
+  executiveSummary: string,
+  subReports: SubReport[],
+  progress: ProgressTracker
+): FullReport {
+  progress.setPhase("saving");
+
+  const agentStatuses = progress.getProgress().agents;
+  const totalTokens = progress.getProgress().totalTokens;
+
+  const fullReport = combineReport({
+    projectName,
+    projectPath: projectRoot,
+    reportType,
+    model: modelId,
+    executiveSummary,
+    subReports,
+    agentStatuses,
+    startedAt: progress.getProgress().startedAt,
+    totalTokens,
+  });
+
+  progress.setPhase("done");
+  progress.emit("complete", progress.getProgress());
+
+  return fullReport;
+}
+
+// ── Main pipeline ───────────────────────────────────────────────────────
+
+export async function runPipeline(
+  options: RunPipelineOptions
+): Promise<FullReport> {
+  const { projectRoot, reportType, model, modelId, config, progress, signal, generateTodoList } =
+    options;
+
+  const PIPELINE_TIMEOUT_MS = 10 * 60 * 1000;
+  const timeoutController = new AbortController();
+  const timeoutId = setTimeout(() => timeoutController.abort(), PIPELINE_TIMEOUT_MS);
+
+  const combinedSignal = signal
+    ? AbortSignal.any([signal, timeoutController.signal])
+    : timeoutController.signal;
+
+  try {
+    // Phase 1 & 2: Scan and classify project in parallel
+    const [scanResult, classifyResult] = await Promise.all([
+      scanProject(projectRoot, config, progress),
+      classifyProject(projectRoot, reportType, progress),
+    ]);
+    const { fileTree, fileTreeString } = scanResult;
+    const { classification, projectName, applicableAgents } = classifyResult;
+
+    // Phase 3: Pre-read project files
+    const sharedContext = await preReadFiles(
+      projectRoot,
+      applicableAgents,
+      fileTree,
+      fileTreeString,
+      classification,
+      config,
+      progress
+    );
+
+    // Phase 4: Orchestrator global analysis
+    const fullContext = await runOrchestrator(model, sharedContext, config, progress, combinedSignal);
+
+    // Phase 5: Run agents
+    const subReports = await executeAgents(
+      applicableAgents,
+      model,
+      projectRoot,
+      fullContext,
+      config,
+      progress,
+      combinedSignal
+    );
+
+    if (subReports.length === 0 && applicableAgents.length > 0) {
+      throw new PipelineError(
+        `All ${applicableAgents.length} agents failed to produce results. Check API keys and provider configuration.`
+      );
+    }
+
+    // Phase 5.5: Generate todo list (if enabled)
+    if (generateTodoList) {
+      const todoReport = await executeTodoAgent(
+        model,
+        subReports,
+        config,
+        progress,
+        combinedSignal
+      );
+      if (todoReport) {
+        subReports.push(todoReport);
+      }
+    }
+
+    // Phase 6: Generate executive summary
+    const executiveSummary = await generateExecutiveSummary(
+      model,
+      subReports,
+      projectName,
+      classification,
+      progress,
+      combinedSignal
+    );
+
+    // Phase 7: Combine and finalize
+    return combineAndFinalize(
+      projectName,
+      projectRoot,
+      reportType,
+      modelId,
+      executiveSummary,
+      subReports,
+      progress
+    );
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}