openreport 0.1.0

package/src/report/md-to-html.ts

@@ -0,0 +1,153 @@
+const HTML_ESC_MAP: Record<string, string> = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+
+export function esc(str: string): string {
+  return str.replace(/[&<>"']/g, (c) => HTML_ESC_MAP[c] ?? c);
+}
+
+/** Minimal markdown-to-HTML for section content — line-based state machine */
+export function mdToHtml(text: string): string {
+  const lines = text.split("\n");
+  const out: string[] = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Skip blank lines
+    if (!trimmed) { i++; continue; }
+
+    // Code block (fenced)
+    if (trimmed.startsWith("```")) {
+      const lang = trimmed.slice(3).trim();
+      const codeLines: string[] = [];
+      i++;
+      while (i < lines.length && !lines[i].trim().startsWith("```")) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      i++; // skip closing ```
+      out.push(`<pre><code${lang ? ` class="lang-${esc(lang)}"` : ""}>${esc(codeLines.join("\n"))}</code></pre>`);
+      continue;
+    }
+
+    // Heading
+    const hMatch = trimmed.match(/^(#{1,4})\s+(.+)/);
+    if (hMatch) {
+      const level = Math.min(hMatch[1].length + 2, 6);
+      out.push(`<h${level}>${inlineFormat(hMatch[2])}</h${level}>`);
+      i++;
+      continue;
+    }
+
+    // Table: line starts with |, and next line is a separator (|---|)
+    if (trimmed.startsWith("|") && i + 1 < lines.length && /^\|[\s-:|]+\|$/.test(lines[i + 1].trim())) {
+      const tableLines: string[] = [trimmed];
+      i++;
+      while (i < lines.length && lines[i].trim().startsWith("|")) {
+        tableLines.push(lines[i].trim());
+        i++;
+      }
+      out.push(renderTable(tableLines.join("\n")));
+      continue;
+    }
+
+    // Checkbox list (- [ ] or - [x])
+    if (/^[-*]\s\[[ xX]\]\s/.test(trimmed)) {
+      const items: string[] = [];
+      while (i < lines.length && /^[-*]\s\[[ xX]\]\s/.test(lines[i].trim())) {
+        items.push(lines[i].trim());
+        i++;
+      }
+      out.push(`<ul class="checklist">${items.map((t) => {
+        const checked = /^[-*]\s\[[xX]\]/.test(t);
+        const text = t.replace(/^[-*]\s\[[ xX]\]\s+/, "");
+        return `<li class="checklist-item${checked ? " checked" : ""}" onclick="toggleCheck(this)"><span class="checkbox${checked ? " checkbox-checked" : ""}">${checked ? "&#10003;" : ""}</span><span class="checklist-text">${inlineFormat(text)}</span></li>`;
+      }).join("")}</ul>`);
+      continue;
+    }
+
+    // Unordered list
+    if (/^[-*]\s/.test(trimmed)) {
+      const items: string[] = [];
+      while (i < lines.length && /^[-*]\s/.test(lines[i].trim())) {
+        items.push(lines[i].trim().replace(/^[-*]\s+/, ""));
+        i++;
+      }
+      out.push(`<ul>${items.map((t) => `<li>${inlineFormat(t)}</li>`).join("")}</ul>`);
+      continue;
+    }
+
+    // Ordered list
+    if (/^\d+\.\s/.test(trimmed)) {
+      const items: string[] = [];
+      while (i < lines.length && /^\d+\.\s/.test(lines[i].trim())) {
+        items.push(lines[i].trim().replace(/^\d+\.\s+/, ""));
+        i++;
+      }
+      out.push(`<ol>${items.map((t) => `<li>${inlineFormat(t)}</li>`).join("")}</ol>`);
+      continue;
+    }
+
+    // Paragraph: collect consecutive non-blank, non-special lines
+    const paraLines: string[] = [trimmed];
+    i++;
+    while (i < lines.length) {
+      const next = lines[i].trim();
+      if (!next || next.startsWith("```") || next.startsWith("#") || next.startsWith("|") || /^[-*]\s/.test(next) || /^\d+\.\s/.test(next)) break;
+      paraLines.push(next);
+      i++;
+    }
+    out.push(`<p>${inlineFormat(paraLines.join(" "))}</p>`);
+  }
+
+  return out.join("\n");
+}
+
+export function isSafeUrl(url: string): boolean {
+  const decoded = url.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').trim();
+  const scheme = decoded.toLowerCase().split(":")[0];
+  if (!decoded.includes(":")) return true; // relative URLs are safe
+  return scheme === "http" || scheme === "https" || scheme === "mailto";
+}
+
+function inlineFormat(text: string): string {
+  return esc(text)
+    .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
+    .replace(/\*(.+?)\*/g, "<em>$1</em>")
+    .replace(/`([^`]+)`/g, '<code class="inline">$1</code>')
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, label, url) => {
+      if (isSafeUrl(url)) {
+        return `<a href="${esc(url)}">${label}</a>`;
+      }
+      return label;
+    });
+}
+
+function renderTable(text: string): string {
+  const rows = text
+    .split("\n")
+    .map((r) => r.trim())
+    .filter(Boolean);
+  if (rows.length < 2) return `<p>${esc(text)}</p>`;
+
+  const parseRow = (row: string) =>
+    row
+      .split("|")
+      .map((c) => c.trim())
+      .filter(Boolean);
+
+  const headers = parseRow(rows[0]);
+  const bodyRows = rows.slice(2).map(parseRow); // skip separator
+
+  return `<div class="table-wrap"><table>
+<thead><tr>${headers.map((h) => `<th>${inlineFormat(h)}</th>`).join("")}</tr></thead>
+<tbody>${bodyRows.map((cells) => `<tr>${cells.map((c) => `<td>${inlineFormat(c)}</td>`).join("")}</tr>`).join("")}</tbody>
+</table></div>`;
+}

package/src/report/open-browser.ts

@@ -0,0 +1,22 @@
+import { spawn } from "child_process";
+import * as os from "os";
+import { debugLog } from "../utils/debug.js";
+
+const SAFE_PATH = /^[a-zA-Z0-9_\-./\\: ]+$/;
+
+export function openInBrowser(filePath: string): void {
+  if (!SAFE_PATH.test(filePath)) return;
+
+  const platform = os.platform();
+
+  let child;
+  if (platform === "win32") {
+    child = spawn("cmd", ["/c", "start", "", filePath], { shell: false });
+  } else if (platform === "darwin") {
+    child = spawn("open", [filePath]);
+  } else {
+    child = spawn("xdg-open", [filePath]);
+  }
+
+  child.on("error", (err) => debugLog("browser:open", `Failed to open browser: ${err.message}`));
+}

package/src/schemas/findings.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+// ── Normalization functions ─────────────────────────────────────────────
+
+export function normalizeSeverity(s: string): "critical" | "warning" | "info" | "suggestion" {
+  const lower = s.toLowerCase().trim();
+  if (["critical", "error", "high", "severe"].includes(lower)) return "critical";
+  if (["warning", "warn", "medium", "moderate"].includes(lower)) return "warning";
+  if (["info", "information", "low", "note"].includes(lower)) return "info";
+  if (["suggestion", "hint", "improvement", "enhancement"].includes(lower)) return "suggestion";
+  return "info";
+}
+
+export function normalizeEffort(s: string): "low" | "medium" | "high" {
+  const lower = s.toLowerCase().trim();
+  if (["low", "easy", "trivial", "simple"].includes(lower)) return "low";
+  if (["high", "hard", "complex", "difficult"].includes(lower)) return "high";
+  return "medium";
+}
+
+// Accept any string for category — AI agents produce varied labels
+export const CategorySchema = z.string();
+
+export const FindingSchema = z.object({
+  id: z.string(),
+  severity: z.string().transform(normalizeSeverity),
+  category: CategorySchema,
+  title: z.string(),
+  description: z.string(),
+  files: z.array(z.string()).default([]),
+  recommendation: z.string().default(""),
+  effort: z.string().transform(normalizeEffort).default("medium"),
+  codeSnippet: z.string().optional(),
+});
+
+export const SEVERITY_ORDER: Record<string, number> = { critical: 0, warning: 1, info: 2, suggestion: 3 };
+
+export const SEVERITY_EMOJI: Record<string, string> = {
+  critical: "\u{1F534}",
+  warning: "\u{1F7E0}",
+  info: "\u{1F535}",
+  suggestion: "\u{1F4A1}",
+};
+
+export type Severity = "critical" | "warning" | "info" | "suggestion";
+export type Effort = "low" | "medium" | "high";
+export type Category = z.infer<typeof CategorySchema>;
+export type Finding = z.infer<typeof FindingSchema>;

package/src/schemas/report.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { FindingSchema } from "./findings.js";
+
+export { FindingSchema } from "./findings.js";
+
+export const SubReportSchema = z.object({
+  agentId: z.string(),
+  agentName: z.string(),
+  title: z.string(),
+  summary: z.string(),
+  sections: z.array(
+    z.object({
+      heading: z.string(),
+      content: z.string(),
+    })
+  ),
+  findings: z.array(FindingSchema),
+  metadata: z
+    .object({
+      filesAnalyzed: z.number().default(0),
+      tokensUsed: z
+        .object({ input: z.number(), output: z.number() })
+        .default({ input: 0, output: 0 }),
+      duration: z.number().default(0),
+    })
+    .default({}),
+});
+
+export const FindingSummarySchema = z.object({
+  critical: z.number().default(0),
+  warning: z.number().default(0),
+  info: z.number().default(0),
+  suggestion: z.number().default(0),
+});
+
+export const ReportMetadataSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  projectName: z.string(),
+  projectPath: z.string(),
+  createdAt: z.string(),
+  duration: z.number(),
+  model: z.string(),
+  tokens: z.object({ input: z.number(), output: z.number() }),
+  agentStatuses: z.array(
+    z.object({
+      agentId: z.string(),
+      status: z.enum(["completed", "failed", "skipped"]),
+      duration: z.number().optional(),
+    })
+  ),
+  grade: z.string().optional(),
+  sections: z.array(z.string()),
+});
+
+export const FullReportSchema = z.object({
+  metadata: ReportMetadataSchema,
+  executiveSummary: z.string(),
+  findingSummary: FindingSummarySchema,
+  subReports: z.array(SubReportSchema),
+  allFindings: z.array(FindingSchema).optional(),
+  markdownContent: z.string(),
+});
+

package/src/screens/ConfigScreen.tsx

@@ -0,0 +1,271 @@
+import React, { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import Spinner from "ink-spinner";
+import { Header } from "../components/layout/Header.js";
+import { Footer } from "../components/layout/Footer.js";
+import { Container } from "../components/layout/Container.js";
+import {
+  detectInstalledClis,
+  type DetectedCli,
+} from "../config/cli-detection.js";
+import { useTerminalSize } from "../hooks/useTerminalSize.js";
+import type { OpenReportConfig } from "../config/schema.js";
+import type { Screen } from "../types/index.js";
+
+export interface ConfigChanges {
+  defaultProvider: string;
+  defaultModel: string;
+  maxConcurrency: number;
+  temperature: number;
+  todoList: boolean;
+}
+
+interface ConfigScreenProps {
+  config: OpenReportConfig;
+  onNavigate: (screen: Screen, params?: Record<string, string>) => void;
+  onSave: (changes: ConfigChanges) => void;
+}
+
+// Models available per CLI agent
+const CLI_MODELS: Record<string, string[]> = {
+  "claude-code": ["sonnet", "opus", "haiku"],
+  "gemini-cli": ["gemini-cli"],
+  "codex-cli": ["codex-cli"],
+};
+
+type ConfigField = "provider" | "model" | "concurrency" | "temperature" | "todoList";
+
+export function ConfigScreen({
+  config,
+  onNavigate,
+  onSave,
+}: ConfigScreenProps) {
+  const [selectedField, setSelectedField] = useState<number>(0);
+  const [currentProvider, setCurrentProvider] = useState(
+    config.defaultProvider
+  );
+  const [currentModel, setCurrentModel] = useState(config.defaultModel);
+  const [concurrency, setConcurrency] = useState(config.agents.maxConcurrency);
+  const [temperature, setTemperature] = useState(config.agents.temperature);
+  const [todoList, setTodoList] = useState(config.features?.todoList ?? false);
+  const [saved, setSaved] = useState(false);
+
+  // CLI tools state
+  const [detectedClis, setDetectedClis] = useState<DetectedCli[]>([]);
+  const [cliDetecting, setCliDetecting] = useState(true);
+
+  // Detect installed CLI tools on mount
+  useEffect(() => {
+    setCliDetecting(true);
+    detectInstalledClis().then((clis) => {
+      setDetectedClis(clis);
+      setCliDetecting(false);
+
+      // Auto-switch to first available agent if current isn't detected
+      const currentIsAvailable = clis.some((c) => c.id === currentProvider);
+      if (!currentIsAvailable && clis.length > 0) {
+        setCurrentProvider(clis[0].id);
+        const models = CLI_MODELS[clis[0].id] || [];
+        if (models.length > 0) {
+          setCurrentModel(models[0]);
+        }
+      }
+    });
+  }, []);
+
+  // Only CLI agents are available for analysis
+  const allProviders = detectedClis.map((c) => c.id);
+
+  const getModelsForProvider = (provider: string): string[] => {
+    return CLI_MODELS[provider] || [];
+  };
+
+  const getProviderLabel = (id: string): string => {
+    const cli = detectedClis.find((c) => c.id === id);
+    if (cli) return cli.name;
+    return id;
+  };
+
+  const isDetected = detectedClis.some((c) => c.id === currentProvider);
+
+  const hasChanges =
+    currentProvider !== config.defaultProvider ||
+    currentModel !== config.defaultModel ||
+    concurrency !== config.agents.maxConcurrency ||
+    temperature !== config.agents.temperature ||
+    todoList !== (config.features?.todoList ?? false);
+
+  const fields: Array<{ id: ConfigField; label: string; value: string }> = [
+    {
+      id: "provider",
+      label: "Agent",
+      value: getProviderLabel(currentProvider),
+    },
+    { id: "model", label: "Model", value: currentModel },
+    {
+      id: "concurrency",
+      label: "Max Concurrency",
+      value: String(concurrency),
+    },
+    { id: "temperature", label: "Temperature", value: String(temperature) },
+    { id: "todoList", label: "Todo List", value: todoList ? "ON" : "OFF" },
+  ];
+
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setSelectedField((prev) => Math.max(0, prev - 1));
+      setSaved(false);
+    } else if (key.downArrow) {
+      setSelectedField((prev) => Math.min(fields.length - 1, prev + 1));
+      setSaved(false);
+    } else if (key.leftArrow || key.rightArrow) {
+      setSaved(false);
+      const field = fields[selectedField];
+      const direction = key.rightArrow ? 1 : -1;
+
+      switch (field.id) {
+        case "provider": {
+          if (allProviders.length === 0) break;
+          const idx = allProviders.indexOf(currentProvider);
+          const newIdx =
+            (idx + direction + allProviders.length) % allProviders.length;
+          const newProvider = allProviders[newIdx];
+          setCurrentProvider(newProvider);
+          // Auto-select first model
+          const models = getModelsForProvider(newProvider);
+          if (models.length > 0 && !models.includes(currentModel)) {
+            setCurrentModel(models[0]);
+          }
+          break;
+        }
+        case "model": {
+          const models = getModelsForProvider(currentProvider);
+          if (models.length === 0) break;
+          const idx = models.indexOf(currentModel);
+          const newIdx = (idx + direction + models.length) % models.length;
+          setCurrentModel(models[newIdx]);
+          break;
+        }
+        case "concurrency": {
+          setConcurrency((prev) =>
+            Math.min(10, Math.max(1, prev + direction))
+          );
+          break;
+        }
+        case "temperature": {
+          setTemperature((prev) => {
+            const next = prev + direction * 0.1;
+            return Math.round(Math.min(1, Math.max(0, next)) * 10) / 10;
+          });
+          break;
+        }
+        case "todoList": {
+          setTodoList((prev) => !prev);
+          break;
+        }
+      }
+    } else if (key.return || input === "s") {
+      onSave({
+        defaultProvider: currentProvider,
+        defaultModel: currentModel,
+        maxConcurrency: concurrency,
+        temperature,
+        todoList,
+      });
+      setSaved(true);
+    } else if (key.escape || input === "q") {
+      onNavigate("home");
+    }
+  });
+
+  const { columns, rows } = useTerminalSize();
+
+  return (
+    <Box flexDirection="column" width={columns} height={rows}>
+      <Header modelName={currentModel} />
+
+      <Container>
+        <Text bold>Configuration</Text>
+        <Text color="gray">
+          Use arrows to change values, Enter to save
+        </Text>
+
+        <Box flexDirection="column" paddingY={1}>
+          {fields.map((field, i) => (
+            <Box key={field.id} flexDirection="row" gap={2}>
+              <Text color={i === selectedField ? "yellow" : "gray"}>
+                {i === selectedField ? ">" : " "}
+              </Text>
+              <Box width={20}>
+                <Text bold={i === selectedField}>{field.label}</Text>
+              </Box>
+              <Text color="cyan">
+                {i === selectedField ? "◀ " : "  "}
+                {field.value}
+                {i === selectedField ? " ▶" : "  "}
+              </Text>
+            </Box>
+          ))}
+        </Box>
+
+        {/* Agent status */}
+        <Box flexDirection="column" paddingY={0} gap={0}>
+          {cliDetecting ? (
+            <Box gap={1}>
+              <Spinner type="dots" />
+              <Text color="gray">Detecting installed agents...</Text>
+            </Box>
+          ) : detectedClis.length === 0 ? (
+            <Box flexDirection="column">
+              <Text color="red">
+                No code agents detected on your system
+              </Text>
+              <Text color="gray">
+                Install one of: claude, gemini, codex
+              </Text>
+            </Box>
+          ) : (
+            <Box flexDirection="column" gap={0}>
+              {isDetected && (
+                <Text color="green">
+                  {getProviderLabel(currentProvider)} detected - uses your existing authentication
+                </Text>
+              )}
+              {!isDetected && (
+                <Text color="yellow">
+                  {currentProvider} not found - use arrows to select an installed agent
+                </Text>
+              )}
+              <Text color="gray" dimColor>
+                Available: {detectedClis.map((c) => c.name).join(", ")}
+              </Text>
+            </Box>
+          )}
+        </Box>
+
+        <Box paddingY={1}>
+          {saved ? (
+            <Text color="green" bold>
+              Configuration saved!
+            </Text>
+          ) : hasChanges ? (
+            <Text color="yellow">
+              Unsaved changes - press Enter or [s] to save
+            </Text>
+          ) : (
+            <Text color="gray">No changes</Text>
+          )}
+        </Box>
+      </Container>
+
+      <Footer
+        actions={[
+          { key: "←→", label: "Change" },
+          { key: "↑↓", label: "Navigate" },
+          { key: "enter", label: "Save" },
+          { key: "esc", label: "Back" },
+        ]}
+      />
+    </Box>
+  );
+}