openreport 0.1.0

package/src/pipeline/context.ts

@@ -0,0 +1,108 @@
+import { safeReadFileAsync } from "../utils/file-utils.js";
+import * as path from "path";
+import type {
+  FileTreeNode,
+  ProjectClassification,
+} from "../types/index.js";
+import type { BaseTools, ExtendedTools } from "../tools/index.js";
+
+// ── Shared context for all agents ────────────────────────────────────────
+
+export interface SharedContext {
+  classification: ProjectClassification;
+  fileTreeString: string;
+  fileTree: FileTreeNode[];
+  fileContents: Map<string, string>;  // relPath → content (pre-read)
+  contextInfo: string;                // formatted project info
+  orchestratorAnalysis: string;       // global project analysis from orchestrator agent
+  baseTools?: BaseTools;              // pre-created base tools (shared across agents)
+  extendedTools?: ExtendedTools;      // pre-created extended tools (shared across agents)
+  agentFilePaths?: Map<string, string[]>; // agentId → relevant file paths (cached)
+}
+
+// ── Pre-read all files into shared context ──────────────────────────────
+
+export async function preReadAllFiles(
+  projectRoot: string,
+  filePaths: string[],
+  maxFiles: number = 30,
+  maxCharsPerFile: number = 8000,
+  fileSizes?: Map<string, number>
+): Promise<Map<string, string>> {
+  const contents = new Map<string, string>();
+
+  const candidates = filePaths.slice(0, maxFiles * 2);
+
+  const sorted = candidates
+    .map((p) => ({ path: p, size: fileSizes?.get(p) ?? 0 }))
+    .filter((r) => r.size > 0)
+    .sort((a, b) => a.size - b.size)
+    .slice(0, maxFiles);
+
+  // Read all selected files in parallel
+  const readResults = await Promise.all(
+    sorted.map(async ({ path: relPath }) => {
+      const content = await safeReadFileAsync(path.join(projectRoot, relPath));
+      return { path: relPath, content };
+    })
+  );
+  for (const { path: relPath, content } of readResults) {
+    if (content) {
+      if (content.length > maxCharsPerFile) {
+        const newlineIdx = content.lastIndexOf('\n', maxCharsPerFile);
+        const cutoff = newlineIdx > 0 ? newlineIdx : maxCharsPerFile;
+        contents.set(relPath, content.slice(0, cutoff) + "\n... (truncated)");
+      } else {
+        contents.set(relPath, content);
+      }
+    }
+  }
+  return contents;
+}
+
+// ── Build formatted context info string ─────────────────────────────────
+
+export function buildContextInfo(
+  classification: ProjectClassification,
+  fileTreeString: string,
+  relevantFiles: string[]
+): string {
+  return `
+## Project Info
+- Language: ${classification.language}
+- Framework: ${classification.framework || "none"}
+- Type: ${classification.projectType}
+- Build Tool: ${classification.buildTool || "none"}
+- Package Manager: ${classification.packageManager || "unknown"}
+- Has Tests: ${classification.hasTests}
+- Has CI: ${classification.hasCI}
+
+## File Tree
+${fileTreeString}
+
+## Relevant Files for Analysis
+${relevantFiles.slice(0, 50).join("\n")}
+`;
+}
+
+// ── Build pre-loaded file content block for agent prompts ───────────────
+
+export function buildFileContentBlock(
+  sharedContext: SharedContext,
+  agentRelevantPaths: string[]
+): string {
+  const parts: string[] = [];
+  for (const relPath of agentRelevantPaths) {
+    const content = sharedContext.fileContents.get(relPath);
+    if (content) {
+      parts.push(`### ${relPath}\n\`\`\`\n${content}\n\`\`\``);
+    }
+  }
+  if (parts.length === 0) return "";
+
+  return `## Pre-loaded Source Files (${parts.length} files)
+> IMPORTANT: These files have already been read for you. Do NOT re-read them with tools.
+> Only use readFile/glob/grep for files NOT listed below.
+
+${parts.join("\n\n")}`;
+}

package/src/pipeline/extraction.ts

@@ -0,0 +1,153 @@
+import { SubReportSchema } from "../schemas/report.js";
+import {
+  normalizeSeverity as normalizeSeverityStr,
+  normalizeEffort as normalizeEffortStr,
+} from "../schemas/findings.js";
+import { ExtractionError } from "../errors.js";
+import { debugLog } from "../utils/debug.js";
+import type { AgentId, SubReport } from "../types/index.js";
+
+interface RawSection {
+  heading?: string;
+  content?: string;
+  [key: string]: unknown;
+}
+
+interface RawFinding {
+  id?: string;
+  severity?: string;
+  category?: string;
+  title?: string;
+  description?: string;
+  files?: string[];
+  recommendation?: string;
+  effort?: string;
+  codeSnippet?: string;
+  [key: string]: unknown;
+}
+
+// ── Value normalization (delegates to canonical functions in findings.ts) ──
+
+export function normalizeSeverity(value: unknown): "critical" | "warning" | "info" | "suggestion" {
+  return normalizeSeverityStr(String(value || "info"));
+}
+
+export function normalizeEffort(value: unknown): "low" | "medium" | "high" {
+  return normalizeEffortStr(String(value || "medium"));
+}
+
+// ── JSON extraction from agent output ───────────────────────────────────
+
+export function extractJsonFromText(text: string): string | null {
+  // Strategy 1: Find the LAST <report>...</report> block (greedy from end)
+  const lastOpen = text.lastIndexOf("<report>");
+  const lastClose = text.lastIndexOf("</report>");
+  if (lastOpen >= 0 && lastClose > lastOpen) {
+    let json = text.substring(lastOpen + "<report>".length, lastClose).trim();
+    // Strip code block markers if agent wrapped JSON in ```json ... ```
+    json = json.replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "").trim();
+    return json;
+  }
+
+  // Strategy 2: Find a JSON object containing "sections" key
+  const jsonMatch = text.match(/\{[\s\S]*"sections"\s*:\s*\[[\s\S]*\][\s\S]*\}/);
+  if (jsonMatch) {
+    return jsonMatch[0];
+  }
+
+  return null;
+}
+
+// ── Sub-report extraction with multi-fallback ───────────────────────────
+
+export function extractSubReport(
+  agentId: AgentId,
+  agentName: string,
+  text: string,
+  filesAnalyzed: number,
+  usage?: { promptTokens: number; completionTokens: number }
+): SubReport {
+  const makeMeta = () => ({
+    filesAnalyzed,
+    tokensUsed: {
+      input: usage?.promptTokens || 0,
+      output: usage?.completionTokens || 0,
+    },
+    duration: 0,
+  });
+
+  const jsonStr = extractJsonFromText(text);
+
+  if (jsonStr) {
+    // Try strict Zod parse first
+    try {
+      const parsed = JSON.parse(jsonStr);
+      return SubReportSchema.parse({
+        ...parsed,
+        agentId,
+        agentName,
+        metadata: makeMeta(),
+      });
+    } catch (e) {
+      debugLog("pipeline:strictParse", new ExtractionError(
+        `Strict parse failed for agent ${agentId}: ${e instanceof Error ? e.message : String(e)}`
+      ));
+    }
+
+    // Try lenient manual parse
+    try {
+      const parsed = JSON.parse(jsonStr);
+      const sections = Array.isArray(parsed.sections)
+        ? parsed.sections
+            .filter((s: RawSection) => s && typeof s.heading === "string" && typeof s.content === "string")
+            .map((s: RawSection) => ({ heading: String(s.heading), content: String(s.content) }))
+        : [];
+      const findings = Array.isArray(parsed.findings)
+        ? parsed.findings
+            .filter((f: RawFinding) => f && typeof f.title === "string")
+            .map((f: RawFinding) => ({
+              id: String(f.id || `${agentId}-${Math.random().toString(36).slice(2, 6)}`),
+              severity: normalizeSeverity(f.severity),
+              category: String(f.category || "general"),
+              title: String(f.title),
+              description: String(f.description || ""),
+              files: Array.isArray(f.files) ? f.files.map(String) : [],
+              recommendation: String(f.recommendation || ""),
+              effort: normalizeEffort(f.effort),
+              ...(f.codeSnippet ? { codeSnippet: String(f.codeSnippet) } : {}),
+            }))
+        : [];
+
+      return {
+        agentId,
+        agentName,
+        title: String(parsed.title || agentName),
+        summary: String(parsed.summary || "Analysis completed"),
+        sections: sections.length > 0 ? sections : [{ heading: "Analysis", content: String(parsed.summary || "Analysis completed") }],
+        findings,
+        metadata: makeMeta(),
+      };
+    } catch (e) {
+      debugLog("pipeline:lenientParse", new ExtractionError(
+        `Lenient parse failed for agent ${agentId}: ${e instanceof Error ? e.message : String(e)}`
+      ));
+    }
+  } else {
+    // No <report> block found in output, falling through to fallback
+  }
+
+  // Fallback: strip the <report> JSON from content so it doesn't render as text
+  const cleanText = text
+    .replace(/<report>[\s\S]*?<\/report>/g, "")
+    .trim();
+
+  return {
+    agentId,
+    agentName,
+    title: agentName,
+    summary: "Analysis completed",
+    sections: [{ heading: "Analysis", content: cleanText || "No structured output was produced." }],
+    findings: [],
+    metadata: makeMeta(),
+  };
+}

package/src/pipeline/progress.ts

@@ -0,0 +1,192 @@
+import { EventEmitter } from "events";
+import type {
+  AgentId,
+  AgentStatus,
+  AgentRunStatus,
+  PipelinePhase,
+  PipelineProgress,
+} from "../types/index.js";
+
+/** Maximum characters retained per agent stream to prevent unbounded memory growth. */
+const MAX_STREAM_TEXT = 2000;
+
+// ── Typed EventEmitter ─────────────────────────────────────────────────
+// Maps each event name to its listener signature. This ensures that
+// .on(), .emit(), and .off() calls are statically checked.
+
+export type ProgressEventMap = {
+  phaseChange: [phase: PipelinePhase];
+  phaseDetailChange: [detail: string];
+  agentStatusChange: [status: AgentStatus];
+  streamText: [text: string, agentId: AgentId];
+  tokenUpdate: [tokens: { input: number; output: number }];
+  warning: [message: string];
+  complete: [progress: PipelineProgress];
+};
+
+/**
+ * A thin typed wrapper around Node's EventEmitter.
+ * Constrains `on`, `off`, `once`, and `emit` to the keys / signatures
+ * declared in the supplied event map `T`, where each value is a tuple
+ * of the event's argument types.
+ */
+interface ITypedEmitter<T extends Record<string, unknown[]>> {
+  on<K extends keyof T & string>(event: K, listener: (...args: T[K]) => void): this;
+  off<K extends keyof T & string>(event: K, listener: (...args: T[K]) => void): this;
+  once<K extends keyof T & string>(event: K, listener: (...args: T[K]) => void): this;
+  emit<K extends keyof T & string>(event: K, ...args: T[K]): boolean;
+}
+
+// Re-export EventEmitter cast through the typed interface so that
+// ProgressTracker inherits the real implementation while exposing
+// only the type-safe signatures to consumers.
+const TypedEventEmitter = EventEmitter as {
+  new <T extends Record<string, unknown[]>>(): ITypedEmitter<T> & EventEmitter;
+};
+
+export class ProgressTracker extends TypedEventEmitter<ProgressEventMap> {
+  private agents: Map<AgentId, AgentStatus> = new Map();
+  private phase: PipelinePhase = "scanning";
+  private phaseDetail = "";
+  private totalTokens = { input: 0, output: 0 };
+  private previousTokens: Map<AgentId, { input: number; output: number }> = new Map();
+  private startedAt: Date = new Date();
+  private currentStreamText = "";
+  private agentStreamTexts: Map<AgentId, string> = new Map();
+
+  setPhase(phase: PipelinePhase): void {
+    this.phase = phase;
+    this.phaseDetail = "";
+    this.emit("phaseChange", phase);
+  }
+
+  setPhaseDetail(detail: string): void {
+    this.phaseDetail = detail;
+    this.emit("phaseDetailChange", detail);
+  }
+
+  registerAgent(agentId: AgentId, agentName: string): void {
+    const status: AgentStatus = {
+      agentId,
+      agentName,
+      status: "pending",
+    };
+    this.agents.set(agentId, status);
+    this.emit("agentStatusChange", status);
+  }
+
+  updateAgentStatus(
+    agentId: AgentId,
+    status: AgentRunStatus,
+    message?: string
+  ): void {
+    const agent = this.agents.get(agentId);
+    if (!agent) return;
+
+    agent.status = status;
+    if (message) agent.statusMessage = message;
+
+    if (status === "running" && !agent.startedAt) {
+      agent.startedAt = new Date();
+    }
+    if (status === "completed" || status === "failed") {
+      agent.completedAt = new Date();
+    }
+
+    this.agents.set(agentId, agent);
+    this.emit("agentStatusChange", { ...agent });
+  }
+
+  setAgentError(agentId: AgentId, error: string): void {
+    const agent = this.agents.get(agentId);
+    if (!agent) return;
+
+    agent.status = "failed";
+    agent.error = error;
+    agent.completedAt = new Date();
+    this.agents.set(agentId, agent);
+    this.emit("agentStatusChange", { ...agent });
+  }
+
+  updateAgentTokens(
+    agentId: AgentId,
+    tokens: { input: number; output: number }
+  ): void {
+    const agent = this.agents.get(agentId);
+    if (!agent) return;
+
+    agent.tokensUsed = tokens;
+    this.agents.set(agentId, agent);
+
+    // O(1) delta update: subtract previous values, add new ones
+    const prev = this.previousTokens.get(agentId) || { input: 0, output: 0 };
+    this.totalTokens.input += tokens.input - prev.input;
+    this.totalTokens.output += tokens.output - prev.output;
+    this.previousTokens.set(agentId, { input: tokens.input, output: tokens.output });
+
+    this.emit("tokenUpdate", { ...this.totalTokens });
+  }
+
+  addStreamText(delta: string, agentId: AgentId): void {
+    const existing = this.agentStreamTexts.get(agentId) || "";
+    let updated = existing + delta;
+    if (updated.length > MAX_STREAM_TEXT) {
+      updated = updated.slice(-MAX_STREAM_TEXT);
+    }
+    this.agentStreamTexts.set(agentId, updated);
+    this.currentStreamText = updated;
+    this.emit("streamText", delta, agentId);
+  }
+
+  getProgress(): PipelineProgress {
+    const agents = Array.from(this.agents.values());
+    const completed = agents.filter(
+      (a) => a.status === "completed" || a.status === "failed"
+    ).length;
+    const total = agents.length;
+
+    let estimatedTimeRemaining: number | undefined;
+    if (completed > 0 && completed < total) {
+      const elapsed = Date.now() - this.startedAt.getTime();
+      const avgTimePerAgent = elapsed / completed;
+      estimatedTimeRemaining = Math.round(
+        avgTimePerAgent * (total - completed) / 1000
+      );
+    }
+
+    return {
+      phase: this.phase,
+      phaseDetail: this.phaseDetail || undefined,
+      agents,
+      totalTokens: { ...this.totalTokens },
+      startedAt: this.startedAt,
+      estimatedTimeRemaining,
+      currentStreamText: this.currentStreamText,
+    };
+  }
+
+  getCompletionPercentage(): number {
+    const agents = Array.from(this.agents.values());
+    if (agents.length === 0) return 0;
+
+    const completed = agents.filter(
+      (a) =>
+        a.status === "completed" ||
+        a.status === "failed" ||
+        a.status === "skipped"
+    ).length;
+
+    return Math.round((completed / agents.length) * 100);
+  }
+
+  reset(): void {
+    this.agents.clear();
+    this.phase = "scanning";
+    this.phaseDetail = "";
+    this.totalTokens = { input: 0, output: 0 };
+    this.previousTokens.clear();
+    this.startedAt = new Date();
+    this.currentStreamText = "";
+    this.agentStreamTexts.clear();
+  }
+}