@nathapp/nax 0.37.0 → 0.38.1

package/src/commands/logs-formatter.ts

@@ -0,0 +1,201 @@
+/**
+ * Log formatting and display utilities
+ */
+
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import type { LogEntry, LogLevel } from "../logger/types";
+import { formatLogEntry, formatRunSummary } from "../logging/formatter";
+import type { VerbosityMode } from "../logging/types";
+import { extractRunSummary } from "./logs-reader";
+
+/**
+ * Log level hierarchy for filtering
+ */
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+/**
+ * Display runs table
+ */
+export async function displayRunsList(runsDir: string): Promise<void> {
+  const files = readdirSync(runsDir)
+    .filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl")
+    .sort()
+    .reverse();
+
+  if (files.length === 0) {
+    console.log(chalk.dim("No runs found"));
+    return;
+  }
+
+  console.log(chalk.bold("\nRuns:\n"));
+  console.log(chalk.gray("  Timestamp            Stories  Duration  Cost      Status"));
+  console.log(chalk.gray("  ─────────────────────────────────────────────────────────"));
+
+  for (const file of files) {
+    const filePath = join(runsDir, file);
+    const summary = await extractRunSummary(filePath);
+
+    const timestamp = file.replace(".jsonl", "");
+    const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
+    const duration = summary ? formatDuration(summary.durationMs) : "?";
+    const cost = summary ? `$${summary.totalCost.toFixed(4)}` : "$?.????";
+    const status = summary ? (summary.failed === 0 ? chalk.green("✓") : chalk.red("✗")) : "?";
+
+    console.log(`  ${timestamp}  ${stories.padEnd(7)}  ${duration.padEnd(8)}  ${cost.padEnd(8)}  ${status}`);
+  }
+
+  console.log();
+}
+
+/**
+ * Display static logs
+ */
+export async function displayLogs(
+  filePath: string,
+  options: { json?: boolean; story?: string; level?: LogLevel },
+): Promise<void> {
+  const file = Bun.file(filePath);
+  const content = await file.text();
+  const lines = content.trim().split("\n");
+
+  const mode: VerbosityMode = options.json ? "json" : "normal";
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    try {
+      const entry: LogEntry = JSON.parse(line);
+
+      if (!shouldDisplayEntry(entry, options)) {
+        continue;
+      }
+
+      const formatted = formatLogEntry(entry, { mode, useColor: true });
+
+      if (formatted.shouldDisplay && formatted.output) {
+        console.log(formatted.output);
+      }
+    } catch {
+      // Skip invalid JSON lines
+    }
+  }
+
+  if (!options.json) {
+    const summary = await extractRunSummary(filePath);
+    if (summary) {
+      console.log(formatRunSummary(summary, { mode: "normal", useColor: true }));
+    }
+  }
+}
+
+/**
+ * Follow logs in real-time (tail -f mode)
+ */
+export async function followLogs(
+  filePath: string,
+  options: { json?: boolean; story?: string; level?: LogLevel },
+): Promise<void> {
+  const mode: VerbosityMode = options.json ? "json" : "normal";
+
+  const file = Bun.file(filePath);
+  const content = await file.text();
+  const lines = content.trim().split("\n");
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    try {
+      const entry: LogEntry = JSON.parse(line);
+
+      if (!shouldDisplayEntry(entry, options)) {
+        continue;
+      }
+
+      const formatted = formatLogEntry(entry, { mode, useColor: true });
+
+      if (formatted.shouldDisplay && formatted.output) {
+        console.log(formatted.output);
+      }
+    } catch {
+      // Skip invalid JSON lines
+    }
+  }
+
+  let lastSize = (await Bun.file(filePath).stat()).size;
+
+  while (true) {
+    await Bun.sleep(500);
+
+    const currentSize = (await Bun.file(filePath).stat()).size;
+
+    if (currentSize > lastSize) {
+      const newFile = Bun.file(filePath);
+      const newContent = await newFile.text();
+      const newLines = newContent.slice(lastSize).trim().split("\n");
+
+      for (const line of newLines) {
+        if (!line.trim()) continue;
+
+        try {
+          const entry: LogEntry = JSON.parse(line);
+
+          if (!shouldDisplayEntry(entry, options)) {
+            continue;
+          }
+
+          const formatted = formatLogEntry(entry, { mode, useColor: true });
+
+          if (formatted.shouldDisplay && formatted.output) {
+            console.log(formatted.output);
+          }
+        } catch {
+          // Skip invalid JSON lines
+        }
+      }
+
+      lastSize = currentSize;
+    }
+  }
+}
+
+/**
+ * Check if entry should be displayed based on filters
+ */
+function shouldDisplayEntry(entry: LogEntry, options: { json?: boolean; story?: string; level?: LogLevel }): boolean {
+  if (options.story && entry.storyId !== options.story) {
+    return false;
+  }
+
+  if (options.level) {
+    const entryPriority = LOG_LEVEL_PRIORITY[entry.level];
+    const filterPriority = LOG_LEVEL_PRIORITY[options.level];
+
+    if (entryPriority < filterPriority) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Format duration in milliseconds
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  if (ms < 60000) {
+    return `${(ms / 1000).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.floor((ms % 60000) / 1000);
+  return `${minutes}m${seconds}s`;
+}

package/src/commands/logs-reader.ts

@@ -0,0 +1,171 @@
+/**
+ * Log reading and parsing utilities
+ */
+
+import { existsSync, readdirSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { LogEntry } from "../logger/types";
+import type { MetaJson } from "../pipeline/subscribers/registry";
+
+/**
+ * Swappable dependencies for testing
+ */
+export const _deps = {
+  getRunsDir: () => process.env.NAX_RUNS_DIR ?? join(homedir(), ".nax", "runs"),
+};
+
+/**
+ * Resolve log file path for a runId from the central registry
+ */
+export async function resolveRunFileFromRegistry(runId: string): Promise<string | null> {
+  const runsDir = _deps.getRunsDir();
+
+  let entries: string[];
+  try {
+    entries = await readdir(runsDir);
+  } catch {
+    throw new Error(`Run not found in registry: ${runId}`);
+  }
+
+  let matched: MetaJson | null = null;
+  for (const entry of entries) {
+    const metaPath = join(runsDir, entry, "meta.json");
+    try {
+      const meta: MetaJson = await Bun.file(metaPath).json();
+      if (meta.runId === runId || meta.runId.startsWith(runId)) {
+        matched = meta;
+        break;
+      }
+    } catch {
+      // skip unreadable meta.json entries
+    }
+  }
+
+  if (!matched) {
+    throw new Error(`Run not found in registry: ${runId}`);
+  }
+
+  if (!existsSync(matched.eventsDir)) {
+    console.log(`Log directory unavailable for run: ${runId}`);
+    return null;
+  }
+
+  const files = readdirSync(matched.eventsDir)
+    .filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl")
+    .sort()
+    .reverse();
+
+  if (files.length === 0) {
+    console.log(`No log files found for run: ${runId}`);
+    return null;
+  }
+
+  const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
+  return join(matched.eventsDir, specificFile ?? files[0]);
+}
+
+/**
+ * Select latest run file from directory
+ */
+export async function selectRunFile(runsDir: string): Promise<string | null> {
+  const files = readdirSync(runsDir)
+    .filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl")
+    .sort()
+    .reverse();
+
+  if (files.length === 0) {
+    return null;
+  }
+
+  return join(runsDir, files[0]);
+}
+
+/**
+ * Extract run summary from log file
+ */
+export async function extractRunSummary(filePath: string): Promise<{
+  total: number;
+  passed: number;
+  failed: number;
+  skipped: number;
+  durationMs: number;
+  totalCost: number;
+  startedAt: string;
+  completedAt: string | undefined;
+} | null> {
+  const file = Bun.file(filePath);
+  const content = await file.text();
+  const lines = content.trim().split("\n");
+
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  let totalCost = 0;
+  let startedAt = "";
+  let completedAt: string | undefined;
+  let firstTimestamp = "";
+  let lastTimestamp = "";
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    try {
+      const entry: LogEntry = JSON.parse(line);
+
+      if (!firstTimestamp) {
+        firstTimestamp = entry.timestamp;
+      }
+      lastTimestamp = entry.timestamp;
+
+      if (entry.stage === "run.start") {
+        startedAt = entry.timestamp;
+        const runData = entry.data as Record<string, unknown>;
+        total = typeof runData?.totalStories === "number" ? runData.totalStories : 0;
+      }
+
+      if (entry.stage === "story.complete" || entry.stage === "agent.complete") {
+        const data = entry.data as Record<string, unknown>;
+        const success = data?.success ?? true;
+        const action = data?.finalAction || data?.action;
+
+        if (success) {
+          passed++;
+        } else if (action === "skip") {
+          skipped++;
+        } else {
+          failed++;
+        }
+
+        if (data?.cost && typeof data.cost === "number") {
+          totalCost += data.cost;
+        }
+      }
+
+      if (entry.stage === "run.end") {
+        completedAt = entry.timestamp;
+      }
+    } catch {
+      // Skip invalid JSON lines
+    }
+  }
+
+  if (!startedAt) {
+    return null;
+  }
+
+  const durationMs = lastTimestamp ? new Date(lastTimestamp).getTime() - new Date(firstTimestamp).getTime() : 0;
+
+  return {
+    total,
+    passed,
+    failed,
+    skipped,
+    durationMs,
+    totalCost,
+    startedAt,
+    completedAt,
+  };
+}