openreport 0.1.0

package/src/config/cli-model.ts

@@ -0,0 +1,397 @@
+import { spawn as spawnChild, execFile } from "child_process";
+import { promisify } from "util";
+import * as os from "os";
+import type {
+  LanguageModelV1,
+  LanguageModelV1CallOptions,
+  LanguageModelV1StreamPart,
+} from "ai";
+import { estimateTokens } from "../ingestion/token-budget.js";
+import { debugLog } from "../utils/debug.js";
+import {
+  CLI_TOOLS,
+  getCliCommand,
+  validateCliCommand,
+  type CliToolDef,
+} from "./cli-detection.js";
+import {
+  buildFullPrompt,
+  processCliOutput,
+  parseToolCalls,
+} from "./cli-prompt-formatter.js";
+
+const execFileAsync = promisify(execFile);
+
+async function resolveWindowsCommand(command: string): Promise<{ cmd: string; args: string[]; needsShell: boolean }> {
+  if (os.platform() !== "win32") {
+    return { cmd: command, args: [], needsShell: false };
+  }
+  try {
+    const { stdout } = await execFileAsync("where.exe", [command], { encoding: "utf-8", timeout: 3000 });
+    const fullPath = stdout.trim().split("\n")[0].trim();
+    if (fullPath.endsWith(".cmd") || fullPath.endsWith(".bat")) {
+      return { cmd: process.env.ComSpec || "cmd.exe", args: ["/c", fullPath], needsShell: false };
+    }
+    return { cmd: fullPath, args: [], needsShell: false };
+  } catch {
+    return { cmd: command, args: [], needsShell: true };
+  }
+}
+
+// ── CLI model marker for provider detection ─────────────────────────────
+
+const cliModels = new WeakSet<LanguageModelV1>();
+
+/** Check whether a LanguageModelV1 was created by `createCliModel`. */
+export function isCliModel(model: LanguageModelV1): boolean {
+  return cliModels.has(model);
+}
+
+// ── Async CLI execution (non-blocking) ──────────────────────────────────
+
+export async function runCliAsync(
+  tool: CliToolDef,
+  fullPrompt: string,
+  model: string | null,
+  signal?: AbortSignal
+): Promise<string> {
+  const command = getCliCommand(tool.id);
+  validateCliCommand(command);
+  const args = tool.buildArgs(model);
+
+  const resolved = await resolveWindowsCommand(command);
+
+  return new Promise((resolve, reject) => {
+    const proc = spawnChild(resolved.cmd, [...resolved.args, ...args], {
+      stdio: ["pipe", "pipe", "pipe"],
+      ...(resolved.needsShell ? { shell: true } : {}),
+    });
+
+    // Propagate abort signal to kill child process
+    const onAbort = () => { proc.kill(); };
+    if (signal) {
+      if (signal.aborted) {
+        proc.kill();
+        reject(new Error("Aborted"));
+        return;
+      }
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+
+    proc.stdin.write(fullPrompt);
+    proc.stdin.end();
+
+    const stdoutChunks: string[] = [];
+    const stderrChunks: string[] = [];
+
+    proc.stdout.on("data", (chunk: Buffer) => {
+      stdoutChunks.push(chunk.toString("utf-8"));
+    });
+
+    proc.stderr.on("data", (chunk: Buffer) => {
+      stderrChunks.push(chunk.toString("utf-8"));
+    });
+
+    proc.on("close", (code) => {
+      signal?.removeEventListener("abort", onAbort);
+      const stderr = stderrChunks.join("");
+      if (code !== 0 && stderr) {
+        reject(new Error(`CLI stderr: ${stderr.slice(0, 500)}`));
+      } else {
+        resolve(stdoutChunks.join("").trim());
+      }
+    });
+
+    proc.on("error", (err) => {
+      signal?.removeEventListener("abort", onAbort);
+      reject(new Error(`CLI error: ${err.message}`));
+    });
+  });
+}
+
+// ── Stream event parsing helpers ─────────────────────────────────────────
+
+interface ParsedStreamEvent {
+  type: "text" | "usage" | "unknown";
+  text?: string;
+  usage?: { input_tokens?: number; output_tokens?: number };
+}
+
+function parseStreamEvent(line: string): ParsedStreamEvent | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  try {
+    const event = JSON.parse(trimmed);
+
+    if (
+      event.type === "stream_event" &&
+      event.event?.delta?.type === "text_delta" &&
+      event.event.delta.text
+    ) {
+      return { type: "text", text: event.event.delta.text };
+    }
+
+    if (event.usage) {
+      return { type: "usage", usage: event.usage };
+    }
+
+    return { type: "unknown" };
+  } catch (e) {
+    debugLog("cli:streamParseChunk", e);
+    return null;
+  }
+}
+
+function processRemainingBuffer(
+  buffer: string,
+  textChunks: string[],
+  controller: ReadableStreamDefaultController<LanguageModelV1StreamPart>,
+  usage: { inputTokens: number; outputTokens: number },
+): void {
+  if (!buffer.trim()) return;
+
+  const parsed = parseStreamEvent(buffer);
+  if (!parsed) return;
+
+  if (parsed.type === "text" && parsed.text) {
+    textChunks.push(parsed.text);
+    controller.enqueue({ type: "text-delta", textDelta: parsed.text });
+  }
+  if (parsed.usage) {
+    if (parsed.usage.input_tokens) usage.inputTokens = parsed.usage.input_tokens;
+    if (parsed.usage.output_tokens) usage.outputTokens = parsed.usage.output_tokens;
+  }
+}
+
+function buildStreamFinishResult(
+  textChunks: string[],
+  usage: { inputTokens: number; outputTokens: number },
+  fullPrompt: string,
+): { finishParts: LanguageModelV1StreamPart[] } {
+  const totalText = textChunks.join("");
+  const toolCalls = parseToolCalls(totalText);
+  const parts: LanguageModelV1StreamPart[] = [];
+
+  if (toolCalls) {
+    for (const tc of toolCalls) {
+      parts.push({
+        type: "tool-call",
+        toolCallType: "function",
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        args: tc.args,
+      });
+    }
+  }
+
+  parts.push({
+    type: "finish",
+    finishReason: toolCalls ? "tool-calls" : "stop",
+    usage: {
+      promptTokens: usage.inputTokens || estimateTokens(fullPrompt),
+      completionTokens: usage.outputTokens || estimateTokens(totalText),
+    },
+  });
+
+  return { finishParts: parts };
+}
+
+// ── Streaming execution for Claude Code ─────────────────────────────────
+
+async function streamClaude(
+  tool: CliToolDef,
+  fullPrompt: string,
+  model: string | null,
+  signal?: AbortSignal
+): Promise<ReadableStream<LanguageModelV1StreamPart>> {
+  const command = getCliCommand(tool.id);
+  validateCliCommand(command);
+  const args = tool.buildStreamArgs(model);
+
+  const resolved = await resolveWindowsCommand(command);
+
+  return new ReadableStream<LanguageModelV1StreamPart>({
+    start(controller) {
+      const proc = spawnChild(resolved.cmd, [...resolved.args, ...args], {
+        stdio: ["pipe", "pipe", "pipe"],
+        ...(resolved.needsShell ? { shell: true } : {}),
+      });
+
+      const onAbort = () => { proc.kill(); };
+      if (signal) {
+        if (signal.aborted) {
+          proc.kill();
+          controller.close();
+          return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+
+      proc.stdin.write(fullPrompt);
+      proc.stdin.end();
+
+      let buffer = "";
+      const textChunks: string[] = [];
+      const usage = { inputTokens: 0, outputTokens: 0 };
+
+      proc.stdout.on("data", (chunk: Buffer) => {
+        buffer += chunk.toString("utf-8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          const parsed = parseStreamEvent(line);
+          if (!parsed) continue;
+
+          if (parsed.type === "text" && parsed.text) {
+            textChunks.push(parsed.text);
+            controller.enqueue({ type: "text-delta", textDelta: parsed.text });
+          }
+          if (parsed.usage) {
+            if (parsed.usage.input_tokens) usage.inputTokens = parsed.usage.input_tokens;
+            if (parsed.usage.output_tokens) usage.outputTokens = parsed.usage.output_tokens;
+          }
+        }
+      });
+
+      let stderrOutput = "";
+      proc.stderr.on("data", (chunk: Buffer) => {
+        stderrOutput += chunk.toString("utf-8");
+      });
+
+      proc.on("close", (code) => {
+        if (code !== 0 && stderrOutput) {
+          debugLog("cli:stderr", stderrOutput.slice(0, 500));
+        }
+        signal?.removeEventListener("abort", onAbort);
+
+        processRemainingBuffer(buffer, textChunks, controller, usage);
+
+        const { finishParts } = buildStreamFinishResult(textChunks, usage, fullPrompt);
+        for (const part of finishParts) {
+          controller.enqueue(part);
+        }
+        controller.close();
+      });
+
+      proc.on("error", (err) => {
+        signal?.removeEventListener("abort", onAbort);
+        controller.error(new Error(`CLI spawn error: ${err.message}`));
+      });
+    },
+  });
+}
+
+// ── LanguageModelV1 implementation ──────────────────────────────────────
+
+export function createCliModel(
+  toolId: string,
+  modelOverride?: string
+): LanguageModelV1 {
+  const tool = CLI_TOOLS.find((t) => t.id === toolId);
+  if (!tool) throw new Error(`Unknown CLI tool: ${toolId}`);
+
+  const modelId = modelOverride || tool.defaultModel;
+
+  const model = {
+    specificationVersion: "v1" as const,
+    provider: tool.id,
+    modelId,
+    defaultObjectGenerationMode: "json" as const,
+
+    async doGenerate(options: LanguageModelV1CallOptions) {
+      const fullPrompt = buildFullPrompt(options);
+
+      // Use async spawn to avoid blocking the event loop
+      const output = await runCliAsync(tool, fullPrompt, modelOverride || null, options.abortSignal);
+
+      const { cleanText, toolCalls } = processCliOutput(output);
+
+      return {
+        text: cleanText || undefined,
+        toolCalls,
+        finishReason: toolCalls
+          ? ("tool-calls" as const)
+          : ("stop" as const),
+        usage: {
+          promptTokens: estimateTokens(fullPrompt),
+          completionTokens: estimateTokens(output),
+        },
+        rawCall: {
+          rawPrompt: fullPrompt,
+          rawSettings: { toolId, modelId },
+        },
+        rawResponse: { headers: {} },
+        warnings: [],
+      };
+    },
+
+    async doStream(options: LanguageModelV1CallOptions) {
+      const fullPrompt = buildFullPrompt(options);
+
+      // Use native streaming for Claude Code
+      if (tool.supportsStreaming && tool.id === "claude-code") {
+        const stream = await streamClaude(tool, fullPrompt, modelOverride || null, options.abortSignal);
+
+        return {
+          stream,
+          rawCall: {
+            rawPrompt: fullPrompt,
+            rawSettings: { toolId, modelId },
+          },
+          rawResponse: { headers: {} },
+          warnings: [],
+        };
+      }
+
+      // Fallback: async execution then emit as single chunk
+      const output = await runCliAsync(tool, fullPrompt, modelOverride || null, options.abortSignal);
+
+      const { cleanText, toolCalls } = processCliOutput(output);
+
+      const stream = new ReadableStream<LanguageModelV1StreamPart>({
+        start(controller) {
+          if (cleanText) {
+            controller.enqueue({ type: "text-delta", textDelta: cleanText });
+          }
+          if (toolCalls) {
+            for (const tc of toolCalls) {
+              controller.enqueue({
+                type: "tool-call",
+                toolCallType: "function",
+                toolCallId: tc.toolCallId,
+                toolName: tc.toolName,
+                args: tc.args,
+              });
+            }
+          }
+          controller.enqueue({
+            type: "finish",
+            finishReason: toolCalls ? "tool-calls" : "stop",
+            usage: {
+              promptTokens: estimateTokens(fullPrompt),
+              completionTokens: estimateTokens(output),
+            },
+          });
+          controller.close();
+        },
+      });
+
+      return {
+        stream,
+        rawCall: {
+          rawPrompt: fullPrompt,
+          rawSettings: { toolId, modelId },
+        },
+        rawResponse: { headers: {} },
+        warnings: [],
+      };
+    },
+  };
+
+  // Mark as CLI model for provider detection (see isCliModel)
+  cliModels.add(model);
+
+  return model;
+}

package/src/config/cli-prompt-formatter.ts

@@ -0,0 +1,129 @@
+import type { LanguageModelV1CallOptions } from "ai";
+import { debugLog } from "../utils/debug.js";
+
+// ── Prompt formatting ───────────────────────────────────────────────────
+
+export function formatUserPrompt(
+  prompt: LanguageModelV1CallOptions["prompt"]
+): string {
+  const parts: string[] = [];
+
+  for (const msg of prompt) {
+    switch (msg.role) {
+      case "system":
+        parts.push(`<system_instructions>\n${msg.content}\n</system_instructions>`);
+        break;
+      case "user":
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            parts.push(part.text);
+          }
+        }
+        break;
+      case "assistant":
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            parts.push(`[Assistant response]\n${part.text}`);
+          }
+        }
+        break;
+      case "tool":
+        for (const part of msg.content) {
+          parts.push(
+            `[Tool result for ${part.toolCallId}]\n${JSON.stringify(part.result)}`
+          );
+        }
+        break;
+    }
+  }
+
+  return parts.join("\n\n");
+}
+
+export function formatToolsForPrompt(
+  mode: LanguageModelV1CallOptions["mode"]
+): string {
+  if (mode.type !== "regular" || !mode.tools || mode.tools.length === 0) {
+    return "";
+  }
+
+  let text = "\n\n<available_tools>\n";
+  text +=
+    "When you need to use a tool, respond ONLY with a JSON block like:\n";
+  text +=
+    '```json\n{"tool_calls": [{"id": "call_1", "name": "toolName", "arguments": {...}}]}\n```\n\n';
+
+  for (const tool of mode.tools) {
+    if (tool.type === "function") {
+      text += `### ${tool.name}\n${tool.description || ""}\nParameters: ${JSON.stringify(tool.parameters)}\n\n`;
+    }
+  }
+
+  text += "</available_tools>\n";
+  return text;
+}
+
+// ── Tool call parsing ────────────────────────────────────────────────────
+
+export type ParsedToolCall = {
+  toolCallType: "function";
+  toolCallId: string;
+  toolName: string;
+  args: string;
+};
+
+export function parseToolCalls(text: string): ParsedToolCall[] | undefined {
+  const jsonMatch = text.match(
+    /```json\s*\n?\s*(\{[\s\S]*?"tool_calls"[\s\S]*?\})\s*\n?\s*```/
+  );
+  if (!jsonMatch) return undefined;
+
+  try {
+    const parsed = JSON.parse(jsonMatch[1]);
+    if (!Array.isArray(parsed.tool_calls)) return undefined;
+
+    return parsed.tool_calls.map(
+      (tc: { id?: string; name: string; arguments: unknown }, i: number) => ({
+        toolCallType: "function" as const,
+        toolCallId: tc.id || `call_${i}`,
+        toolName: tc.name,
+        args: JSON.stringify(tc.arguments || {}),
+      })
+    );
+  } catch (e) {
+    debugLog("cli:parseToolCalls", e);
+    return undefined;
+  }
+}
+
+// ── Shared helpers for doGenerate / doStream ─────────────────────────────
+
+/**
+ * Build the full prompt from SDK call options.
+ * Shared between doGenerate and doStream to avoid duplication.
+ */
+export function buildFullPrompt(options: LanguageModelV1CallOptions): string {
+  const toolsText = formatToolsForPrompt(options.mode);
+  return formatUserPrompt(options.prompt) + toolsText;
+}
+
+/**
+ * Process raw CLI output: parse tool calls and strip the tool_calls JSON block.
+ * Shared between doGenerate and doStream (fallback path).
+ */
+export function processCliOutput(output: string): {
+  cleanText: string;
+  toolCalls: ParsedToolCall[] | undefined;
+} {
+  const toolCalls = parseToolCalls(output);
+  const cleanText = toolCalls
+    ? output
+        .replace(
+          /```json\s*\n?\s*\{[\s\S]*?"tool_calls"[\s\S]*?\}\s*\n?\s*```/,
+          ""
+        )
+        .trim()
+    : output;
+
+  return { cleanText, toolCalls };
+}

package/src/config/defaults.ts

@@ -0,0 +1,79 @@
+import type { OpenReportConfig } from "./schema.js";
+
+export const DEFAULT_CONFIG: OpenReportConfig = {
+  defaultProvider: "claude-code",
+  defaultModel: "sonnet",
+  providers: {},
+  output: {
+    directory: ".openreport/reports",
+    format: "markdown",
+    includeMetadata: true,
+  },
+  agents: {
+    maxConcurrency: 3,
+    maxStepsOverride: {},
+    temperature: 0.3,
+    maxTokens: 8192,
+  },
+  scan: {
+    exclude: [],
+    maxFileSize: 50_000,
+    maxDepth: 10,
+  },
+  ui: {
+    theme: "auto",
+    showTokenCount: true,
+    streamOutput: true,
+  },
+  features: {
+    todoList: false,
+  },
+};
+
+export const REPORT_TYPES = {
+  "full-audit": {
+    id: "full-audit",
+    name: "Full Project Audit",
+    description: "Comprehensive analysis covering all aspects of the project",
+    agents: [
+      "architecture-analyst",
+      "security-auditor",
+      "code-quality-reviewer",
+      "dependency-analyzer",
+      "performance-analyzer",
+      "test-coverage-analyst",
+    ] as const,
+  },
+  "quick-health": {
+    id: "quick-health",
+    name: "Quick Health Check",
+    description: "Fast overview of code quality and dependencies",
+    agents: ["code-quality-reviewer", "dependency-analyzer"] as const,
+  },
+  "security-review": {
+    id: "security-review",
+    name: "Security Review",
+    description: "Focused security audit of the codebase",
+    agents: ["security-auditor", "dependency-analyzer"] as const,
+  },
+  architecture: {
+    id: "architecture",
+    name: "Architecture Documentation",
+    description: "Architecture analysis with diagrams and patterns",
+    agents: ["architecture-analyst"] as const,
+  },
+  dependencies: {
+    id: "dependencies",
+    name: "Dependency Report",
+    description: "Dependency health, vulnerabilities, and licenses",
+    agents: ["dependency-analyzer"] as const,
+  },
+  onboarding: {
+    id: "onboarding",
+    name: "Onboarding Guide",
+    description: "New developer onboarding guide for the project",
+    agents: ["onboarding-guide", "architecture-analyst"] as const,
+  },
+} as const;
+
+export type ReportTypeId = keyof typeof REPORT_TYPES;