@seanxdo/superview 0.1.13

package/runtime-node/adapters/opencode.ts

@@ -0,0 +1,193 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { AgentLogAdapter, AgentLogSource, NormalizedBundle, ParsedAgentEvent, TokenUsage } from "../../core/types";
+import { normalizeCodexLines } from "../../core/normalizer";
+import { asRecord, makeTokenUsage, numberTimestamp, parsedEvent, readJsonFile, stringValue } from "./shared";
+
+const execFileAsync = promisify(execFile);
+
+export const opencodeAdapter: AgentLogAdapter = {
+  provider: "opencode",
+  async scan(config) {
+    if (config?.path) {
+      return [await fileLikeSource(config.path)];
+    }
+    const stdout = await runOpencode(["session", "list", "--format", "json"]);
+    const sessions = stdout.trim() ? asArray(JSON.parse(stdout)) : [];
+    const tempDir = await mkdtemp(path.join(tmpdir(), "superview-opencode-export-"));
+    const sources: AgentLogSource[] = [];
+    for (const session of sessions) {
+      const record = asRecord(session);
+      const id = stringValue(record.id) ?? stringValue(record.sessionID) ?? stringValue(record.sessionId);
+      if (!id) continue;
+      const exported = await runOpencode(["export", id, "--sanitize"]);
+      const exportPath = path.join(tempDir, `${id}.json`);
+      await writeFile(exportPath, exported, "utf8");
+      sources.push(await fileLikeSource(exportPath));
+    }
+    return sources;
+  },
+  async parseSource(source, options = {}) {
+    const json = await readJsonFile(source.path);
+    return normalizeOpenCodeExport(json, source.path, options.repoRoot);
+  }
+};
+
+export function normalizeOpenCodeExport(json: unknown, sourcePath: string, repoRoot?: string | null): NormalizedBundle | null {
+  const root = asRecord(json);
+  const session = asRecord(root.session ?? root);
+  const messages = asArray(root.messages ?? root.message ?? root.parts);
+  const externalSessionId = stringValue(session.id) ?? path.basename(sourcePath, ".json");
+  const cwd = stringValue(session.cwd) ?? stringValue(root.cwd) ?? process.cwd();
+  const startedAt = timestampFromValue(asRecord(session.time).created ?? session.created ?? messages[0]);
+  const version = stringValue(session.version) ?? stringValue(root.version);
+  const lines: ParsedAgentEvent[] = [
+    parsedEvent({
+      provider: "opencode",
+      sourcePath,
+      lineNo: 1,
+      timestamp: startedAt,
+      type: "session_meta",
+      payload: {
+        id: externalSessionId,
+        timestamp: startedAt,
+        cwd,
+        cli_version: version,
+        model_provider: stringValue(session.provider) ?? null,
+        source: "opencode"
+      }
+    })
+  ];
+
+  let lineNo = 2;
+  for (const messageValue of messages) {
+    const message = asRecord(messageValue);
+    const timestamp = timestampFromValue(asRecord(message.time).created ?? message.created ?? message.timestamp);
+    const role = stringValue(message.role) ?? stringValue(message.type);
+    const parts = asArray(message.parts ?? message.content);
+    const usage = makeTokenUsage(message.tokens ?? message.usage);
+
+    const messageText = textFromParts(parts.length > 0 ? parts : message.content);
+    if ((role === "user" || role === "assistant") && messageText) {
+      lines.push(
+        parsedEvent({
+          provider: "opencode",
+          sourcePath,
+          lineNo,
+          timestamp,
+          type: "response_item",
+          payload: {
+            type: "message",
+            role,
+            content: [{ type: role === "assistant" ? "output_text" : "input_text", text: messageText }],
+            ...(usage ? { usage } : {})
+          }
+        })
+      );
+      lineNo += 1;
+    }
+
+    for (const part of parts) {
+      const partRecord = asRecord(part);
+      if (!isToolPart(partRecord)) continue;
+      lines.push(
+        parsedEvent({
+          provider: "opencode",
+          sourcePath,
+          lineNo,
+          timestamp,
+          type: "response_item",
+          payload: {
+            type: "function_call",
+            call_id: stringValue(partRecord.id) ?? stringValue(partRecord.callID) ?? stringValue(partRecord.callId),
+            name: stringValue(partRecord.tool) ?? stringValue(partRecord.name) ?? "tool",
+            arguments: JSON.stringify(partRecord.input ?? partRecord.arguments ?? {})
+          }
+        })
+      );
+      lineNo += 1;
+    }
+
+    if (role === "tool") {
+      lines.push(
+        parsedEvent({
+          provider: "opencode",
+          sourcePath,
+          lineNo,
+          timestamp,
+          type: "response_item",
+          payload: {
+            type: "function_call_output",
+            call_id: stringValue(message.toolCallId) ?? stringValue(message.tool_call_id) ?? stringValue(message.callId),
+            output: messageText || JSON.stringify(message)
+          }
+        })
+      );
+      lineNo += 1;
+    }
+  }
+
+  return normalizeCodexLines(lines, {
+    repoRoot,
+    provider: "opencode",
+    prefixSessionId: true,
+    modelProvider: stringValue(session.provider) ?? null,
+    source: "opencode",
+    agentName: "OpenCode"
+  });
+}
+
+async function fileLikeSource(filePath: string): Promise<AgentLogSource> {
+  const content = await readFile(filePath, "utf8");
+  const stats = await stat(filePath);
+  return {
+    provider: "opencode",
+    id: `opencode:${filePath}`,
+    path: filePath,
+    sizeBytes: Buffer.byteLength(content),
+    mtimeMs: stats.mtimeMs
+  };
+}
+
+async function runOpencode(args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync("opencode", args, {
+    maxBuffer: 50 * 1024 * 1024
+  });
+  return stdout;
+}
+
+function asArray(value: unknown): unknown[] {
+  if (Array.isArray(value)) return value;
+  if (!value || typeof value !== "object") return [];
+  const record = value as Record<string, unknown>;
+  for (const key of ["items", "data", "sessions", "messages"]) {
+    if (Array.isArray(record[key])) return record[key];
+  }
+  return [];
+}
+
+function timestampFromValue(value: unknown): string {
+  if (typeof value === "string") return value;
+  const numeric = numberTimestamp(value);
+  return numeric ?? new Date(0).toISOString();
+}
+
+function textFromParts(value: unknown): string {
+  if (typeof value === "string") return value;
+  return asArray(value)
+    .map((part) => {
+      if (typeof part === "string") return part;
+      const record = asRecord(part);
+      return stringValue(record.text) ?? stringValue(record.content) ?? stringValue(record.output) ?? "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function isToolPart(part: Record<string, unknown>) {
+  const type = stringValue(part.type);
+  return type === "tool" || type === "tool_call" || Boolean(part.tool ?? part.name);
+}

package/runtime-node/adapters/shared.ts

@@ -0,0 +1,113 @@
+import { readFile, stat } from "node:fs/promises";
+import { AgentLogSource, AgentProvider, ParsedAgentEvent, TimelineEvent, TokenUsage } from "../../core/types";
+import { redactValue } from "../../core/redactor";
+import { sha256 } from "../../core/hash";
+
+export async function fileSource(provider: AgentProvider, filePath: string): Promise<AgentLogSource> {
+  const stats = await stat(filePath);
+  return {
+    provider,
+    id: `${provider}:${filePath}`,
+    path: filePath,
+    sizeBytes: stats.size,
+    mtimeMs: stats.mtimeMs
+  };
+}
+
+export async function readJsonFile(sourcePath: string): Promise<unknown> {
+  return JSON.parse(await readFile(sourcePath, "utf8"));
+}
+
+export function parsedEvent(input: {
+  provider: AgentProvider;
+  sourcePath: string;
+  lineNo: number;
+  timestamp: string;
+  type: string;
+  payload: unknown;
+  raw?: string;
+}): ParsedAgentEvent {
+  const raw = input.raw ?? JSON.stringify({ timestamp: input.timestamp, type: input.type, payload: input.payload });
+  return {
+    provider: input.provider,
+    sourcePath: input.sourcePath,
+    lineNo: input.lineNo,
+    timestamp: input.timestamp,
+    type: input.type,
+    payload: input.payload,
+    redactedPayload: redactValue(input.payload),
+    sha256: sha256(raw)
+  };
+}
+
+export function makeTokenUsage(value: unknown): TokenUsage | null {
+  const rawInput = firstNumber(value, ["input_tokens", "prompt_tokens", "input", "prompt"]);
+  const output = firstNumber(value, ["output_tokens", "completion_tokens", "output", "completion"]);
+  const reasoning = firstNumber(value, ["reasoning_tokens", "reasoning", "reasoning_output_tokens"]);
+  // OpenAI/Codex style: cached_tokens / cached_input_tokens are ALREADY included in prompt_tokens/input_tokens.
+  // Anthropic style: cache_read_input_tokens and cache_creation_input_tokens are reported SEPARATELY from input_tokens.
+  const cachedRead = firstNumber(value, ["cached_input_tokens", "cached_tokens", "cache_read_input_tokens", "cached_input", "cache_read", "read"]);
+  const anthropicCacheRead = firstNumber(value, ["cache_read_input_tokens"]);
+  const anthropicCacheCreation = firstNumber(value, ["cache_creation_input_tokens"]);
+  const explicitTotal = firstNumber(value, ["total_tokens", "total"]);
+  const isAnthropicStyle = anthropicCacheRead !== null || anthropicCacheCreation !== null;
+  const input = isAnthropicStyle
+    ? (rawInput ?? 0) + (anthropicCacheRead ?? 0) + (anthropicCacheCreation ?? 0)
+    : rawInput;
+  const cachedInput = isAnthropicStyle ? (anthropicCacheRead ?? 0) : cachedRead;
+  const total = explicitTotal ?? sumKnown(input, output);
+  if (rawInput === null && output === null && reasoning === null && cachedRead === null && total === null && !isAnthropicStyle) return null;
+  return {
+    input: input ?? 0,
+    output: output ?? 0,
+    reasoning: reasoning ?? 0,
+    cachedInput: cachedInput ?? 0,
+    total: total ?? 0
+  };
+}
+
+export function attachTokenUsage(event: TimelineEvent, usage: TokenUsage | null): TimelineEvent {
+  return usage ? { ...event, tokenUsage: usage } : event;
+}
+
+export function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+export function stringValue(value: unknown): string | null {
+  return typeof value === "string" ? value : null;
+}
+
+export function numberTimestamp(value: unknown): string | null {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return new Date(value).toISOString();
+}
+
+function firstNumber(value: unknown, keys: string[]): number | null {
+  const matches = collectNumbers(value, new Set(keys.map(normalizeKey)));
+  return matches[0] ?? null;
+}
+
+function collectNumbers(value: unknown, keys: Set<string>): number[] {
+  if (!value || typeof value !== "object") return [];
+  if (Array.isArray(value)) return value.flatMap((item) => collectNumbers(item, keys));
+  const matches: number[] = [];
+  for (const [key, child] of Object.entries(value)) {
+    if (keys.has(normalizeKey(key)) && typeof child === "number" && Number.isFinite(child) && child >= 0) {
+      matches.push(Math.trunc(child));
+    }
+    if (child && typeof child === "object") {
+      matches.push(...collectNumbers(child, keys));
+    }
+  }
+  return matches;
+}
+
+function normalizeKey(value: string) {
+  return value.replace(/[^a-z0-9]/gi, "").toLowerCase();
+}
+
+function sumKnown(...values: Array<number | null>) {
+  const known = values.filter((value): value is number => value !== null);
+  return known.length > 0 ? known.reduce((sum, value) => sum + value, 0) : null;
+}

package/runtime-node/cli-ingest.ts

@@ -0,0 +1,7 @@
+import { SuperViewDatabase } from "../storage/database";
+import { IngestService } from "./ingest";
+
+const db = new SuperViewDatabase();
+const service = new IngestService(db);
+const result = service.start(process.argv[2] ? { codexHome: process.argv[2] } : {});
+console.log(JSON.stringify({ jobId: result.job.id, alreadyRunning: result.alreadyRunning }, null, 2));

package/runtime-node/cli-start.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const require = createRequire(import.meta.url);
+const tsxDir = path.dirname(require.resolve("tsx/package.json"));
+const tsxPath = path.join(tsxDir, "dist", "cli.mjs");
+const cliPath = fileURLToPath(new URL("./cli-start.ts", import.meta.url));
+
+const child = spawn(process.execPath, [tsxPath, cliPath, ...process.argv.slice(2)], {
+  stdio: "inherit"
+});
+child.on("exit", (code) => process.exit(code ?? 0));

package/runtime-node/cli-start.ts

@@ -0,0 +1,9 @@
+import { startProdServer } from "./prod-server.js";
+
+const portArg = process.argv.find((arg) => arg.startsWith("--port="));
+const dataDirArg = process.argv.find((arg) => arg.startsWith("--data-dir="));
+
+if (portArg) process.env.SUPERVIEW_PORT = portArg.split("=")[1];
+if (dataDirArg) process.env.SUPERVIEW_DATA_DIR = dataDirArg.split("=")[1];
+
+startProdServer();

package/runtime-node/dev-server.ts

@@ -0,0 +1,6 @@
+import { createServer } from "./server.js";
+
+const port = Number(process.env.SUPERVIEW_API_PORT ?? 5174);
+createServer().listen(port, "127.0.0.1", () => {
+  console.log(`SuperView API listening on http://127.0.0.1:${port}`);
+});

package/runtime-node/git-provider.ts

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type { GitCommitRecord } from "../core/types";
+
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 3000;
+
+export async function getRepoRoot(cwd: string): Promise<string | null> {
+  try {
+    const { stdout } = await execFileAsync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { timeout: GIT_TIMEOUT_MS });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+export async function getCommits(repoRoot: string, from?: string | null, to?: string | null): Promise<GitCommitRecord[]> {
+  const args = [
+    "-C",
+    repoRoot,
+    "log",
+    "--date=iso-strict",
+    "--pretty=format:%x1e%H%x1f%h%x1f%an%x1f%ae%x1f%ad%x1f%s",
+    "--numstat"
+  ];
+
+  if (from) {
+    args.push(`--since=${formatGitDateArg(from)}`);
+  }
+  if (to) {
+    args.push(`--until=${formatGitDateArg(to)}`);
+  }
+
+  try {
+    const { stdout } = await execFileAsync("git", args, {
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return parseGitLogNumstat(stdout, repoRoot);
+  } catch {
+    return [];
+  }
+}
+
+function parseGitLogNumstat(stdout: string, repoRoot: string): GitCommitRecord[] {
+  return stdout
+    .split("\x1e")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => parseGitCommitEntry(entry, repoRoot))
+    .filter((commit): commit is GitCommitRecord => commit !== null);
+}
+
+function parseGitCommitEntry(entry: string, repoRoot: string): GitCommitRecord | null {
+  const lines = entry.split(/\r?\n/).filter(Boolean);
+  const header = lines.shift();
+  if (!header) return null;
+
+  const [hash, shortHash, authorName, authorEmail, timestamp, subject] = header.split("\x1f");
+  if (!hash || !shortHash || !timestamp) return null;
+
+  let filesChanged = 0;
+  let insertions = 0;
+  let deletions = 0;
+
+  for (const line of lines) {
+    const [inserted, deleted] = line.split(/\t/);
+    if (inserted === undefined || deleted === undefined) continue;
+
+    filesChanged += 1;
+    insertions += parseNumstatCount(inserted);
+    deletions += parseNumstatCount(deleted);
+  }
+
+  return {
+    id: hash,
+    projectId: repoRoot,
+    repoRoot,
+    hash,
+    shortHash,
+    authorName: authorName || null,
+    authorEmail: authorEmail || null,
+    timestamp,
+    subject: subject ?? "",
+    filesChanged,
+    insertions,
+    deletions
+  };
+}
+
+function parseNumstatCount(value: string): number {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function formatGitDateArg(value: string): string {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    return value;
+  }
+  return `@${Math.floor(parsed.getTime() / 1000)}`;
+}

package/runtime-node/history.ts

@@ -0,0 +1,9 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { parseCodexHistoryJsonlContent, type CodexHistoryParseResult } from "../core/history";
+
+export async function parseCodexHistoryJsonlFile(sourcePath = join(homedir(), ".codex", "history.jsonl")): Promise<CodexHistoryParseResult> {
+  const content = await readFile(sourcePath, "utf8");
+  return parseCodexHistoryJsonlContent(content, sourcePath);
+}

package/runtime-node/ingest-worker.ts

@@ -0,0 +1,32 @@
+import { SuperViewDatabase } from "../storage/database";
+import { parseIngestOptions, runIngestJob } from "./ingest";
+
+const [jobId, encodedOptions] = process.argv.slice(2);
+
+if (!jobId) {
+  throw new Error("Missing ingest job id");
+}
+
+const db = new SuperViewDatabase();
+
+try {
+  if (process.env.SUPERVIEW_TEST_INGEST_WORKER_FAIL === "1") {
+    markFailed(db, jobId, "Forced ingest worker failure");
+    process.exitCode = 1;
+  } else {
+    await runIngestJob(db, jobId, parseIngestOptions(encodedOptions), { workerPid: process.pid });
+  }
+} finally {
+  db.close();
+}
+
+function markFailed(database: SuperViewDatabase, id: string, message: string) {
+  const job = database.getJob(id);
+  if (!job) return;
+  job.status = "failed";
+  job.phase = "failed";
+  job.finishedAt = new Date().toISOString();
+  job.currentFile = null;
+  job.errors.push(message);
+  database.upsertJob(job);
+}