failproofai 0.0.9-beta.2 → 0.0.10-beta.0

package/.next/standalone/lib/opencode-sessions.ts

@@ -0,0 +1,237 @@
+/**
+ * OpenCode (sst/opencode) session transcript loader.
+ *
+ * Sessions live in opencode's SQLite DB (`~/.local/share/opencode/opencode.db`),
+ * not on disk as JSONL like the other CLIs. We read them by shelling out to
+ * `opencode db --format json "<sql>"` — same surface as `lib/opencode-projects.ts`
+ * and the same fail-open contract (binary missing → return null).
+ *
+ * Schema verified live on opencode v1.14.31:
+ *   • `session(id, project_id, parent_id, slug, directory, title, time_*, …)`
+ *   • `message(id, session_id, time_created, time_updated, data: JSON)`
+ *   • `part(id, message_id, session_id, time_created, time_updated, data: JSON)`
+ *
+ * The `data` column on message/part is an opaque JSON blob; we parse it
+ * defensively (degrade unknown types to system entries) so a future opencode
+ * release that adds new shapes doesn't break the dashboard.
+ *
+ * Refs: https://opencode.ai/docs/   (CLI reference)
+ */
+import { execFileSync } from "node:child_process";
+import { runtimeCache } from "./runtime-cache";
+import {
+  baseEntry,
+  type LogEntry,
+  type UserEntry,
+  type AssistantEntry,
+  type GenericEntry,
+  type ContentBlock,
+  type LogSource,
+} from "./log-entries";
+
+interface OpenCodeSessionRow {
+  id: string;
+  project_id: string;
+  slug: string | null;
+  directory: string | null;
+  title: string | null;
+  time_created: number;
+  time_updated: number;
+}
+
+interface OpenCodeMessageRow {
+  id: string;
+  session_id: string;
+  time_created: number;
+  time_updated: number;
+  data: string; // JSON-encoded
+}
+
+interface OpenCodePartRow {
+  id: string;
+  message_id: string;
+  session_id: string;
+  time_created: number;
+  time_updated: number;
+  data: string; // JSON-encoded
+}
+
+/** Run a parameter-free SELECT against opencode's DB. Returns `null` on any
+ *  failure (binary missing, query error, malformed output). */
+function runOpenCodeDb<T>(sql: string): T[] | null {
+  try {
+    const stdout = execFileSync("opencode", ["db", "--format", "json", sql], {
+      encoding: "utf8",
+      timeout: 5_000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (!stdout.trim()) return [];
+    const parsed = JSON.parse(stdout) as unknown;
+    if (!Array.isArray(parsed)) return null;
+    return parsed as T[];
+  } catch {
+    return null;
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/** Safely JSON.parse a string column from a DB row. */
+function parseDataColumn(raw: string | undefined | null): Record<string, unknown> | null {
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return isPlainObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Read content text safely — opencode parts may carry text under `text` or
+ *  `content` (depending on part type). Anything non-string degrades to "". */
+function readContentText(data: Record<string, unknown>): string {
+  if (typeof data.text === "string") return data.text;
+  if (typeof data.content === "string") return data.content;
+  return "";
+}
+
+/** Translate a (message, parts[]) tuple into a single LogEntry. */
+function translateMessage(
+  msgRow: OpenCodeMessageRow,
+  partRows: OpenCodePartRow[],
+  source: LogSource,
+): LogEntry {
+  const msgData = parseDataColumn(msgRow.data) ?? {};
+  const role = typeof msgData.role === "string" ? msgData.role : "system";
+  const date = new Date(msgRow.time_created);
+  const timestamp = date.toISOString();
+  const raw: Record<string, unknown> = { uuid: msgRow.id, parentUuid: null };
+  const base = baseEntry(raw, timestamp, date, source);
+
+  // Build content blocks from parts. opencode part types we recognize:
+  //   • text  → text block
+  //   • tool  → tool_use envelope (tool name + input args)
+  //   • everything else → preserve as a text block with a debug tag
+  const content: ContentBlock[] = [];
+  let userText = "";
+  for (const p of partRows) {
+    const data = parseDataColumn(p.data);
+    if (!data) continue;
+    const type = typeof data.type === "string" ? data.type : "unknown";
+    if (type === "text") {
+      const text = readContentText(data);
+      if (text) {
+        content.push({ type: "text", text });
+        userText += (userText ? "\n" : "") + text;
+      }
+      continue;
+    }
+    if (type === "tool") {
+      const toolName = typeof data.tool === "string" ? data.tool : (typeof data.name === "string" ? data.name : "tool");
+      const input = isPlainObject(data.input) ? data.input : (isPlainObject(data.args) ? data.args : {});
+      content.push({
+        type: "tool_use",
+        id: p.id,
+        name: toolName,
+        input: input as Record<string, unknown>,
+      });
+      continue;
+    }
+    // Unknown part type — preserve as a text annotation rather than drop silently.
+    content.push({ type: "text", text: `[opencode ${type}]` });
+  }
+
+  if (role === "user") {
+    const entry: UserEntry = {
+      ...base,
+      type: "user",
+      message: { role: "user", content: userText },
+    };
+    return entry;
+  }
+  if (role === "assistant") {
+    const modelInfo = isPlainObject(msgData.model) ? msgData.model : null;
+    const modelStr = modelInfo && typeof modelInfo.modelID === "string" ? modelInfo.modelID : undefined;
+    const entry: AssistantEntry = {
+      ...base,
+      type: "assistant",
+      message: { role: "assistant", content, model: modelStr },
+    };
+    return entry;
+  }
+  // Fallback — system / unknown roles surface as generic entries so nothing is lost.
+  const entry: GenericEntry = {
+    ...base,
+    type: "system",
+    raw: { id: msgRow.id, role, parts: content },
+  };
+  return entry;
+}
+
+export interface OpenCodeSessionLogData {
+  entries: LogEntry[];
+  rawLines: Record<string, unknown>[];
+  cwd?: string;
+  filePath: string; // synthetic — opencode doesn't have a file path; we use opencode://<id>
+}
+
+/**
+ * Load a single session by ID. Returns null when the session doesn't exist
+ * or the binary is unavailable.
+ */
+export async function getOpenCodeSessionLog(sessionId: string): Promise<OpenCodeSessionLogData | null> {
+  if (!sessionId || !/^[A-Za-z0-9_-]+$/.test(sessionId)) return null; // SQL-injection guard
+  const sessions = runOpenCodeDb<OpenCodeSessionRow>(
+    `SELECT id, project_id, slug, directory, title, time_created, time_updated FROM session WHERE id = '${sessionId}'`,
+  );
+  if (!sessions || sessions.length === 0) return null;
+  const session = sessions[0];
+
+  const messages = runOpenCodeDb<OpenCodeMessageRow>(
+    `SELECT id, session_id, time_created, time_updated, data FROM message WHERE session_id = '${sessionId}' ORDER BY time_created ASC`,
+  );
+  const parts = runOpenCodeDb<OpenCodePartRow>(
+    `SELECT id, message_id, session_id, time_created, time_updated, data FROM part WHERE session_id = '${sessionId}' ORDER BY time_created ASC`,
+  );
+  if (!messages) return { entries: [], rawLines: [], cwd: session.directory ?? undefined, filePath: `opencode://${sessionId}` };
+
+  // Group parts by message_id for O(1) lookup.
+  const partsByMessage = new Map<string, OpenCodePartRow[]>();
+  for (const p of parts ?? []) {
+    let bucket = partsByMessage.get(p.message_id);
+    if (!bucket) {
+      bucket = [];
+      partsByMessage.set(p.message_id, bucket);
+    }
+    bucket.push(p);
+  }
+
+  const entries: LogEntry[] = [];
+  const rawLines: Record<string, unknown>[] = [];
+  for (const msg of messages) {
+    const partRows = partsByMessage.get(msg.id) ?? [];
+    entries.push(translateMessage(msg, partRows, "session"));
+    const data = parseDataColumn(msg.data);
+    rawLines.push({
+      id: msg.id,
+      session_id: msg.session_id,
+      time_created: msg.time_created,
+      data: data ?? msg.data,
+    });
+  }
+
+  return {
+    entries,
+    rawLines,
+    cwd: session.directory ?? undefined,
+    filePath: `opencode://${sessionId}`,
+  };
+}
+
+export const getCachedOpenCodeSessionLog = runtimeCache(
+  (sessionId: string) => getOpenCodeSessionLog(sessionId),
+  30,
+  { maxSize: 50 },
+);

package/.next/standalone/lib/pi-projects.ts

@@ -0,0 +1,230 @@
+/**
+ * Pi (pi-coding-agent) project discovery.
+ *
+ * Empirically verified against pi-coding-agent v0.72.1 (Phase 0.7 of plan):
+ *
+ *   • Session-state root: `~/.pi/agent/sessions/` (NOT `~/.pi/sessions/`).
+ *   • Per-cwd subdirs are encoded with `/` → `-` and wrapped in `--…--`,
+ *     e.g. `/home/u/repo` → `--home-u-repo--`. The encoding is LOSSY
+ *     (literal `-` in the path is preserved as `-` and indistinguishable
+ *     from a path separator), so we never use the dir name as the canonical
+ *     cwd — we read the first JSONL record (`{type: "session", cwd, ...}`)
+ *     to recover it exactly.
+ *   • Per-session file: `<ISO-timestamp>_<UUID>.jsonl`, e.g.
+ *     `2026-05-01T20-36-22-628Z_019de541-b7e3-7131-abac-d15df780042c.jsonl`.
+ *   • File format: JSONL. First record always shape
+ *     `{type: "session", version, id, timestamp, cwd}`.
+ *
+ * As with Cursor/Copilot, this module is intentionally permissive — a
+ * missing `~/.pi/` returns `[]`, and a malformed JSONL falls open without
+ * surfacing the session.
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { encodeFolderName } from "./paths";
+import type { ProjectFolder, SessionFile } from "./projects";
+import { runtimeCache } from "./runtime-cache";
+import { batchAll } from "./concurrency";
+import { formatDate } from "./format-date";
+import { logWarn } from "./logger";
+
+/** Filename pattern for a Pi session JSONL: `<iso-timestamp>_<uuid>.jsonl`. */
+const SESSION_FILE_RE = /^[\d-]+T[\d-]+Z_([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+
+function getPiSessionsRoot(): string {
+  return process.env.PI_SESSIONS_DIR
+    || join(homedir(), ".pi", "agent", "sessions");
+}
+
+interface PiSessionMeta {
+  filePath: string;
+  sessionId: string;
+  cwd: string;
+  fileMtime: Date;
+}
+
+async function safeReaddir(dir: string) {
+  try {
+    return await readdir(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+}
+
+async function statMtime(path: string): Promise<Date | null> {
+  try {
+    return (await stat(path)).mtime;
+  } catch {
+    return null;
+  }
+}
+
+/** Reads the first newline-terminated record of a Pi JSONL file and returns
+ *  its `cwd` field. Returns null on read/parse failure or when the first
+ *  record isn't `{type: "session"}`. */
+async function readSessionCwd(filePath: string): Promise<string | null> {
+  let text: string;
+  try {
+    text = await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const firstLine = text.indexOf("\n") >= 0 ? text.slice(0, text.indexOf("\n")) : text;
+  if (!firstLine) return null;
+  try {
+    const parsed = JSON.parse(firstLine) as { type?: unknown; cwd?: unknown };
+    if (parsed.type !== "session") return null;
+    if (typeof parsed.cwd !== "string" || parsed.cwd.length === 0) return null;
+    return parsed.cwd;
+  } catch {
+    return null;
+  }
+}
+
+async function scanPiSessions(): Promise<PiSessionMeta[]> {
+  const root = getPiSessionsRoot();
+  const cwdDirs = await safeReaddir(root);
+  if (!cwdDirs) return [];
+
+  const candidates: { sessionId: string; filePath: string }[] = [];
+  for (const cwdDir of cwdDirs) {
+    if (!cwdDir.isDirectory()) continue;
+    const cwdPath = join(root, cwdDir.name);
+    const sessionFiles = await safeReaddir(cwdPath);
+    if (!sessionFiles) continue;
+    for (const f of sessionFiles) {
+      if (!f.isFile()) continue;
+      const m = SESSION_FILE_RE.exec(f.name);
+      if (!m) continue;
+      candidates.push({ sessionId: m[1], filePath: join(cwdPath, f.name) });
+    }
+  }
+  if (candidates.length === 0) return [];
+
+  const settled = await batchAll(
+    candidates.map((c) => async (): Promise<PiSessionMeta | null> => {
+      const cwd = await readSessionCwd(c.filePath);
+      if (!cwd) return null;
+      const mtime = await statMtime(c.filePath);
+      if (!mtime) return null;
+      return {
+        filePath: c.filePath,
+        sessionId: c.sessionId,
+        cwd,
+        fileMtime: mtime,
+      };
+    }),
+    16,
+  );
+  return settled
+    .filter((r): r is PromiseFulfilledResult<PiSessionMeta | null> => r.status === "fulfilled")
+    .map((r) => r.value)
+    .filter((v): v is PiSessionMeta => v !== null);
+}
+
+const cachedScan = runtimeCache(scanPiSessions, 30);
+
+/** Returns one ProjectFolder per unique cwd discovered in Pi transcripts. */
+export async function getPiProjects(): Promise<ProjectFolder[]> {
+  let metas: PiSessionMeta[];
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Pi sessions:", error);
+    return [];
+  }
+
+  const byCwd = new Map<string, { latest: Date; cwd: string }>();
+  for (const m of metas) {
+    const existing = byCwd.get(m.cwd);
+    if (!existing || m.fileMtime.getTime() > existing.latest.getTime()) {
+      byCwd.set(m.cwd, { latest: m.fileMtime, cwd: m.cwd });
+    }
+  }
+
+  const folders: ProjectFolder[] = [];
+  for (const { cwd, latest } of byCwd.values()) {
+    folders.push({
+      name: encodeFolderName(cwd),
+      path: cwd,
+      isDirectory: true,
+      lastModified: latest,
+      lastModifiedFormatted: formatDate(latest),
+      cli: ["pi"],
+    });
+  }
+  folders.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return folders;
+}
+
+function metasToSessionFiles(metas: PiSessionMeta[]): SessionFile[] {
+  const files: SessionFile[] = metas.map((m) => ({
+    name: m.sessionId,
+    path: m.filePath,
+    lastModified: m.fileMtime,
+    lastModifiedFormatted: formatDate(m.fileMtime),
+    sessionId: m.sessionId,
+    cli: "pi",
+  }));
+  files.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  return files;
+}
+
+/** Returns SessionFile entries for every Pi transcript whose cwd matches `cwd` exactly. */
+export async function getPiSessionsForCwd(cwd: string): Promise<SessionFile[]> {
+  let metas: PiSessionMeta[];
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Pi sessions:", error);
+    return [];
+  }
+  return metasToSessionFiles(metas.filter((m) => m.cwd === cwd));
+}
+
+export interface PiProjectByName {
+  cwd: string | null;
+  sessions: SessionFile[];
+}
+
+/**
+ * Looks up Pi sessions for a project URL slug. `decodeFolderName` is lossy on
+ * cwds containing `-`, so we re-encode each session's cwd via
+ * `encodeFolderName` and match in that direction. Returns both the canonical
+ * cwd and the matching sessions.
+ */
+export async function getPiSessionsByEncodedName(name: string): Promise<PiProjectByName> {
+  let metas: PiSessionMeta[];
+  try {
+    metas = await cachedScan();
+  } catch (error) {
+    logWarn("Failed to scan Pi sessions:", error);
+    return { cwd: null, sessions: [] };
+  }
+  const matches = metas.filter((m) => encodeFolderName(m.cwd) === name);
+  // encodeFolderName is lossy — distinct cwd values can collapse to the same
+  // encoded slug. Only return a canonical cwd when every match agrees;
+  // otherwise drop the cwd and the (mixed) sessions to avoid surfacing the
+  // wrong project label.
+  const uniqueCwds = Array.from(new Set(matches.map((m) => m.cwd)));
+  if (uniqueCwds.length !== 1) {
+    return { cwd: null, sessions: [] };
+  }
+  return {
+    cwd: uniqueCwds[0],
+    sessions: metasToSessionFiles(matches),
+  };
+}
+
+export const getCachedPiProjects = runtimeCache(getPiProjects, 30);
+export const getCachedPiSessionsForCwd = runtimeCache(
+  (cwd: string) => getPiSessionsForCwd(cwd),
+  30,
+  { maxSize: 50 },
+);
+export const getCachedPiSessionsByEncodedName = runtimeCache(
+  (name: string) => getPiSessionsByEncodedName(name),
+  30,
+  { maxSize: 50 },
+);