@elench/testkit 0.1.84 → 0.1.85

package/lib/cli/agents/investigation-interpreter.mjs

@@ -0,0 +1,320 @@
+const INSPECT_COMMANDS = new Set([
+  "cat",
+  "find",
+  "grep",
+  "head",
+  "ls",
+  "open",
+  "read",
+  "rg",
+  "sed",
+  "tail",
+]);
+
+const EDIT_COMMANDS = new Set([
+  "apply_patch",
+  "cp",
+  "ed",
+  "mv",
+  "perl",
+  "python",
+  "python3",
+  "ruby",
+  "tee",
+  "write",
+]);
+
+const RERUN_COMMANDS = new Set([
+  "npm",
+  "npx",
+  "pnpm",
+  "pytest",
+  "testkit",
+  "vitest",
+  "yarn",
+]);
+
+const PHASE_LABELS = {
+  planning: "Planning investigation",
+  inspecting: "Inspecting relevant files",
+  editing: "Editing candidate fix",
+  rerunning: "Rerunning validation",
+  summarizing: "Summarizing outcome",
+};
+
+export function createInvestigationInterpreter() {
+  let phase = "planning";
+  let timeline = [];
+  let activeStepId = null;
+  let nextId = 1;
+  let inspectedCount = 0;
+  let rerunCount = 0;
+  const editedFiles = new Set();
+
+  pushTimeline({
+    kind: "phase",
+    phase,
+    label: PHASE_LABELS[phase],
+  });
+
+  return {
+    consumeProviderEvent(event) {
+      if (!event || !event.type) return getSnapshot();
+
+      if (event.type === "start") {
+        setPhase("planning");
+        activateStep("planning", "Preparing investigation", "active");
+        return getSnapshot();
+      }
+
+      if (event.type === "tool") {
+        handleToolEvent(event);
+        return getSnapshot();
+      }
+
+      if (event.type === "status") {
+        handleStatusEvent(event);
+        return getSnapshot();
+      }
+
+      if (event.type === "error") {
+        failActiveStep();
+        pushTimeline({
+          kind: "notice",
+          severity: "error",
+          message: event.message || "Agent error",
+        });
+        return getSnapshot();
+      }
+
+      if (event.type === "final") {
+        finalizeWithText(event.text || "");
+        return getSnapshot();
+      }
+
+      if (event.type === "exit" && Number(event.code) !== 0) {
+        failActiveStep();
+        pushTimeline({
+          kind: "notice",
+          severity: "error",
+          message: `Agent exited with code ${event.code}`,
+        });
+        return getSnapshot();
+      }
+
+      return getSnapshot();
+    },
+
+    getSnapshot,
+  };
+
+  function getSnapshot() {
+    return {
+      phase,
+      activeStep: activeStepId ? findTimeline(activeStepId) : null,
+      timeline: timeline.map((entry) => ({
+        ...entry,
+        files: Array.isArray(entry.files) ? [...entry.files] : entry.files,
+      })),
+      summary: {
+        inspectedCount,
+        rerunCount,
+        editedFiles: [...editedFiles].sort(),
+      },
+    };
+  }
+
+  function handleToolEvent(event) {
+    const commandText = String(event.name || "").trim();
+    const detailText = String(event.detail || "").trim();
+    const command = firstToken(commandText);
+
+    if (RERUN_COMMANDS.has(command) || /(?:^|\s)(testkit|vitest|pytest|npm|pnpm|yarn)(?:\s|$)/i.test(commandText)) {
+      setPhase("rerunning");
+      rerunCount += 1;
+      activateStep("rerunning", "Rerunning validation", "active", compactDetail(commandText, detailText));
+      pushTimeline({
+        kind: "rerun",
+        summary: compactDetail(commandText, detailText) || commandText,
+        command: commandText || detailText || null,
+      });
+      return;
+    }
+
+    if (EDIT_COMMANDS.has(command) || /apply_patch|write|edit/i.test(commandText)) {
+      setPhase("editing");
+      const files = extractFileHints(`${commandText} ${detailText}`);
+      for (const file of files) editedFiles.add(file);
+      activateStep(
+        "editing",
+        "Editing candidate fix",
+        "active",
+        files.length > 0 ? `${files.length} file${files.length === 1 ? "" : "s"} touched` : compactDetail(commandText, detailText)
+      );
+      if (files.length > 0) {
+        upsertTimeline(
+          "latest-edit",
+          {
+            kind: "edit",
+            summary: `Edited ${files.length} file${files.length === 1 ? "" : "s"}`,
+            files,
+          },
+          true
+        );
+      }
+      return;
+    }
+
+    if (INSPECT_COMMANDS.has(command) || /git|diff|read|search|inspect|open/i.test(commandText)) {
+      setPhase("inspecting");
+      inspectedCount += 1;
+      activateStep(
+        "inspecting",
+        "Inspecting relevant files",
+        "active",
+        `${inspectedCount} check${inspectedCount === 1 ? "" : "s"}`
+      );
+      return;
+    }
+
+    setPhase("inspecting");
+    activateStep("inspecting", "Inspecting relevant files", "active", compactDetail(commandText, detailText));
+  }
+
+  function handleStatusEvent(event) {
+    const message = String(event.message || "").trim();
+    if (!message) return;
+    if (/error|failed|exception/i.test(message)) {
+      pushTimeline({
+        kind: "notice",
+        severity: "warning",
+        message,
+      });
+      return;
+    }
+    if (/plan|thinking|analy/i.test(message) && phase === "planning") {
+      activateStep("planning", "Planning investigation", "active", "Gathering context");
+    }
+  }
+
+  function finalizeWithText(text) {
+    setPhase("summarizing");
+    completeActiveStep();
+    const summary = summarizeFinalText(text);
+    if (summary) {
+      pushTimeline({
+        kind: "result",
+        summary,
+        finalText: text,
+      });
+      if (/root cause|likely|caused by|problem/i.test(summary)) {
+        pushTimeline({
+          kind: "finding",
+          severity: "info",
+          summary,
+          confidence: inferConfidence(summary),
+        });
+      }
+    }
+  }
+
+  function setPhase(nextPhase) {
+    if (!nextPhase || nextPhase === phase) return;
+    completeActiveStep();
+    phase = nextPhase;
+    pushTimeline({
+      kind: "phase",
+      phase,
+      label: PHASE_LABELS[phase] || nextPhase,
+    });
+  }
+
+  function activateStep(key, label, status, detail = null) {
+    const stepId = `step:${key}`;
+    upsertTimeline(
+      stepId,
+      {
+        kind: "step",
+        label,
+        status,
+        detail,
+      },
+      false
+    );
+    activeStepId = stepId;
+  }
+
+  function completeActiveStep() {
+    if (!activeStepId) return;
+    const entry = findTimeline(activeStepId);
+    if (entry && entry.status === "active") entry.status = "done";
+    activeStepId = null;
+  }
+
+  function failActiveStep() {
+    if (!activeStepId) return;
+    const entry = findTimeline(activeStepId);
+    if (entry) entry.status = "failed";
+    activeStepId = null;
+  }
+
+  function findTimeline(id) {
+    return timeline.find((entry) => entry.id === id) || null;
+  }
+
+  function pushTimeline(entry) {
+    timeline.push({
+      id: `timeline:${nextId += 1}`,
+      at: Date.now(),
+      ...entry,
+    });
+  }
+
+  function upsertTimeline(id, entry, replaceFiles = false) {
+    const existing = findTimeline(id);
+    if (existing) {
+      Object.assign(existing, entry);
+      if (replaceFiles && Array.isArray(entry.files)) existing.files = [...entry.files];
+      return existing;
+    }
+    const nextEntry = {
+      id,
+      at: Date.now(),
+      ...entry,
+    };
+    timeline.push(nextEntry);
+    return nextEntry;
+  }
+}
+
+function firstToken(commandText) {
+  const normalized = String(commandText || "").trim();
+  if (!normalized) return "";
+  return normalized.split(/\s+/)[0].toLowerCase();
+}
+
+function compactDetail(commandText, detailText) {
+  if (commandText && detailText && detailText !== commandText) {
+    return `${commandText} (${detailText})`;
+  }
+  return commandText || detailText || null;
+}
+
+function summarizeFinalText(text) {
+  const normalized = String(text || "").trim();
+  if (!normalized) return "";
+  const [firstParagraph] = normalized.split(/\n\s*\n/);
+  const [firstSentence] = firstParagraph.split(/(?<=[.!?])\s+/);
+  return firstSentence.trim();
+}
+
+function inferConfidence(summary) {
+  if (/definitely|confirmed|root cause/i.test(summary)) return "high";
+  if (/likely|probably|appears/i.test(summary)) return "medium";
+  return "low";
+}
+
+function extractFileHints(text) {
+  const matches = String(text || "").match(/[A-Za-z0-9_./-]+\.(?:mjs|js|cjs|ts|tsx|jsx|json|md)/g) || [];
+  return [...new Set(matches)];
+}

package/lib/cli/agents/investigation-log.mjs

@@ -0,0 +1,37 @@
+import fs from "fs";
+import path from "path";
+
+export function writeInvestigationLog({ productDir, selectedFailure, agentSession } = {}) {
+  if (!productDir || !selectedFailure || !agentSession) return null;
+
+  try {
+    const rootDir = path.join(productDir, ".testkit", "agent-sessions");
+    fs.mkdirSync(rootDir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const fileName = `${stamp}-${sanitize(selectedFailure.serviceName)}-${sanitize(path.basename(selectedFailure.filePath))}.json`;
+    const filePath = path.join(rootDir, fileName);
+    const payload = {
+      serviceName: selectedFailure.serviceName,
+      filePath: selectedFailure.filePath,
+      provider: agentSession.provider,
+      status: agentSession.status,
+      startedAt: agentSession.startedAt || null,
+      endedAt: agentSession.endedAt || null,
+      finalText: agentSession.finalText || "",
+      error: agentSession.error || null,
+      exitCode: agentSession.exitCode ?? null,
+      transcriptEntries: agentSession.transcriptEntries || [],
+      timeline: agentSession.timeline || [],
+      summary: agentSession.summary || null,
+      activePhase: agentSession.activePhase || null,
+    };
+    fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+    return filePath;
+  } catch {
+    return null;
+  }
+}
+
+function sanitize(value) {
+  return String(value || "unknown").replace(/[^A-Za-z0-9._-]+/g, "-");
+}

package/lib/cli/presentation/tree-reporter.mjs

@@ -4,10 +4,13 @@ import { createRunSessionState } from "../tui/run-session-state.mjs";
 import { RunSessionApp } from "../tui/run-session-app.mjs";
 import { suiteSelectionType } from "../../runner/suite-selection.mjs";
 import { startHostedInvestigation } from "../agents/investigate.mjs";
+import { createInvestigationInterpreter } from "../agents/investigation-interpreter.mjs";
+import { writeInvestigationLog } from "../agents/investigation-log.mjs";
 
 export function createTreeReporter({ stdout = process.stdout, stderr = process.stderr, productDir } = {}) {
   const sessionState = createRunSessionState();
   let activeAgentSession = null;
+  let activeInterpreter = null;
   let investigationToken = 0;
 
   const app = render(
@@ -101,9 +104,11 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     }
 
     const token = ++investigationToken;
+    let finalDelivered = false;
     sessionState.beginInvestigation({ provider, userMessage });
 
     try {
+      activeInterpreter = createInvestigationInterpreter();
       activeAgentSession = startHostedInvestigation({
         productDir,
         serviceName: snapshot.selectedFailure.serviceName,
@@ -112,28 +117,43 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
         userMessage,
         onEvent(event) {
           if (token !== investigationToken) return;
-          sessionState.appendAgentEvent(event);
+          if (event.type === "final") finalDelivered = true;
+          const presentation = activeInterpreter?.consumeProviderEvent(event) || null;
+          sessionState.recordInvestigationProgress(event, presentation);
         },
       });
       const result = await activeAgentSession.completion;
       if (token !== investigationToken) return;
       activeAgentSession = null;
+      if (result.finalText && !finalDelivered) {
+        const finalEvent = { type: "final", text: result.finalText };
+        const presentation = activeInterpreter?.consumeProviderEvent(finalEvent) || null;
+        sessionState.recordInvestigationProgress(finalEvent, presentation);
+      }
       if (result.cancelled) {
         sessionState.cancelAgentSession("Cancelled investigation.");
+        persistInvestigationLog();
+        activeInterpreter = null;
         return;
       }
       if (result.exitCode !== 0 && !result.finalText) {
         sessionState.failAgentSession(result.stderr || `Agent exited with code ${result.exitCode}`);
+        persistInvestigationLog();
+        activeInterpreter = null;
         return;
       }
       sessionState.completeAgentSession({
         finalText: result.finalText,
         exitCode: result.exitCode,
       });
+      persistInvestigationLog();
+      activeInterpreter = null;
     } catch (error) {
       if (token !== investigationToken) return;
       activeAgentSession = null;
       sessionState.failAgentSession(error);
+      persistInvestigationLog();
+      activeInterpreter = null;
     }
   }
 
@@ -146,6 +166,8 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     activeAgentSession.cancel();
     activeAgentSession = null;
     sessionState.cancelAgentSession("Cancelled investigation.");
+    persistInvestigationLog();
+    activeInterpreter = null;
   }
 
   function close() {
@@ -156,4 +178,14 @@ export function createTreeReporter({ stdout = process.stdout, stderr = process.s
     }
     app.unmount();
   }
+
+  function persistInvestigationLog() {
+    const snapshot = sessionState.getSnapshot();
+    if (!snapshot.selectedFailure || !snapshot.agentSession) return;
+    writeInvestigationLog({
+      productDir,
+      selectedFailure: snapshot.selectedFailure,
+      agentSession: snapshot.agentSession,
+    });
+  }
 }

package/lib/cli/tui/run-session-app.mjs

@@ -100,6 +100,10 @@ export function RunSessionApp({
     }
 
     if (snapshot.mode === "investigating") {
+      if (input === "t") {
+        sessionState.toggleInvestigationViewMode();
+        return;
+      }
       if (input === "x") {
         onCancelInvestigation?.();
         return;
@@ -159,9 +163,9 @@ export function buildFooterText(snapshot) {
   if (!snapshot.finished) return "Run in progress";
   if (snapshot.mode === "investigating") {
     if (snapshot.agentSession?.status === "running" || snapshot.agentSession?.status === "starting") {
-      return "x cancel investigation · q quit";
+      return "t transcript · x cancel investigation · q quit";
     }
-    return "b back to summary · q quit";
+    return "t transcript · b back to summary · q quit";
   }
   if (!snapshot.selectedFailure) return "q quit";
   return "↑/↓ select failure · y investigate · c Claude · o Codex · q quit";
@@ -329,7 +333,9 @@ function buildFailureDetailPane(snapshot, detailLines) {
 }
 
 function buildAgentPane(snapshot) {
-  const entries = snapshot.agentSession?.entries || [];
+  const transcriptEntries = snapshot.agentSession?.transcriptEntries || [];
+  const timeline = snapshot.agentSession?.timeline || [];
+  const viewMode = snapshot.agentSession?.viewMode || "summary";
   const status = snapshot.agentSession?.status || "idle";
   const statusText =
     status === "running" || status === "starting"
@@ -337,21 +343,77 @@ function buildAgentPane(snapshot) {
       : status === "error"
         ? red(`Status: ${status}`)
         : green(`Status: ${status}`);
-
-  const renderedEntries = entries.length === 0
-    ? [createElement(Text, { key: "agent-empty" }, dim("Waiting for agent output..."))]
-    : entries.slice(-32).map((entry, index) =>
-        createElement(Text, { key: `agent-${index}` }, formatAgentEntry(entry))
-      );
+  const phaseText = snapshot.agentSession?.activePhase
+    ? dim(`Phase: ${snapshot.agentSession.activePhase}`)
+    : dim("Phase: planning");
 
   return [
     createElement(Text, { key: "agent-title" }, bold("Investigation")),
     createElement(Text, { key: "agent-status" }, statusText),
+    createElement(Text, { key: "agent-phase" }, phaseText),
     createElement(Text, { key: "agent-gap" }, ""),
-    ...renderedEntries,
+    ...(viewMode === "transcript"
+      ? buildTranscriptEntries(transcriptEntries)
+      : buildSummaryEntries(snapshot.agentSession, timeline)),
   ];
 }
 
+function buildSummaryEntries(agentSession, timeline) {
+  const summaryLines = [];
+  const activeStep = agentSession?.activeStep || null;
+  const summary = agentSession?.summary || { inspectedCount: 0, rerunCount: 0, editedFiles: [] };
+
+  if (activeStep?.label) {
+    summaryLines.push(
+      createElement(Text, { key: "summary-step" }, `${yellow(figures.pointerSmall)} ${activeStep.label}${activeStep.detail ? ` ${dim(`· ${activeStep.detail}`)}` : ""}`)
+    );
+  }
+
+  if (summary.inspectedCount > 0 || summary.editedFiles.length > 0 || summary.rerunCount > 0) {
+    const parts = [];
+    if (summary.inspectedCount > 0) parts.push(`${summary.inspectedCount} check${summary.inspectedCount === 1 ? "" : "s"}`);
+    if (summary.editedFiles.length > 0) parts.push(`${summary.editedFiles.length} file${summary.editedFiles.length === 1 ? "" : "s"} edited`);
+    if (summary.rerunCount > 0) parts.push(`${summary.rerunCount} rerun${summary.rerunCount === 1 ? "" : "s"}`);
+    summaryLines.push(createElement(Text, { key: "summary-counts" }, dim(parts.join(" · "))));
+  }
+
+  const renderedTimeline = timeline.filter((entry) => entry.kind !== "step").slice(-8);
+  if (renderedTimeline.length === 0) {
+    summaryLines.push(createElement(Text, { key: "summary-empty" }, dim("Waiting for investigation progress...")));
+    return summaryLines;
+  }
+
+  summaryLines.push(createElement(Text, { key: "summary-gap-2" }, ""));
+  for (let index = 0; index < renderedTimeline.length; index += 1) {
+    const entry = renderedTimeline[index];
+    summaryLines.push(
+      createElement(Text, { key: `timeline-${index}` }, formatTimelineEntry(entry))
+    );
+  }
+  return summaryLines;
+}
+
+function buildTranscriptEntries(entries) {
+  if (entries.length === 0) {
+    return [createElement(Text, { key: "agent-empty" }, dim("Waiting for agent output..."))];
+  }
+  return entries.slice(-24).map((entry, index) =>
+    createElement(Text, { key: `agent-${index}` }, formatAgentEntry(entry))
+  );
+}
+
+export function formatTimelineEntry(entry) {
+  if (entry.kind === "phase") return dim(entry.label);
+  if (entry.kind === "finding") return `${yellow(figures.bullet)} ${entry.summary}`;
+  if (entry.kind === "edit") return `${yellow(figures.bullet)} ${entry.summary}`;
+  if (entry.kind === "rerun") return `${yellow(figures.bullet)} ${entry.summary}`;
+  if (entry.kind === "result") return `${green(figures.tick)} ${entry.summary}`;
+  if (entry.kind === "notice") {
+    return entry.severity === "error" ? red(entry.message) : yellow(entry.message);
+  }
+  return entry.label || entry.summary || entry.message || "";
+}
+
 export function formatAgentEntry(entry) {
   if (entry.kind === "tool") return yellow(`[tool] ${entry.text}`);
   if (entry.kind === "status") return dim(`[status] ${entry.text}`);

package/lib/cli/tui/run-session-state.mjs

@@ -125,7 +125,7 @@ export function createRunSessionState() {
   function appendTranscriptEntry(kind, text) {
     if (!agentSession || !text) return;
     const normalizedText = String(text);
-    const entries = agentSession.entries || [];
+    const entries = agentSession.transcriptEntries || [];
     const lastEntry = entries.at(-1);
     if (kind === "assistant" && lastEntry?.kind === "assistant") {
       lastEntry.text += normalizedText;
@@ -133,7 +133,7 @@ export function createRunSessionState() {
       return;
     }
     entries.push({ kind, text: normalizedText });
-    agentSession.entries = entries;
+    agentSession.transcriptEntries = entries;
     agentSession.updatedAt = Date.now();
   }
 
@@ -324,19 +324,26 @@ export function createRunSessionState() {
         status: "starting",
         startedAt: Date.now(),
         updatedAt: Date.now(),
-        entries: [],
+        rawEvents: [],
+        transcriptEntries: [],
+        timeline: [],
+        summary: null,
+        activePhase: "planning",
+        activeStep: null,
+        viewMode: "summary",
       };
       notify();
     },
 
-    appendAgentEvent(event) {
+    recordInvestigationProgress(event, presentation = null) {
       if (!agentSession || !event) return;
+      agentSession.rawEvents.push({ ...event });
       if (event.type === "start") {
         agentSession.status = "running";
       } else if (event.type === "delta") {
         appendTranscriptEntry("assistant", event.text || "");
       } else if (event.type === "final") {
-        if (event.text && !(agentSession.entries || []).some((entry) => entry.kind === "assistant")) {
+        if (event.text && !(agentSession.transcriptEntries || []).some((entry) => entry.kind === "assistant")) {
           appendTranscriptEntry("assistant", event.text);
         }
         agentSession.finalText = event.text || agentSession.finalText || "";
@@ -349,6 +356,23 @@ export function createRunSessionState() {
       } else if (event.type === "exit") {
         agentSession.exitCode = event.code;
       }
+
+      if (presentation) {
+        agentSession.activePhase = presentation.phase || agentSession.activePhase || null;
+        agentSession.activeStep = presentation.activeStep || null;
+        agentSession.timeline = presentation.timeline || [];
+        agentSession.summary = presentation.summary || null;
+      }
+      notify();
+    },
+
+    appendAgentEvent(event) {
+      this.recordInvestigationProgress(event);
+    },
+
+    toggleInvestigationViewMode() {
+      if (!agentSession) return;
+      agentSession.viewMode = agentSession.viewMode === "summary" ? "transcript" : "summary";
       notify();
     },
 

package/node_modules/@elench/next-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/next-analysis",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "SWC-backed Next.js source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/node_modules/@elench/testkit-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-bridge",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "Browser bridge helpers for testkit",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@elench/testkit-protocol": "0.1.84"
+    "@elench/testkit-protocol": "0.1.85"
   },
   "private": false
 }

package/node_modules/@elench/testkit-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit-protocol",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "Shared browser protocol for testkit bridge and extension consumers",
   "type": "module",
   "main": "./dist/index.js",

package/node_modules/@elench/ts-analysis/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/ts-analysis",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "TypeScript compiler-backed source analysis primitives for Erench tools",
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.84",
+  "version": "0.1.85",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "workspaces": [
@@ -82,10 +82,10 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.0",
-    "@elench/next-analysis": "0.1.84",
-    "@elench/testkit-bridge": "0.1.84",
-    "@elench/testkit-protocol": "0.1.84",
-    "@elench/ts-analysis": "0.1.84",
+    "@elench/next-analysis": "0.1.85",
+    "@elench/testkit-bridge": "0.1.85",
+    "@elench/testkit-protocol": "0.1.85",
+    "@elench/ts-analysis": "0.1.85",
     "@oclif/core": "^4.10.6",
     "esbuild": "^0.25.11",
     "execa": "^9.5.0",