openreport 0.1.0

package/src/hooks/useReportGeneration.ts

@@ -0,0 +1,199 @@
+import { useState, useEffect, useCallback, useRef, useMemo } from "react";
+import { orchestrate } from "../agents/orchestrator.js";
+import { saveReport } from "../storage/report-store.js";
+import { getErrorMessage } from "../utils/format.js";
+import type { LanguageModelV1 } from "ai";
+import type {
+  AgentStatus,
+  PipelinePhase,
+  FullReport,
+} from "../types/index.js";
+import type { OpenReportConfig } from "../config/schema.js";
+import type { ProgressTracker } from "../pipeline/progress.js";
+
+// ── Public interface ─────────────────────────────────────────────────
+
+export interface UseReportGenerationOptions {
+  projectRoot: string;
+  reportType: string;
+  model: LanguageModelV1;
+  modelId: string;
+  config: OpenReportConfig;
+  generateTodoList?: boolean;
+}
+
+export interface ReportGenerationState {
+  phase: PipelinePhase;
+  phaseDetail: string;
+  agents: AgentStatus[];
+  agentStreams: Record<string, string>;
+  error: string | null;
+  report: FullReport | null;
+  tokens: { input: number; output: number };
+  elapsed: number;
+  startedAt: number;
+}
+
+export interface UseReportGenerationResult extends ReportGenerationState {
+  abort: () => void;
+}
+
+// ── Constants ────────────────────────────────────────────────────────
+
+/** Maximum characters retained per agent stream to prevent unbounded memory growth. */
+const MAX_STREAM_TEXT = 2000;
+
+/** Interval (ms) to flush batched stream updates to React state. */
+const STREAM_FLUSH_INTERVAL = 200;
+
+// ── Hook implementation ──────────────────────────────────────────────
+
+export function useReportGeneration(
+  options: UseReportGenerationOptions
+): UseReportGenerationResult {
+  const { projectRoot, reportType, model, modelId, config, generateTodoList } = options;
+
+  const [phase, setPhase] = useState<PipelinePhase>("scanning");
+  const [phaseDetail, setPhaseDetail] = useState<string>("");
+  const [agents, setAgents] = useState<AgentStatus[]>([]);
+  const [agentStreams, setAgentStreams] = useState<Record<string, string>>({});
+  const [tokens, setTokens] = useState({ input: 0, output: 0 });
+  const [startedAt] = useState(Date.now());
+  const [report, setReport] = useState<FullReport | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [elapsed, setElapsed] = useState(0);
+  const abortControllerRef = useRef(new AbortController());
+  const progressRef = useRef<ProgressTracker | null>(null);
+
+  // Batched stream updates: accumulate deltas in a ref and flush periodically
+  const pendingStreamDeltas = useRef<Record<string, string>>({});
+  const streamFlushTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const abort = useCallback(() => {
+    abortControllerRef.current.abort();
+  }, []);
+
+  // Orchestration logic
+  const startGeneration = useCallback(async () => {
+    try {
+      const result = await orchestrate({
+        projectRoot,
+        reportType,
+        model,
+        modelId,
+        config,
+        generateTodoList: generateTodoList ?? config.features?.todoList ?? false,
+        signal: abortControllerRef.current.signal,
+        onProgress: (progress) => {
+          progressRef.current = progress;
+          progress.on("phaseChange", (p: PipelinePhase) => {
+            setPhase(p);
+            setPhaseDetail("");
+          });
+          progress.on("phaseDetailChange", (detail: string) => setPhaseDetail(detail));
+          progress.on("agentStatusChange", (status: AgentStatus) => {
+            setAgents((prev) => {
+              const existing = prev.findIndex(
+                (a) => a.agentId === status.agentId
+              );
+              if (existing >= 0) {
+                const updated = [...prev];
+                updated[existing] = status;
+                return updated;
+              }
+              return [...prev, status];
+            });
+
+            // Clear stream text when an agent completes
+            if (
+              status.status === "completed" ||
+              status.status === "failed" ||
+              status.status === "skipped"
+            ) {
+              setAgentStreams((prev) => {
+                const next = { ...prev };
+                delete next[status.agentId];
+                return next;
+              });
+            }
+          });
+
+          // Per-agent stream tracking — receives deltas, batches updates every 200ms
+          progress.on("streamText", (delta: string, agentId: string) => {
+            if (!agentId) return;
+            pendingStreamDeltas.current[agentId] =
+              (pendingStreamDeltas.current[agentId] || "") + delta;
+
+            if (!streamFlushTimer.current) {
+              streamFlushTimer.current = setTimeout(() => {
+                const deltas = { ...pendingStreamDeltas.current };
+                pendingStreamDeltas.current = {};
+                streamFlushTimer.current = null;
+
+                setAgentStreams((prev) => {
+                  const next = { ...prev };
+                  for (const [id, d] of Object.entries(deltas)) {
+                    let updated = (next[id] || "") + d;
+                    if (updated.length > MAX_STREAM_TEXT) {
+                      updated = updated.slice(-MAX_STREAM_TEXT);
+                    }
+                    next[id] = updated;
+                  }
+                  return next;
+                });
+              }, STREAM_FLUSH_INTERVAL);
+            }
+          });
+
+          progress.on(
+            "tokenUpdate",
+            (t: { input: number; output: number }) => {
+              setTokens(t);
+            }
+          );
+        },
+      });
+
+      setReport(result.report);
+      await saveReport(projectRoot, result.report);
+    } catch (err: unknown) {
+      if (abortControllerRef.current.signal.aborted) return;
+      setError(getErrorMessage(err));
+    }
+  }, [projectRoot, reportType, model, modelId, config, generateTodoList]);
+
+  // Start generation on mount, abort on unmount
+  useEffect(() => {
+    startGeneration();
+    return () => {
+      abortControllerRef.current.abort();
+      progressRef.current?.removeAllListeners();
+      if (streamFlushTimer.current) {
+        clearTimeout(streamFlushTimer.current);
+        streamFlushTimer.current = null;
+      }
+    };
+  }, []);
+
+  // Timer for elapsed time
+  useEffect(() => {
+    if (report || error) return;
+    const timer = setInterval(() => {
+      setElapsed(Date.now() - startedAt);
+    }, 1000);
+    return () => clearInterval(timer);
+  }, [report, error, startedAt]);
+
+  return {
+    phase,
+    phaseDetail,
+    agents,
+    agentStreams,
+    error,
+    report,
+    tokens,
+    elapsed,
+    startedAt,
+    abort,
+  };
+}

package/src/hooks/useTerminalSize.ts

@@ -0,0 +1,35 @@
+import { useState, useEffect } from "react";
+import { useStdout } from "ink";
+
+interface TerminalSize {
+  columns: number;
+  rows: number;
+}
+
+const DEFAULT_COLUMNS = 80;
+const DEFAULT_ROWS = 24;
+
+export function useTerminalSize(): TerminalSize {
+  const { stdout } = useStdout();
+
+  const [size, setSize] = useState<TerminalSize>({
+    columns: stdout.columns || DEFAULT_COLUMNS,
+    rows: stdout.rows || DEFAULT_ROWS,
+  });
+
+  useEffect(() => {
+    const onResize = () => {
+      setSize({
+        columns: stdout.columns || DEFAULT_COLUMNS,
+        rows: stdout.rows || DEFAULT_ROWS,
+      });
+    };
+
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+
+  return size;
+}

package/src/ingestion/context-selector.ts

@@ -0,0 +1,247 @@
+import type { AgentId, FileTreeNode } from "../types/index.js";
+import { flattenFileTree } from "./file-tree.js";
+
+type ContextStrategy = (files: FileTreeNode[]) => FileTreeNode[];
+
+// Cache for flattenFileTree: avoids re-flattening the same tree reference
+const _flatCache = new WeakMap<FileTreeNode[], FileTreeNode[]>();
+
+function getCachedFlatFileTree(tree: FileTreeNode[]): FileTreeNode[] {
+  let result = _flatCache.get(tree);
+  if (!result) {
+    result = flattenFileTree(tree);
+    _flatCache.set(tree, result);
+  }
+  return result;
+}
+
+const CONFIG_PATTERNS = [
+  /^package\.json$/,
+  /^tsconfig.*\.json$/,
+  /^\.eslintrc/,
+  /^\.prettierrc/,
+  /^next\.config\./,
+  /^vite\.config\./,
+  /^webpack\.config\./,
+  /^nuxt\.config\./,
+  /^tailwind\.config\./,
+  /^postcss\.config\./,
+  /^jest\.config\./,
+  /^vitest\.config\./,
+  /^babel\.config\./,
+  /^docker-compose\./,
+  /^Dockerfile$/,
+  /^\.env\.example$/,
+  /^\.github\//,
+  /^\.gitlab-ci/,
+  /^Makefile$/,
+];
+
+const ENTRY_POINT_PATTERNS = [
+  /^src\/index\./,
+  /^src\/main\./,
+  /^src\/app\./,
+  /^src\/App\./,
+  /^index\./,
+  /^main\./,
+  /^app\//,
+  /^pages\//,
+  /^src\/pages\//,
+  /^src\/routes\//,
+  /^server\./,
+  /^src\/server\./,
+];
+
+const SECURITY_PATTERNS = [
+  /auth/i,
+  /login/i,
+  /session/i,
+  /password/i,
+  /token/i,
+  /crypto/i,
+  /encrypt/i,
+  /middleware/i,
+  /cors/i,
+  /csrf/i,
+  /sanitize/i,
+  /validate/i,
+  /\.env/,
+  /secret/i,
+  /permission/i,
+  /role/i,
+  /guard/i,
+  /policy/i,
+];
+
+const TEST_PATTERNS = [
+  /\.test\./,
+  /\.spec\./,
+  /\/__tests__\//,
+  /\/test\//,
+  /\/tests\//,
+  /\/spec\//,
+  /jest\.config/,
+  /vitest\.config/,
+  /cypress/,
+  /playwright/,
+];
+
+const API_PATTERNS = [
+  /\/api\//,
+  /\/routes\//,
+  /\/controllers\//,
+  /\/handlers\//,
+  /\/endpoints\//,
+  /\/resolvers\//,
+  /\.controller\./,
+  /\.route\./,
+  /\.handler\./,
+  /swagger/i,
+  /openapi/i,
+];
+
+const PERFORMANCE_PATTERNS = [
+  /cache/i,
+  /worker/i,
+  /queue/i,
+  /pool/i,
+  /stream/i,
+  /buffer/i,
+  /lazy/i,
+  /async/i,
+  /batch/i,
+  /index/i,
+  /database/i,
+  /query/i,
+  /migration/i,
+  /orm/i,
+];
+
+function matchesAny(filePath: string, patterns: RegExp[]): boolean {
+  return patterns.some((p) => p.test(filePath));
+}
+
+const STRATEGIES: Record<AgentId, ContextStrategy> = {
+  "architecture-analyst": (files) => {
+    return files.filter(
+      (f) =>
+        matchesAny(f.path, CONFIG_PATTERNS) ||
+        matchesAny(f.path, ENTRY_POINT_PATTERNS) ||
+        f.path.includes("src/") ||
+        f.path.includes("lib/") ||
+        f.path.includes("app/")
+    );
+  },
+
+  "security-auditor": (files) => {
+    return files.filter(
+      (f) =>
+        matchesAny(f.path, SECURITY_PATTERNS) ||
+        matchesAny(f.path, CONFIG_PATTERNS) ||
+        matchesAny(f.path, API_PATTERNS) ||
+        f.path.includes("middleware")
+    );
+  },
+
+  "code-quality-reviewer": (files) => {
+    // All source code, excluding tests and config
+    return files.filter(
+      (f) =>
+        f.language &&
+        !matchesAny(f.path, TEST_PATTERNS) &&
+        !f.path.includes("node_modules")
+    );
+  },
+
+  "dependency-analyzer": (files) => {
+    return files.filter(
+      (f) =>
+        f.name === "package.json" ||
+        f.name === "package-lock.json" ||
+        f.name === "yarn.lock" ||
+        f.name === "bun.lockb" ||
+        f.name === "pnpm-lock.yaml" ||
+        f.name === "requirements.txt" ||
+        f.name === "Pipfile" ||
+        f.name === "Gemfile" ||
+        f.name === "go.mod" ||
+        f.name === "Cargo.toml" ||
+        f.name === "pom.xml" ||
+        f.name === "build.gradle" ||
+        matchesAny(f.path, CONFIG_PATTERNS)
+    );
+  },
+
+  "performance-analyzer": (files) => {
+    return files.filter(
+      (f) =>
+        matchesAny(f.path, PERFORMANCE_PATTERNS) ||
+        matchesAny(f.path, API_PATTERNS) ||
+        matchesAny(f.path, ENTRY_POINT_PATTERNS) ||
+        (f.language &&
+          !matchesAny(f.path, TEST_PATTERNS) &&
+          (f.path.includes("src/") || f.path.includes("lib/")))
+    );
+  },
+
+  "test-coverage-analyst": (files) => {
+    return files.filter(
+      (f) =>
+        matchesAny(f.path, TEST_PATTERNS) ||
+        matchesAny(f.path, CONFIG_PATTERNS) ||
+        f.path.includes(".github/")
+    );
+  },
+
+  "api-documentation": (files) => {
+    return files.filter(
+      (f) =>
+        matchesAny(f.path, API_PATTERNS) ||
+        matchesAny(f.path, CONFIG_PATTERNS) ||
+        f.name.toLowerCase().includes("schema") ||
+        f.name.toLowerCase().includes("type") ||
+        f.path.includes("middleware")
+    );
+  },
+
+  "onboarding-guide": (files) => {
+    return files.filter(
+      (f) =>
+        matchesAny(f.path, CONFIG_PATTERNS) ||
+        matchesAny(f.path, ENTRY_POINT_PATTERNS) ||
+        f.name.toLowerCase() === "readme.md" ||
+        f.name.toLowerCase() === "contributing.md" ||
+        f.name.toLowerCase() === "changelog.md" ||
+        f.path.includes("docs/") ||
+        f.path.includes(".github/")
+    );
+  },
+
+  "todo-generator": () => [],
+};
+
+export function selectContextForAgent(
+  agentId: AgentId,
+  fileTree: FileTreeNode[]
+): FileTreeNode[] {
+  const allFiles = getCachedFlatFileTree(fileTree);
+  const strategy = STRATEGIES[agentId];
+
+  if (!strategy) return allFiles;
+
+  const selected = strategy(allFiles);
+
+  // If too few files selected, fall back to all source files
+  if (selected.length < 3) {
+    return allFiles.filter((f) => f.language);
+  }
+
+  return selected;
+}
+
+export function getRelevantFilePaths(
+  agentId: AgentId,
+  fileTree: FileTreeNode[]
+): string[] {
+  return selectContextForAgent(agentId, fileTree).map((f) => f.path);
+}

package/src/ingestion/file-tree.ts

@@ -0,0 +1,227 @@
+import * as fs from "fs";
+import * as path from "path";
+import type { FileTreeNode } from "../types/index.js";
+import { debugLog } from "../utils/debug.js";
+import { loadGitignore } from "../tools/shared-ignore.js";
+
+const LANGUAGE_MAP: Record<string, string> = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".rb": "ruby",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".swift": "swift",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".c": "c",
+  ".h": "c",
+  ".php": "php",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".less": "less",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".xml": "xml",
+  ".md": "markdown",
+  ".sql": "sql",
+  ".sh": "shell",
+  ".bash": "shell",
+  ".dockerfile": "docker",
+};
+
+const ALWAYS_IGNORE = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "coverage",
+  ".cache",
+  "__pycache__",
+  ".turbo",
+  ".vercel",
+  ".output",
+  ".svelte-kit",
+  ".parcel-cache",
+  "vendor",
+  "target",
+]);
+
+const BINARY_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg", ".webp",
+  ".woff", ".woff2", ".ttf", ".eot", ".otf",
+  ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar",
+  ".exe", ".dll", ".so", ".dylib", ".bin",
+  ".mp3", ".mp4", ".wav", ".avi", ".mov", ".mkv",
+  ".pdf", ".doc", ".docx", ".xls", ".xlsx",
+  ".lock",
+]);
+
+const LARGE_FILE_THRESHOLD = 50_000; // 50KB
+
+export function detectLanguage(filePath: string): string | undefined {
+  const ext = path.extname(filePath).toLowerCase();
+  if (LANGUAGE_MAP[ext]) return LANGUAGE_MAP[ext];
+
+  const basename = path.basename(filePath).toLowerCase();
+  if (basename === "dockerfile") return "docker";
+  if (basename === "makefile") return "make";
+  if (basename === "rakefile") return "ruby";
+  if (basename === "gemfile") return "ruby";
+  if (basename === "cmakelists.txt") return "cmake";
+
+  return undefined;
+}
+
+export interface BuildFileTreeOptions {
+  maxDepth?: number;
+  extraIgnore?: string[];
+  maxFileSize?: number;
+}
+
+export async function buildFileTree(
+  projectRoot: string,
+  options: BuildFileTreeOptions = {}
+): Promise<FileTreeNode[]> {
+  const { maxDepth = 10, extraIgnore = [], maxFileSize = LARGE_FILE_THRESHOLD } = options;
+  const ig = await loadGitignore(projectRoot);
+  if (extraIgnore.length > 0) {
+    ig.add(extraIgnore);
+  }
+
+  async function walk(dir: string, depth: number): Promise<FileTreeNode[]> {
+    if (depth >= maxDepth) return [];
+
+    let entries: fs.Dirent[];
+    try {
+      entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    } catch (e) {
+      debugLog("fileTree:readdir", e);
+      return [];
+    }
+
+    // Separate entries into directories and files after applying skip filters
+    const dirEntries: Array<{ entry: typeof entries[0]; fullPath: string; relativePath: string }> = [];
+    const fileEntries: Array<{ entry: typeof entries[0]; fullPath: string; relativePath: string }> = [];
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(projectRoot, fullPath).replace(/\\/g, "/");
+
+      // Skip always-ignored dirs
+      if (entry.isDirectory() && ALWAYS_IGNORE.has(entry.name)) continue;
+
+      // Skip hidden files (except important dotfiles)
+      if (
+        entry.name.startsWith(".") &&
+        !entry.name.startsWith(".env") &&
+        entry.name !== ".eslintrc.js" &&
+        entry.name !== ".prettierrc"
+      ) {
+        continue;
+      }
+
+      // Check gitignore
+      if (ig.ignores(relativePath)) continue;
+
+      if (entry.isDirectory()) {
+        dirEntries.push({ entry, fullPath, relativePath });
+      } else {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext)) continue;
+        fileEntries.push({ entry, fullPath, relativePath });
+      }
+    }
+
+    // Stat all files in parallel
+    const fileNodes = await Promise.all(
+      fileEntries.map(async ({ entry, fullPath, relativePath }) => {
+        let size: number | undefined;
+        try {
+          const stat = await fs.promises.stat(fullPath);
+          size = stat.size;
+        } catch (e) {
+          debugLog("fileTree:stat", e);
+        }
+        return {
+          name: entry.name,
+          path: relativePath,
+          type: "file" as const,
+          language: detectLanguage(entry.name),
+          size,
+          isLarge: size !== undefined && size > maxFileSize,
+        };
+      })
+    );
+
+    // Recurse into directories in parallel
+    const dirNodes: FileTreeNode[] = await Promise.all(
+      dirEntries.map(async ({ entry, fullPath, relativePath }) => ({
+        name: entry.name,
+        path: relativePath,
+        type: "directory" as const,
+        children: await walk(fullPath, depth + 1),
+      }))
+    );
+
+    const nodes: FileTreeNode[] = [...dirNodes, ...fileNodes];
+
+    return nodes.sort((a, b) => {
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    });
+  }
+
+  return walk(projectRoot, 0);
+}
+
+export function flattenFileTree(nodes: FileTreeNode[]): FileTreeNode[] {
+  const flat: FileTreeNode[] = [];
+  function recurse(list: FileTreeNode[]) {
+    for (const node of list) {
+      if (node.type === "file") {
+        flat.push(node);
+      }
+      if (node.children) {
+        recurse(node.children);
+      }
+    }
+  }
+  recurse(nodes);
+  return flat;
+}
+
+export function fileTreeToString(nodes: FileTreeNode[], prefix = ""): string {
+  const lines: string[] = [];
+  buildTreeLines(nodes, prefix, lines);
+  return lines.join("");
+}
+
+function buildTreeLines(nodes: FileTreeNode[], prefix: string, lines: string[]): void {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    const isLast = i === nodes.length - 1;
+    const connector = isLast ? "└── " : "├── ";
+    const sizeInfo = node.isLarge ? ` (${((node.size || 0) / 1024).toFixed(1)}KB)` : "";
+
+    lines.push(`${prefix}${connector}${node.name}${sizeInfo}\n`);
+
+    if (node.children && node.children.length > 0) {
+      const childPrefix = prefix + (isLast ? "    " : "│   ");
+      buildTreeLines(node.children, childPrefix, lines);
+    }
+  }
+}