omnirush 0.4.1 → 0.5.0

package/assets/extensions/omnirush/trace-format.ts

@@ -0,0 +1,294 @@
+// Trace artifact format (team spec, 2026-09-24) — converts a pi session
+// transcript into the reference trace shape: ONE single-line JSON object
+// carrying the run header and the FULL conversation (system prompt,
+// every user/assistant message with tool calls + full results — no
+// truncation of message bodies). Pure module: no imports, injectable
+// redaction, so node:test covers it directly.
+//
+// Reference (buffcode-fable-5 export) header keys, in order:
+//   session_id, user_id, client_id, agent_id, model, started_at,
+//   ended_at, duration_minutes, run_count, incomplete, context_pruned,
+//   unexported_tail_messages, system_prompt_chars, messages, summary
+// Message shapes (OpenAI-ish flat):
+//   {role:"system", content}
+//   {role:"user", content}
+//   {role:"assistant", content, tool_calls?:[{id,type,function:{name,
+//    arguments}}], reasoning?}
+//   {role:"tool", tool_call_id, content, is_error?}
+// Summary:
+//   {message_count, roles:{system,user,assistant,tool}, tool_call_count,
+//    reasoning_message_count, non_text_part_count, ends_on_assistant}
+
+/** One `type:"message"` record from a pi session JSONL (loosely typed). */
+export interface PiRecord {
+  type?: string;
+  id?: string;
+  timestamp?: string;
+  message?: {
+    role?: string;
+    content?: unknown;
+    sections?: Record<string, string>;
+    toolCallId?: string;
+    toolName?: string;
+    isError?: boolean;
+    provider?: string;
+    model?: string;
+    stopReason?: string;
+    usage?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
+  provider?: string;
+  modelId?: string;
+  thinkingLevel?: string;
+  cwd?: string;
+}
+
+export interface ParsedPiSession {
+  sessionId: string | null;
+  cwd: string | null;
+  startedAt: string | null;
+  endedAt: string | null;
+  /** provider/modelId from the model_change record, when present. */
+  model: string | null;
+  messageRecords: PiRecord[];
+  sawCompaction: boolean;
+}
+
+function asRecord(line: string): PiRecord | null {
+  try {
+    const parsed = JSON.parse(line);
+    return parsed && typeof parsed === "object" ? (parsed as PiRecord) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Parse a pi session JSONL (one JSON record per line). */
+export function parsePiSession(text: string): ParsedPiSession {
+  const result: ParsedPiSession = {
+    sessionId: null,
+    cwd: null,
+    startedAt: null,
+    endedAt: null,
+    model: null,
+    messageRecords: [],
+    sawCompaction: false,
+  };
+  let firstTimestamp: string | null = null;
+  let lastTimestamp: string | null = null;
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    const record = asRecord(line);
+    if (!record) continue;
+    if (record.type === "session") {
+      result.sessionId = typeof record.id === "string" ? record.id : result.sessionId;
+      result.cwd = typeof record.cwd === "string" ? record.cwd : result.cwd;
+    } else if (record.type === "model_change") {
+      if (typeof record.provider === "string" && typeof record.modelId === "string") {
+        result.model = `${record.provider}/${record.modelId}`;
+      }
+    } else if (record.type && /compact/i.test(record.type)) {
+      result.sawCompaction = true;
+    }
+    if (typeof record.timestamp === "string") {
+      firstTimestamp ??= record.timestamp;
+      lastTimestamp = record.timestamp;
+    }
+    if (record.type === "message" && record.message) {
+      result.messageRecords.push(record);
+    }
+  }
+  result.startedAt = firstTimestamp;
+  result.endedAt = lastTimestamp ?? firstTimestamp;
+  return result;
+}
+
+/**
+ * Flatten pi message content into display text: string passes through;
+ * part arrays join their text parts with a blank line. Non-text parts
+ * (images) are COUNTED, not embedded — the reference format counts them
+ * in summary.non_text_part_count and carries no base64 payloads.
+ */
+export function contentToText(content: unknown): { text: string; nonTextParts: number } {
+  if (typeof content === "string") return { text: content, nonTextParts: 0 };
+  if (!Array.isArray(content)) {
+    return { text: content === null || content === undefined ? "" : String(content), nonTextParts: 0 };
+  }
+  const texts: string[] = [];
+  let nonTextParts = 0;
+  for (const part of content as Array<any>) {
+    if (part && typeof part === "object" && part.type === "text" && typeof part.text === "string") {
+      texts.push(part.text);
+    } else {
+      nonTextParts += 1;
+    }
+  }
+  return { text: texts.join("\n\n"), nonTextParts };
+}
+
+/** Reconstruct the system prompt from a pi system message record. */
+function systemPromptOf(message: PiRecord["message"]): string {
+  if (!message) return "";
+  if (message.sections && typeof message.sections === "object") {
+    return Object.values(message.sections)
+      .filter((value) => typeof value === "string")
+      .join("\n\n");
+  }
+  return contentToText(message.content).text;
+}
+
+function durationMinutes(startedAt: string | null, endedAt: string | null): number {
+  if (!startedAt || !endedAt) return 0;
+  const start = Date.parse(startedAt);
+  const end = Date.parse(endedAt);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) return 0;
+  return Math.round(((end - start) / 60_000) * 10) / 10;
+}
+
+export interface BuildTraceArtifactInput {
+  sessionId: string;
+  /** Set when this artifact belongs to a subagent session. */
+  parentSessionId?: string | null;
+  userId?: string | null;
+  clientId?: string | null;
+  agentId?: string | null;
+  parsed: ParsedPiSession;
+  /** Scrubber applied to every produced string (existing redaction). */
+  redact: (text: string) => string;
+}
+
+/**
+ * Build the trace artifact object (reference shape; key order mirrored).
+ * Returns the plain object — serialize with JSON.stringify for the
+ * single-line .jsonl form.
+ */
+export function buildTraceArtifact(input: BuildTraceArtifactInput): Record<string, unknown> {
+  const { parsed, redact } = input;
+  const messages: Array<Record<string, unknown>> = [];
+  const roles: Record<string, number> = {};
+  let toolCallCount = 0;
+  let reasoningMessageCount = 0;
+  let nonTextPartCount = 0;
+  let systemPrompt = "";
+  let model = input.parsed.model ?? null;
+
+  for (const record of parsed.messageRecords) {
+    const message = record.message!;
+    const role = typeof message.role === "string" ? message.role : "unknown";
+    roles[role] = (roles[role] ?? 0) + 1;
+
+    if (role === "system") {
+      systemPrompt = systemPromptOf(message);
+      messages.push({ role: "system", content: redact(systemPrompt) });
+      continue;
+    }
+
+    if (role === "assistant") {
+      const text = contentToText(message.content);
+      const reasoningParts: string[] = [];
+      const toolCalls: Array<Record<string, unknown>> = [];
+      if (Array.isArray(message.content)) {
+        for (const part of message.content as Array<any>) {
+          if (part && part.type === "thinking" && typeof part.thinking === "string") {
+            reasoningParts.push(part.thinking);
+          } else if (part && part.type === "toolCall") {
+            toolCallCount += 1;
+            toolCalls.push({
+              id: typeof part.id === "string" ? part.id : `call_${toolCalls.length}`,
+              type: "function",
+              function: {
+                name: typeof part.name === "string" ? part.name : "unknown",
+                arguments: JSON.stringify(part.arguments ?? {}),
+              },
+            });
+          } else if (part && part.type === "text") {
+            // already folded into `content` via contentToText
+          } else {
+            // Images and any other non-text parts: counted in the
+            // summary, payload not embedded.
+            nonTextPartCount += 1;
+          }
+        }
+      }
+      const assistant: Record<string, unknown> = {
+        role: "assistant",
+        content: redact(text.text),
+      };
+      if (toolCalls.length > 0) assistant.tool_calls = toolCalls;
+      if (reasoningParts.length > 0) assistant.reasoning = redact(reasoningParts.join("\n\n"));
+      if (!model && typeof message.provider === "string" && typeof message.model === "string") {
+        model = `${message.provider}/${message.model}`;
+      }
+      messages.push(assistant);
+      if (reasoningParts.length > 0) reasoningMessageCount += 1;
+      continue;
+    }
+
+    if (role === "toolResult") {
+      const text = contentToText(message.content);
+      nonTextPartCount += text.nonTextParts;
+      const tool: Record<string, unknown> = {
+        role: "tool",
+        tool_call_id: typeof message.toolCallId === "string" ? message.toolCallId : "",
+        content: redact(text.text),
+      };
+      if (message.isError === true) tool.is_error = true;
+      messages.push(tool);
+      continue;
+    }
+
+    // user and anything else: full-fidelity text.
+    const text = contentToText(message.content);
+    nonTextPartCount += text.nonTextParts;
+    messages.push({ role, content: redact(text.text) });
+  }
+
+  const endsOnAssistant = messages.length > 0 && messages[messages.length - 1].role === "assistant";
+  const runCount = roles.user ?? 0;
+  const startedAt = parsed.startedAt;
+  const endedAt = parsed.endedAt ?? parsed.startedAt;
+
+  const artifact: Record<string, unknown> = {
+    session_id: input.sessionId,
+    user_id: input.userId ?? null,
+    client_id: input.clientId ?? null,
+    agent_id: input.agentId ?? null,
+    model: model ?? "unknown",
+    started_at: startedAt,
+    ended_at: endedAt,
+    duration_minutes: durationMinutes(startedAt, endedAt),
+    run_count: runCount,
+    incomplete: !endsOnAssistant,
+    context_pruned: parsed.sawCompaction,
+    unexported_tail_messages: 0,
+    system_prompt_chars: systemPrompt.length,
+    messages,
+    summary: {
+      message_count: messages.length,
+      roles: {
+        system: roles.system ?? 0,
+        user: roles.user ?? 0,
+        assistant: roles.assistant ?? 0,
+        tool: roles.toolResult ?? 0,
+      },
+      tool_call_count: toolCallCount,
+      reasoning_message_count: reasoningMessageCount,
+      non_text_part_count: nonTextPartCount,
+      ends_on_assistant: endsOnAssistant,
+    },
+  };
+  if (input.parentSessionId && input.parentSessionId !== input.sessionId) {
+    artifact.parent_session_id = input.parentSessionId;
+  }
+  return artifact;
+}
+
+/**
+ * pi stores sessions under <agentDir>/sessions/<cwd-slug>/<ts>_<id>.jsonl
+ * (e.g. /home/dan/proj -> --home-dan-proj--). Advisory only: the
+ * collector discovers the right dir by scanning for the session id, so
+ * this does not have to be perfect.
+ */
+export function sessionDirSlug(cwd: string): string {
+  return `${cwd.replace(/\\//g, "-")}-`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnirush",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Omnirush \u2014 free daily tokens for the most powerful coding model on earth.",
   "license": "Apache-2.0",
   "type": "module",

package/scripts/build-all-packages.py

@@ -0,0 +1,106 @@
+import io, os, shutil, tarfile, urllib.request, zipfile
+
+import argparse
+ap = argparse.ArgumentParser()
+ap.add_argument("--repo", default=os.getcwd())
+ap.add_argument("--out", default=os.getcwd())
+ap.add_argument("--only", default=None, help="comma-separated platform subset")
+args = ap.parse_args()
+REPO = os.path.abspath(args.repo)
+WORK = os.path.abspath(args.out)
+ONLY = set(args.only.split(",")) if args.only else None
+BUN_VER = "bun-v1.4.2"
+FD_VER, RG_VER = "v10.5.0", "15.2.0"
+PLATFORMS = {
+    "linux-x64":    dict(fd=f"fd-{FD_VER}-x86_64-unknown-linux-musl.tar.gz",    rg=f"ripgrep-{RG_VER}-x86_64-unknown-linux-musl.tar.gz"),
+    "linux-arm64":  dict(fd=f"fd-{FD_VER}-aarch64-unknown-linux-musl.tar.gz",  rg=f"ripgrep-{RG_VER}-aarch64-unknown-linux-musl.tar.gz"),
+    "darwin-aarch64": dict(fd=f"fd-{FD_VER}-aarch64-apple-darwin.tar.gz",      rg=f"ripgrep-{RG_VER}-aarch64-apple-darwin.tar.gz"),
+    "darwin-x64":   dict(fd=f"fd-{FD_VER}-x86_64-apple-darwin.tar.gz",          rg=f"ripgrep-{RG_VER}-x86_64-apple-darwin.tar.gz"),
+    "windows-x64":  dict(fd=f"fd-{FD_VER}-x86_64-pc-windows-msvc.zip",         rg=f"ripgrep-{RG_VER}-x86_64-pc-windows-msvc.zip"),
+}
+
+def fetch(url):
+    import time
+    req = urllib.request.Request(url, headers={"User-Agent": "omnirush-release-builder"})
+    for attempt in range(3):
+        try:
+            with urllib.request.urlopen(req, timeout=300) as r:
+                return r.read()
+        except Exception as e:
+            if attempt == 2:
+                raise
+            print("retry", url.split("/")[-1], "after", e)
+            time.sleep(5)
+
+def extract_zip(data, dest):
+    os.makedirs(dest, exist_ok=True)
+    zf = zipfile.ZipFile(io.BytesIO(data))
+    zf.extractall(dest)
+
+def extract_tgz(data, dest):
+    os.makedirs(dest, exist_ok=True)
+    tf = tarfile.open(fileobj=io.BytesIO(data), mode="r:gz")
+    tf.extractall(dest)
+
+def find_bin(root, names):
+    for dirpath, _, files in os.walk(root):
+        for f in files:
+            if f in names:
+                return os.path.join(dirpath, f)
+    return None
+
+for plat, cfg in PLATFORMS.items():
+    if ONLY and plat not in ONLY:
+        continue
+    out_pre = f"omnirush-cli-{plat}.tar.gz" if plat == "linux-x64" else f"omnirush-cli-{plat}.zip"
+    if os.path.exists(out_pre) and not ONLY:
+        print("skip (built):", plat)
+        continue
+    stage = os.path.join(WORK, f"omnirush-cli-{plat}")
+    shutil.rmtree(stage, ignore_errors=True)
+    tmp = os.path.join(WORK, f".tmp-{plat}")
+    shutil.rmtree(tmp, ignore_errors=True)
+    os.makedirs(os.path.join(stage, ".runtime", "bin"))
+    os.makedirs(tmp)
+    shutil.copytree(os.path.join(REPO, "src"), os.path.join(stage, "src"))
+    shutil.copytree(os.path.join(REPO, "assets"), os.path.join(stage, "assets"))
+    shutil.copy2(os.path.join(REPO, "package.json"), os.path.join(stage, "package.json"))
+    exe = "bun.exe" if plat == "windows-x64" else "bun"
+    bun_plat = plat.replace("arm64", "aarch64")
+    bunzip = fetch(f"https://github.com/oven-sh/bun/releases/download/{BUN_VER}/bun-{bun_plat}.zip")
+    extract_zip(bunzip, tmp)
+    extracted_dir = os.path.join(tmp, f"bun-{bun_plat}")
+    shutil.copy2(os.path.join(extracted_dir, exe), os.path.join(stage, ".runtime", "bin", exe))
+    if plat != "windows-x64":
+        os.chmod(os.path.join(stage, ".runtime", "bin", "bun"), 0o755)
+    def fetch_extract(url, dest, cfg_value):
+        data = fetch(url)
+        if cfg_value.endswith(".zip"):
+            extract_zip(data, dest)
+        else:
+            extract_tgz(data, dest)
+    fetch_extract(f"https://github.com/sharkdp/fd/releases/download/{FD_VER}/{cfg['fd']}", os.path.join(tmp, "fd"), cfg["fd"])
+    fetch_extract(f"https://github.com/BurntSushi/ripgrep/releases/download/{RG_VER}/{cfg['rg']}", os.path.join(tmp, "rg"), cfg["rg"])
+    fb = find_bin(os.path.join(tmp, "fd"), {"fd", "fd.exe"})
+    rb = find_bin(os.path.join(tmp, "rg"), {"rg", "rg.exe"})
+    assert fb and rb, f"fd/rg not found for {plat}"
+    shutil.copy2(fb, os.path.join(stage, ".runtime", "bin", os.path.basename(fb)))
+    shutil.copy2(rb, os.path.join(stage, ".runtime", "bin", os.path.basename(rb)))
+    if plat == "linux-x64":
+        out = f"omnirush-cli-{plat}.tar.gz"
+        with tarfile.open(out, "w:gz") as t:
+            t.add(stage, arcname=os.path.basename(stage))
+    else:
+        with tarfile.open(f"omnirush-cli-{plat}.zip", "w") as t:  # plain zip via tarfile? no
+            pass
+        # use zipfile properly
+        import zipfile as zfmod
+        with zfmod.ZipFile(f"omnirush-cli-{plat}.zip", "w", zfmod.ZIP_DEFLATED) as z:
+            for dirpath, _, files in os.walk(stage):
+                for f in files:
+                    full = os.path.join(dirpath, f)
+                    z.write(full, os.path.relpath(full, WORK))
+    print("built", plat)
+    shutil.rmtree(stage, ignore_errors=True)
+    shutil.rmtree(tmp, ignore_errors=True)
+print("ALL PLATFORMS BUILT")

package/scripts/postinstall.js

@@ -145,11 +145,15 @@ function findFile(rootDir, fileName) {
   return null;
 }
 
-async function fetchBun(plat) {
-  const existing = path.join(RUNTIME, exe("bun"));
+export function managedBunPath() {
+  return path.join(RUNTIME, exe("bun"));
+}
+
+async function fetchBun(plat, log = console.log) {
+  const existing = managedBunPath();
   if (fs.existsSync(existing)) return;
   const zipUrl = `https://github.com/oven-sh/bun/releases/download/${BUN_VERSION}/bun-${bunAssetPlat(plat)}.zip`;
-  process.stdout.write(`omnirush: downloading agent runtime (bun for ${plat})...\n`);
+  log(`omnirush: downloading agent runtime (bun for ${plat})...`);
   const buf = await get(zipUrl);
   fs.mkdirSync(RUNTIME, { recursive: true });
   extractZip(buf, ROOT);
@@ -157,7 +161,7 @@ async function fetchBun(plat) {
   fs.copyFileSync(src, existing);
   if (process.platform !== "win32") fs.chmodSync(existing, 0o755);
   fs.rmSync(path.join(ROOT, `bun-${bunAssetPlat(plat)}`), { recursive: true, force: true });
-  console.log("omnirush: runtime ready");
+  log("omnirush: runtime ready");
 }
 
 // fd/rg release archives both nest the binary under a versioned directory
@@ -196,9 +200,14 @@ function rgAsset(plat) {
   return `ripgrep-${RG_VERSION}-${arch}-unknown-linux-musl`;
 }
 
-async function main() {
+/**
+ * Fetch the agent runtime when it is missing (idempotent: existing
+ * binaries are kept). Used by postinstall and by `omnirush doctor`
+ * self-heal. `log` defaults to console.log.
+ */
+export async function ensureRuntime({ log = console.log } = {}) {
   const plat = platform();
-  await fetchBun(plat);
+  await fetchBun(plat, log);
   for (const [name, version, repo, archive] of [
     ["fd", FD_VERSION, "sharkdp/fd", fdAsset(plat)],
     ["rg", RG_VERSION, "BurntSushi/ripgrep", rgAsset(plat)],
@@ -208,9 +217,17 @@ async function main() {
     } catch (error) {
       // Optional tools: warn and continue (the launcher only installs what
       // exists; the agent degrades to PATH lookup / built-in search).
-      console.warn(`omnirush: ${name} download failed (search may be degraded):`, error.message);
+      log(`omnirush: ${name} download failed (search may be degraded): ${error.message}`);
     }
   }
 }
 
-main().catch((e) => { console.error("omnirush postinstall:", e.message); process.exit(1); });
+async function main() {
+  await ensureRuntime();
+}
+
+// CLI entry (postinstall). Imported as a module by the launcher — never
+// exit there.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((e) => { console.error("omnirush postinstall:", e.message); process.exit(1); });
+}