tau-coding-agent 0.1.3 → 0.1.5

package/extensions/loop.ts

@@ -7,15 +7,16 @@
  */
 
 import { Type } from "typebox";
-import { complete, type Api, type Model, type UserMessage } from "@mariozechner/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
+import type { Api, Model, UserMessage } from "@earendil-works/pi-ai";
 import {
   compact,
   defineTool,
   DynamicBorder,
   type ExtensionAPI,
   type ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { Container, type SelectItem, SelectList, Text } from "@mariozechner/pi-tui";
+} from "@earendil-works/pi-coding-agent";
+import { Container, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
 
 const LOOP_PRESETS = [
   { value: "tests", label: "Until tests pass", description: "" },
@@ -213,6 +214,8 @@ async function loadState(ctx: ExtensionContext): Promise<LoopStateData> {
 
 export default function loopExtension(pi: ExtensionAPI): void {
   let loopState: LoopStateData = { active: false };
+  let lastAgentEndMessages: Array<{ role?: string; stopReason?: string }> = [];
+  let pendingLoopPrompt: ReturnType<typeof setImmediate> | undefined;
 
   function persistState(state: LoopStateData): void {
     pi.appendEntry(LOOP_STATE_ENTRY, state);
@@ -271,6 +274,23 @@ export default function loopExtension(pi: ExtensionAPI): void {
     );
   }
 
+  function scheduleLoopPrompt(ctx: ExtensionContext): void {
+    if (pendingLoopPrompt) return;
+
+    pendingLoopPrompt = setImmediate(() => {
+      pendingLoopPrompt = undefined;
+      if (!loopState.active || !ctx.isIdle()) return;
+      triggerLoopPrompt(ctx);
+    });
+    pendingLoopPrompt.unref?.();
+  }
+
+  function cancelScheduledLoopPrompt(): void {
+    if (!pendingLoopPrompt) return;
+    clearImmediate(pendingLoopPrompt);
+    pendingLoopPrompt = undefined;
+  }
+
   async function showLoopSelector(ctx: ExtensionContext): Promise<LoopStateData | null> {
     const items: SelectItem[] = LOOP_PRESETS.map((preset) => ({
       value: preset.value,
@@ -385,11 +405,11 @@ export default function loopExtension(pi: ExtensionAPI): void {
       name: "signal_loop_success",
       label: "Signal Loop Success",
       description:
-        "Stop the active loop when the breakout condition is satisfied. Only call this tool when explicitly instructed to do so by the user, tool or system prompt.",
+        "Stop the active loop when the breakout condition is satisfied. Only call signal_loop_success when explicitly instructed to do so by the user, tool, or system prompt.",
       promptSnippet: "Signal that the active /loop breakout condition has been satisfied",
       promptGuidelines: [
-        "Call this tool only when the active loop's breakout condition is actually satisfied.",
-        "Do not call this tool unless a loop is currently active.",
+        "Call signal_loop_success only when the active loop's breakout condition is actually satisfied.",
+        "Do not call signal_loop_success unless a loop is currently active.",
       ],
       parameters: Type.Object({}),
       async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
@@ -416,7 +436,7 @@ export default function loopExtension(pi: ExtensionAPI): void {
     handler: async (args, ctx) => {
       let nextState = parseArgs(args);
       if (!nextState) {
-        if (!ctx.hasUI) {
+        if (ctx.mode !== "tui") {
           ctx.ui.notify("Usage: /loop tests | /loop custom <condition> | /loop self", "warning");
           return;
         }
@@ -458,10 +478,14 @@ export default function loopExtension(pi: ExtensionAPI): void {
     },
   });
 
-  pi.on("agent_end", async (event, ctx) => {
+  pi.on("agent_end", async (event) => {
+    lastAgentEndMessages = event.messages;
+  });
+
+  pi.on("agent_settled", async (_event, ctx) => {
     if (!loopState.active) return;
 
-    if (ctx.hasUI && wasLastAssistantAborted(event.messages)) {
+    if (ctx.hasUI && wasLastAssistantAborted(lastAgentEndMessages)) {
       const confirm = await withPromptSignal(pi, () =>
         ctx.ui.confirm("Break active loop?", "Operation aborted. Break out of the loop?"),
       );
@@ -471,13 +495,13 @@ export default function loopExtension(pi: ExtensionAPI): void {
       }
     }
 
-    triggerLoopPrompt(ctx);
+    scheduleLoopPrompt(ctx);
   });
 
   pi.on("session_before_compact", async (event, ctx) => {
     if (!loopState.active || !loopState.mode || !ctx.model) return;
     const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
-    if (!auth.ok || !auth.apiKey) return;
+    if (!auth.ok) return;
 
     const instructionParts = [
       event.customInstructions,
@@ -526,4 +550,8 @@ export default function loopExtension(pi: ExtensionAPI): void {
   pi.on("session_start", async (_event, ctx) => {
     await restoreLoopState(ctx);
   });
+
+  pi.on("session_shutdown", async () => {
+    cancelScheduledLoopPrompt();
+  });
 }

package/extensions/memory.ts

@@ -1,11 +1,12 @@
-import { complete, StringEnum, type Api, type Model, type UserMessage } from "@mariozechner/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
+import { StringEnum, type Api, type Model, type UserMessage } from "@earendil-works/pi-ai";
 import {
   defineTool,
   withFileMutationQueue,
   type ExtensionAPI,
   type ExtensionCommandContext,
   type ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -1704,7 +1705,7 @@ export default function memoryExtension(pi: ExtensionAPI): void {
         description: `Update one .agents/memory/core block while enforcing the shared ${CORE_LINE_CAP}-line and ${CORE_CHAR_CAP}-character caps`,
         promptSnippet: `Update one core memory block in .agents/memory/core with ${CORE_LINE_CAP}-line and ${CORE_CHAR_CAP}-character cap enforcement`,
         promptGuidelines: [
-          "Use this tool when updating .agents/memory/core/directives.md, context.md, focus.md, or pending.md.",
+          "Use memory_update_block when updating .agents/memory/core/directives.md, context.md, focus.md, or pending.md.",
           `If a write would exceed the ${CORE_LINE_CAP}-line or ${CORE_CHAR_CAP}-character core cap, run memory_dream or remove content first.`,
         ],
         parameters: MEMORY_UPDATE_BLOCK_PARAMS,
@@ -1735,7 +1736,7 @@ export default function memoryExtension(pi: ExtensionAPI): void {
         description: "Append an entry to .agents/memory/log.md using the repo memory log format",
         promptSnippet: "Append an entry to the repo memory log at .agents/memory/log.md",
         promptGuidelines: [
-          "Use this tool for important decisions, discoveries, plans, experiments, prompt ingests, and attachment additions worth remembering.",
+          "Use memory_append_log for important decisions, discoveries, plans, experiments, prompt ingests, and attachment additions worth remembering.",
           "Use importance labels high, medium, or low.",
           "If this entry replaces or corrects prior memory, set supersedes and/or invalidates links explicitly.",
           "The memory log is append-only. Do not rewrite or truncate older entries.",
@@ -1773,7 +1774,7 @@ export default function memoryExtension(pi: ExtensionAPI): void {
         promptSnippet: "Consolidate repo memory with dream-based core compression",
         promptGuidelines: [
           "Dream is the only consolidation mechanism for .agents/memory/core.",
-          "Use this tool when logs have accumulated, core needs compression, or recent compaction context should be folded into memory.",
+          "Use memory_dream when logs have accumulated, core needs compression, or recent compaction context should be folded into memory.",
         ],
         parameters: MEMORY_DREAM_PARAMS,
         async execute(_toolCallId, params, _signal, _onUpdate, ctx) {

package/extensions/notify.ts

@@ -10,7 +10,8 @@
  * - Windows toast: Windows Terminal (WSL)
  */
 
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { execFile } from "node:child_process";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 const REVIEW_EVENT_START = "review:start";
 const REVIEW_EVENT_END = "review:end";
@@ -39,7 +40,6 @@ function notifyOSC99(title: string, body: string): void {
 }
 
 function notifyWindows(title: string, body: string): void {
-  const { execFile } = require("child_process");
   execFile("powershell.exe", ["-NoProfile", "-Command", windowsToastScript(title, body)]);
 }
 
@@ -92,13 +92,33 @@ export default function (pi: ExtensionAPI) {
   let pendingPromptCount = 0;
   const activeReviewSessions = new Set<string>();
   let currentSessionKey: string | undefined;
+  let pendingReadyNotification: ReturnType<typeof setImmediate> | undefined;
 
   const hasCurrentSessionReviewRun = () => {
     if (!currentSessionKey) return false;
     return activeReviewSessions.has(currentSessionKey);
   };
 
+  const cancelReadyNotification = () => {
+    if (!pendingReadyNotification) return;
+    clearImmediate(pendingReadyNotification);
+    pendingReadyNotification = undefined;
+  };
+
+  const scheduleReadyNotification = (ctx: ExtensionContext) => {
+    cancelReadyNotification();
+    pendingReadyNotification = setImmediate(() => {
+      pendingReadyNotification = undefined;
+      if (!ctx.isIdle()) return;
+      if (pendingPromptCount > 0) return;
+      if (hasCurrentSessionReviewRun()) return;
+      notify("Pi", "Ready for input");
+    });
+    pendingReadyNotification.unref?.();
+  };
+
   pi.on("session_start", async (_event, ctx) => {
+    cancelReadyNotification();
     currentSessionKey = getSessionKey(ctx);
   });
 
@@ -143,14 +163,13 @@ export default function (pi: ExtensionAPI) {
     notify("Pi", "Review failed");
   });
 
-  pi.on("agent_end", async (_event, ctx) => {
+  pi.on("agent_settled", async (_event, ctx) => {
     currentSessionKey = getSessionKey(ctx);
-    if (pendingPromptCount > 0) return;
-    if (hasCurrentSessionReviewRun()) return;
-    notify("Pi", "Ready for input");
+    scheduleReadyNotification(ctx);
   });
 
   pi.on("session_shutdown", async (_event, ctx) => {
+    cancelReadyNotification();
     pendingPromptCount = 0;
     const sessionKey = getSessionKey(ctx);
     activeReviewSessions.delete(sessionKey);

package/extensions/openai-fast.ts

@@ -1,7 +1,10 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 
 const STATUS_KEY = "openai-fast";
 const SUPPORTED_APIS = new Set([
@@ -23,8 +26,7 @@ function emptyConfig(): FastConfig {
 }
 
 function getConfigPath(): string {
-  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
-  return path.join(agentDir, "openai-fast.json");
+  return path.join(getAgentDir(), "openai-fast.json");
 }
 
 function isObject(value: unknown): value is JsonObject {

package/extensions/openai-verbosity.ts

@@ -1,7 +1,10 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 
 const STATUS_KEY = "openai-verbosity";
 const SUPPORTED_APIS = new Set([
@@ -23,8 +26,7 @@ function emptyConfig(): VerbosityConfig {
 }
 
 function getConfigPath(): string {
-  const agentDir = process.env.PI_CODING_AGENT_DIR ?? path.join(os.homedir(), ".pi", "agent");
-  return path.join(agentDir, "openai-verbosity.json");
+  return path.join(getAgentDir(), "openai-verbosity.json");
 }
 
 function isObject(value: unknown): value is JsonObject {

package/extensions/review/fix.ts

@@ -0,0 +1,239 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+import type { ReviewMessageQueue } from "./message-queue.js";
+import { buildAdditionalContextSection, FIX_PROMPT } from "./prompts.js";
+import { reviewMatchesFixRequest } from "./request.js";
+import { computeCurrentFingerprint, fingerprintsEqual } from "./git.js";
+import {
+  buildStalePayloadStaleness,
+  getLastMessageReviewDetails,
+  runReviewPipeline,
+} from "./review.js";
+import {
+  notify,
+  REVIEW_CANCELLED_ERROR,
+  type AgentEndMessage,
+  type AgentEndMessages,
+  type FixPassAgentTracker,
+} from "./runtime.js";
+import type { ParsedRequest, ReviewMessageDetails } from "./schema.js";
+
+const FIX_PASS_START_GRACE_MS = 1_000;
+
+const REVIEW_STALE_REUSE_WARNING =
+  "Last review is stale. Continuing with /fix. Run /review first to refresh it.";
+
+function buildFixPrompt(
+  reviewMessageDetails: ReviewMessageDetails,
+  additionalContext: string | undefined,
+): string {
+  const worklistPayload = JSON.stringify(
+    {
+      scope: reviewMessageDetails.scope,
+      ...(reviewMessageDetails.staleness ? { staleness: reviewMessageDetails.staleness } : {}),
+      findings: reviewMessageDetails.findings.map(
+        ({ priority, location, finding, suggestion, focus }) => ({
+          priority,
+          location,
+          finding,
+          suggestion,
+          focus,
+        }),
+      ),
+    },
+    null,
+    2,
+  );
+  const additionalContextSection = buildAdditionalContextSection(additionalContext);
+
+  return FIX_PROMPT.replace(
+    "{FIX_ADDITIONAL_CONTEXT_SECTION}",
+    () => additionalContextSection,
+  ).replace("{REVIEW_FINDINGS_JSON}", () => worklistPayload);
+}
+
+export async function prepareFixReviewDetails(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  request: ParsedRequest,
+  forceFreshReview = false,
+): Promise<ReviewMessageDetails | null> {
+  let reviewDetails = forceFreshReview ? null : getLastMessageReviewDetails(ctx);
+
+  if (reviewDetails && reviewMatchesFixRequest(reviewDetails, request)) {
+    const currentFingerprint = await computeCurrentFingerprint(
+      pi,
+      ctx.cwd,
+      reviewDetails.scope.mode === "working-tree" || reviewDetails.scope.mode === "folder",
+    );
+    const hasStalePayload = reviewDetails.staleness?.status === "stale";
+    const isStaleNow = !fingerprintsEqual(reviewDetails.fingerprint, currentFingerprint);
+    if (hasStalePayload || isStaleNow) {
+      reviewDetails = {
+        ...reviewDetails,
+        staleness: reviewDetails.staleness ?? buildStalePayloadStaleness(),
+      };
+      notify(ctx, REVIEW_STALE_REUSE_WARNING, "warning");
+    }
+  } else {
+    const reviewResult = await runReviewPipeline(pi, ctx, request, "fix");
+    if (!reviewResult.ok) {
+      if (reviewResult.error === REVIEW_CANCELLED_ERROR) {
+        notify(ctx, REVIEW_CANCELLED_ERROR, "error");
+      } else {
+        notify(ctx, `Cannot continue to /fix: ${reviewResult.error}`, "error");
+      }
+      return null;
+    }
+    reviewDetails = reviewResult.details;
+    if (reviewDetails.staleness?.status === "stale") {
+      notify(ctx, reviewDetails.staleness.nextStep, "warning");
+      return null;
+    }
+  }
+
+  if (reviewDetails.findings.length === 0) {
+    const failedFocusCount = countFailedFocusRuns(reviewDetails);
+    if (failedFocusCount > 0) {
+      notify(
+        ctx,
+        `Latest partial review had ${failedFocusCount} failed focus run(s) and no findings. Rerun /review before /fix.`,
+        "warning",
+      );
+      return null;
+    }
+
+    notify(ctx, "Review produced no findings. Nothing to fix.", "info");
+    return null;
+  }
+
+  return reviewDetails;
+}
+
+function countFailedFocusRuns(reviewDetails: ReviewMessageDetails): number {
+  return reviewDetails.focusStatus.filter((focus) => !focus.ok).length;
+}
+
+function notifyFixUsedPartialReview(ctx: ExtensionContext, failedFocusCount: number): void {
+  if (failedFocusCount === 0) return;
+  const failedLabel = `review${failedFocusCount === 1 ? "" : "s"}`;
+  notify(
+    ctx,
+    `Fix pass used partial review results: ${failedFocusCount} ${failedLabel} failed.`,
+    "warning",
+  );
+}
+
+function queueFixPass(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  reviewDetails: ReviewMessageDetails,
+  additionalContext: string | undefined,
+  options: { forceFollowUp?: boolean } = {},
+): { startsImmediately: boolean } {
+  const fixPrompt = buildFixPrompt(reviewDetails, additionalContext);
+  const startsImmediately = ctx.isIdle();
+  const delivery =
+    options.forceFollowUp || !startsImmediately || ctx.hasPendingMessages()
+      ? { deliverAs: "followUp" as const }
+      : undefined;
+  pi.sendUserMessage(fixPrompt, delivery);
+  notify(ctx, "Queued autonomous fix pass from review findings.", "info");
+  return { startsImmediately };
+}
+
+function getLastAssistantMessage(messages: AgentEndMessages): AgentEndMessage | undefined {
+  return messages.findLast((message) => message?.role === "assistant");
+}
+
+function wasLastAssistantAborted(messages: AgentEndMessages): boolean {
+  return getLastAssistantMessage(messages)?.stopReason === "aborted";
+}
+
+async function waitForPromptStartIfImmediate(
+  agentTracker: FixPassAgentTracker,
+  startCountBeforePrompt: number,
+  startsImmediately: boolean,
+): Promise<void> {
+  if (!startsImmediately) return;
+  await agentTracker.waitForStartAfter(startCountBeforePrompt, FIX_PASS_START_GRACE_MS);
+}
+
+async function waitForFixPassCompletion(
+  agentTracker: FixPassAgentTracker,
+): Promise<AgentEndMessages> {
+  await agentTracker.waitForNextSettled();
+  return agentTracker.getLastEnd()?.messages ?? [];
+}
+
+export async function runFixPassFromReview(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  reviewDetails: ReviewMessageDetails,
+  additionalContext: string | undefined,
+  agentTracker: FixPassAgentTracker,
+  reviewMessageQueue: ReviewMessageQueue,
+): Promise<AgentEndMessages> {
+  const failedFocusCount = countFailedFocusRuns(reviewDetails);
+  const fixPassFinished = waitForFixPassCompletion(agentTracker);
+
+  const startCountBeforeSteering = agentTracker.getStartCount();
+  const steeringStartsImmediately = ctx.isIdle();
+  const sentSteering = reviewMessageQueue.flushSteering(ctx, { forceFollowUp: true });
+  await waitForPromptStartIfImmediate(
+    agentTracker,
+    startCountBeforeSteering,
+    sentSteering && steeringStartsImmediately,
+  );
+
+  const startCountBeforeFix = agentTracker.getStartCount();
+  const fixPass = queueFixPass(pi, ctx, reviewDetails, additionalContext, {
+    forceFollowUp: sentSteering,
+  });
+  await waitForPromptStartIfImmediate(agentTracker, startCountBeforeFix, fixPass.startsImmediately);
+
+  const fixMessages = await fixPassFinished;
+  if (!wasLastAssistantAborted(fixMessages)) {
+    notifyFixUsedPartialReview(ctx, failedFocusCount);
+  }
+  return fixMessages;
+}
+
+export async function runFixLoop(
+  pi: ExtensionAPI,
+  ctx: ExtensionCommandContext,
+  request: ParsedRequest,
+  agentTracker: FixPassAgentTracker,
+  reviewMessageQueue: ReviewMessageQueue,
+): Promise<void> {
+  for (;;) {
+    const reviewDetails = await prepareFixReviewDetails(pi, ctx, request, true);
+    if (!reviewDetails) return;
+
+    const beforeFixFingerprint = reviewDetails.fingerprint;
+    const fixMessages = await runFixPassFromReview(
+      pi,
+      ctx,
+      reviewDetails,
+      request.additionalContext,
+      agentTracker,
+      reviewMessageQueue,
+    );
+    if (wasLastAssistantAborted(fixMessages)) {
+      notify(ctx, "Fix loop stopped: fix pass was aborted.", "warning");
+      return;
+    }
+
+    const afterFixFingerprint = await computeCurrentFingerprint(pi, ctx.cwd, true);
+    if (fingerprintsEqual(beforeFixFingerprint, afterFixFingerprint)) {
+      notify(ctx, "Fix loop stopped: fix pass made no repository changes.", "warning");
+      return;
+    }
+
+    notify(ctx, "Fix loop continuing with a fresh review...", "info");
+  }
+}