@gotgenes/pi-autoformat 0.1.0 → 4.0.3

package/src/extension.ts

@@ -1,56 +1,84 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ToolCallEvent,
+  ToolResultEvent,
+} from "@mariozechner/pi-coding-agent";
+
 import {
   AUTOFORMAT_EXTENSION_ID,
   type ConfigValidationIssue,
   type LoadConfigResult,
   loadAutoformatConfig,
 } from "./config-loader.js";
+import {
+  createCustomToolHandlers,
+  parseTouchedPayload,
+} from "./custom-mutation-tools.js";
+import { resolveFormatScope } from "./format-scope.js";
 import type { AutoformatConfig } from "./formatter-config.js";
 import type { CommandRunner, CommandRunResult } from "./formatter-executor.js";
+import { formatRunOutputBlock } from "./formatter-output-report.js";
 import {
   PromptAutoformatter,
   type PromptAutoformatterResult,
 } from "./prompt-autoformatter.js";
+import {
+  matchWrapper,
+  parseKnownCommand,
+  SnapshotTracker,
+} from "./shell-mutation-detector.js";
+import {
+  type MutationSourceHandler,
+  writeOrEditHandler,
+} from "./touched-files-queue.js";
 
 const execFileAsync = promisify(execFile);
 const COMMAND_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
 
 type NotificationType = "info" | "warning" | "error";
 
-type ExtensionContextLike = {
-  cwd: string;
-  hasUI: boolean;
-  ui: {
-    notify(message: string, type?: NotificationType): void;
-  };
-};
+/**
+ * Narrowed view of Pi's real `ExtensionContext`, restricted to the surface
+ * this extension actually consumes. Pi's full `ExtensionContext` requires
+ * `sessionManager`, `modelRegistry`, `model`, `signal`, `isIdle`, etc., none
+ * of which the autoformatter uses. Internal helpers take this narrow alias
+ * so test stubs do not have to fabricate the unused fields, while top-level
+ * `pi.on(...)` handlers still receive the real `ExtensionContext` from Pi.
+ */
+type AutoformatExtensionContext = Pick<
+  ExtensionContext,
+  "cwd" | "hasUI" | "ui"
+>;
 
-type ToolResultEventLike = {
-  toolName: string;
-  input: unknown;
-  isError: boolean;
-};
+/**
+ * Re-export of Pi's real `ExtensionAPI` under the legacy `ExtensionApiLike`
+ * name so any downstream importer that pinned to the old alias keeps working.
+ * Internal usage prefers `ExtensionAPI` directly.
+ */
+export type ExtensionApiLike = ExtensionAPI;
 
-type ExtensionHandler<TEvent> = (
-  event: TEvent,
-  ctx: ExtensionContextLike,
-) => void | Promise<void>;
-
-type ExtensionApiLike = {
-  on(eventName: "session_start", handler: ExtensionHandler<unknown>): void;
-  on(
-    eventName: "tool_result",
-    handler: ExtensionHandler<ToolResultEventLike>,
-  ): void;
-  on(eventName: "agent_end", handler: ExtensionHandler<unknown>): void;
-  on(eventName: "session_shutdown", handler: ExtensionHandler<unknown>): void;
-};
+const AUTOFORMAT_STATUS_KEY = "autoformat";
+
+function setAutoformatStatus(
+  ctx: AutoformatExtensionContext,
+  text: string | undefined,
+): void {
+  if (!ctx.hasUI) {
+    return;
+  }
+  if (typeof ctx.ui.setStatus !== "function") {
+    return;
+  }
+  ctx.ui.setStatus(AUTOFORMAT_STATUS_KEY, text);
+}
 
 type PromptAutoformatterLike = Pick<
   PromptAutoformatter,
-  "recordToolResult" | "flushPrompt"
+  "recordToolResult" | "flushPrompt" | "addTouchedPath"
 >;
 
 type AutoformatExtensionDependencies = {
@@ -63,13 +91,13 @@ type AutoformatExtensionDependencies = {
     result: PromptAutoformatterResult,
     options: {
       config: AutoformatConfig;
-      ctx: ExtensionContextLike;
+      ctx: AutoformatExtensionContext;
     },
   ) => void;
   reportConfigIssues?: (
     issues: ConfigValidationIssue[],
     options: {
-      ctx: ExtensionContextLike;
+      ctx: AutoformatExtensionContext;
     },
   ) => void;
 };
@@ -78,6 +106,8 @@ type SessionState = {
   cwd: string;
   loadResult: LoadConfigResult;
   autoformatter: PromptAutoformatterLike;
+  snapshotTracker: SnapshotTracker | undefined;
+  unsubscribeEventBus: (() => void) | undefined;
 };
 
 type ExecFileError = Error & {
@@ -141,19 +171,102 @@ function createCommandRunner(commandTimeoutMs: number): CommandRunner {
   };
 }
 
-function createDefaultAutoformatter(
+export function createDefaultAutoformatter(
   cwd: string,
   config: AutoformatConfig,
 ): PromptAutoformatterLike {
+  const scope = resolveFormatScope({ cwd, setting: config.formatScope });
+  const handlers: MutationSourceHandler[] = [writeOrEditHandler];
+
+  if (config.customMutationTools.length > 0) {
+    handlers.push(...createCustomToolHandlers(config.customMutationTools));
+  }
+
+  if (config.shellMutationDetection.enabled) {
+    handlers.push(createBashMutationHandler(config));
+  }
+
   return new PromptAutoformatter(
     cwd,
     config,
     createCommandRunner(config.commandTimeoutMs),
+    { scope, mutationHandlers: handlers },
   );
 }
 
+function createBashMutationHandler(
+  config: AutoformatConfig,
+): MutationSourceHandler {
+  const detection = config.shellMutationDetection;
+  return (toolName, payload, output) => {
+    if (toolName !== "bash") {
+      return [];
+    }
+    const command = extractBashCommand(payload);
+    if (!command) {
+      return [];
+    }
+    const candidates: string[] = [];
+    if (detection.argumentParsing) {
+      candidates.push(...parseKnownCommand(command));
+    }
+    if (detection.wrappers.length > 0) {
+      candidates.push(...matchWrapper(command, output, detection.wrappers));
+    }
+    return candidates;
+  };
+}
+
+function extractBashCommand(payload: unknown): string | undefined {
+  if (
+    typeof payload === "object" &&
+    payload !== null &&
+    "command" in payload &&
+    typeof (payload as { command: unknown }).command === "string"
+  ) {
+    return (payload as { command: string }).command;
+  }
+  return undefined;
+}
+
+function subscribeToEventBus(
+  pi: ExtensionAPI,
+  config: AutoformatConfig,
+  autoformatter: PromptAutoformatterLike,
+): (() => void) | undefined {
+  const channelConfig = config.eventBusMutationChannel;
+  if (!channelConfig.enabled || !pi.events) {
+    return undefined;
+  }
+  return pi.events.on(channelConfig.channel, (data: unknown) => {
+    const paths = parseTouchedPayload(data);
+    for (const candidate of paths) {
+      autoformatter.addTouchedPath(candidate);
+    }
+  });
+}
+
+function extractToolOutputText(
+  content: ToolResultEvent["content"] | undefined,
+): string {
+  if (!content) {
+    return "";
+  }
+  const parts: string[] = [];
+  for (const item of content) {
+    if (
+      item &&
+      "text" in item &&
+      typeof (item as { text?: unknown }).text === "string"
+    ) {
+      parts.push((item as { text: string }).text);
+    }
+  }
+  return parts.join("\n");
+}
+
 function reportMessage(
-  ctx: ExtensionContextLike,
+  ctx: AutoformatExtensionContext,
   message: string,
   type: NotificationType,
 ): void {
@@ -173,82 +286,304 @@ function reportMessage(
 
 type FailureSummary = {
   lines: string[];
-  failedRunCount: number;
+  failedBatchCount: number;
 };
 
-function summarizeFailures(result: PromptAutoformatterResult): FailureSummary {
+function formatterLabel(
+  name: string,
+  fallbackContext?: { skipped: string[] },
+): string {
+  if (!fallbackContext || fallbackContext.skipped.length === 0) {
+    return name;
+  }
+  return `${name} (fallback after ${fallbackContext.skipped.join(", ")} unavailable)`;
+}
+
+function summarizeFailures(
+  result: PromptAutoformatterResult,
+  config?: AutoformatConfig,
+): FailureSummary {
   const lines: string[] = [];
-  let failedRunCount = 0;
+  let failedBatchCount = 0;
+
+  for (const group of result.groups) {
+    for (const run of group.runs) {
+      if (run.success) {
+        continue;
+      }
+      failedBatchCount += 1;
+      lines.push(
+        `${formatterLabel(run.formatterName, run.fallbackContext)} (exit ${run.exitCode}): ${run.files.join(", ")}`,
+      );
+      if (config) {
+        const outputBlock = formatRunOutputBlock(run, config.formatterOutput);
+        if (outputBlock) {
+          lines.push(outputBlock);
+        }
+      }
+    }
+  }
+
+  return { lines, failedBatchCount };
+}
 
-  for (const file of result.files) {
-    const failures = file.runs.filter((run) => !run.success);
-    if (failures.length === 0) {
-      continue;
+function summarizeFallbackUsages(result: PromptAutoformatterResult): string[] {
+  const lines: string[] = [];
+  for (const group of result.groups) {
+    for (const run of group.runs) {
+      if (!run.success) {
+        continue;
+      }
+      if (!run.fallbackContext || run.fallbackContext.skipped.length === 0) {
+        continue;
+      }
+      lines.push(formatterLabel(run.formatterName, run.fallbackContext));
     }
+  }
+  return lines;
+}
 
-    failedRunCount += failures.length;
-    const details = failures
-      .map((run) => `${run.formatterName} (exit ${run.exitCode})`)
-      .join(", ");
-    lines.push(`${file.path}: ${details}`);
+function collectAllFiles(result: PromptAutoformatterResult): string[] {
+  const files: string[] = [];
+  for (const group of result.groups) {
+    files.push(...group.files);
+  }
+  return files;
+}
+
+function summarizeSuccessPaths(files: string[]): string | undefined {
+  if (files.length === 0 || files.length > 3) {
+    return undefined;
+  }
+  return files.join(", ");
+}
+
+type FlushSummary = {
+  groupCount: number;
+  fileCount: number;
+  successBatchCount: number;
+  failureBatchCount: number;
+  failureLines: string[];
+  formatterLabels: string[];
+  fallbackUsages: string[];
+};
+
+function summarizeFlush(
+  result: PromptAutoformatterResult,
+  config?: AutoformatConfig,
+): FlushSummary {
+  const failureSummary = summarizeFailures(result, config);
+  const fallbackUsages = summarizeFallbackUsages(result);
+  const fileCount = collectAllFiles(result).length;
+
+  const seen = new Set<string>();
+  const formatterLabels: string[] = [];
+  let successBatchCount = 0;
+  for (const group of result.groups) {
+    for (const run of group.runs) {
+      if (run.success) {
+        successBatchCount += 1;
+      }
+      const label = formatterLabel(run.formatterName, run.fallbackContext);
+      if (!seen.has(label)) {
+        seen.add(label);
+        formatterLabels.push(label);
+      }
+    }
   }
 
   return {
-    lines,
-    failedRunCount,
+    groupCount: result.groups.length,
+    fileCount,
+    successBatchCount,
+    failureBatchCount: failureSummary.failedBatchCount,
+    failureLines: failureSummary.lines,
+    formatterLabels,
+    fallbackUsages,
   };
 }
 
-function summarizeSuccessPaths(
+type ThemeColorName = "success" | "warning" | "error" | "dim" | "accent";
+
+function themed(
+  ctx: AutoformatExtensionContext,
+  color: ThemeColorName,
+  text: string,
+): string {
+  const theme = ctx.ui.theme;
+  if (!theme || typeof theme.fg !== "function") {
+    return text;
+  }
+  // Call through the theme object so `this` stays bound. Pi's real Theme.fg
+  // is an instance method that reads `this.fgColors`; destructuring it would
+  // throw "Cannot read properties of undefined (reading 'fgColors')".
+  try {
+    return theme.fg(color, text);
+  } catch {
+    // Defensive: a theme that throws on a known color name (e.g. a partial
+    // palette) should degrade to plain text rather than break the flush.
+    return text;
+  }
+}
+
+function formatStatusLine(
+  summary: FlushSummary,
+  ctx: AutoformatExtensionContext,
+): string {
+  const fileWord = summary.fileCount === 1 ? "file" : "files";
+  const formatters =
+    summary.formatterLabels.length > 0
+      ? ` (${summary.formatterLabels.join(", ")})`
+      : "";
+  const label = themed(ctx, "dim", "autoformat:");
+
+  if (summary.failureBatchCount > 0) {
+    const batchWord = summary.failureBatchCount === 1 ? "batch" : "batches";
+    const mark = themed(ctx, "error", "\u2717");
+    const failureClause = themed(
+      ctx,
+      "error",
+      `${summary.failureBatchCount} ${batchWord} failed`,
+    );
+    const okSuffix =
+      summary.successBatchCount > 0
+        ? themed(ctx, "dim", ` \u2014 ${summary.successBatchCount} ok`)
+        : "";
+    return `${mark} ${label} ${failureClause}${formatters}${okSuffix}`;
+  }
+
+  const mark = themed(ctx, "success", "\u2713");
+  return `${mark} ${label} ${summary.fileCount} ${fileWord}${formatters}`;
+}
+
+const STEERING_MAX_FILES = 10;
+
+export function buildSteeringMessageContent(
   result: PromptAutoformatterResult,
 ): string | undefined {
-  if (result.files.length === 0 || result.files.length > 3) {
+  if (result.groups.length === 0) {
+    return undefined;
+  }
+
+  const changedFiles: string[] = [];
+  const failureLines: string[] = [];
+
+  for (const group of result.groups) {
+    changedFiles.push(...group.changedFiles);
+    for (const run of group.runs) {
+      if (run.success) {
+        continue;
+      }
+      const fileList = run.files.join(", ");
+      failureLines.push(
+        `  ${run.formatterName} (exit ${run.exitCode}) on ${fileList}:`,
+      );
+      if (run.stderr) {
+        failureLines.push(`    ${run.stderr}`);
+      }
+      if (run.stdout) {
+        failureLines.push(`    ${run.stdout}`);
+      }
+    }
+  }
+
+  if (changedFiles.length === 0 && failureLines.length === 0) {
     return undefined;
   }
 
-  return result.files.map((file) => file.path).join(", ");
+  const parts: string[] = [];
+
+  if (changedFiles.length > 0) {
+    const shown = changedFiles.slice(0, STEERING_MAX_FILES);
+    const remaining = changedFiles.length - shown.length;
+    let list = shown.join(", ");
+    if (remaining > 0) {
+      list += `, \u2026 and ${remaining} more`;
+    }
+    parts.push(
+      `[autoformat] Formatted ${changedFiles.length} file(s): ${list}`,
+    );
+  }
+
+  if (failureLines.length > 0) {
+    if (changedFiles.length === 0) {
+      parts.push(["[autoformat] Failures:", ...failureLines].join("\n"));
+    } else {
+      parts.push(["Failures:", ...failureLines].join("\n"));
+    }
+  }
+
+  return parts.join("\n\n") || undefined;
+}
+
+function buildLegacyFailureMessage(summary: FlushSummary): string {
+  const batchWord = summary.failureBatchCount === 1 ? "batch" : "batches";
+  return [
+    `Formatter failures in ${summary.failureBatchCount} ${batchWord}:`,
+    ...summary.failureLines,
+  ].join("\n");
+}
+
+function buildLegacySuccessMessage(
+  result: PromptAutoformatterResult,
+  summary: FlushSummary,
+): string {
+  const allFiles = collectAllFiles(result);
+  const successPaths = summarizeSuccessPaths(allFiles);
+  const fileWord = allFiles.length === 1 ? "file" : "files";
+  const baseMessage = successPaths
+    ? `Autoformatted ${allFiles.length} ${fileWord}: ${successPaths}`
+    : `Autoformatted ${allFiles.length} ${fileWord}.`;
+
+  return summary.fallbackUsages.length > 0
+    ? `${baseMessage} [${summary.fallbackUsages.join("; ")}]`
+    : baseMessage;
 }
 
 function defaultReportFlushResult(
   result: PromptAutoformatterResult,
   options: {
     config: AutoformatConfig;
-    ctx: ExtensionContextLike;
+    ctx: AutoformatExtensionContext;
   },
 ): void {
-  if (result.files.length === 0) {
+  if (result.groups.length === 0) {
+    setAutoformatStatus(options.ctx, undefined);
     return;
   }
 
-  const failureSummary = summarizeFailures(result);
-  if (failureSummary.lines.length > 0) {
-    reportMessage(
-      options.ctx,
-      [
-        `Formatter failures in ${failureSummary.lines.length} file${failureSummary.lines.length === 1 ? "" : "s"} (${failureSummary.failedRunCount} failed run${failureSummary.failedRunCount === 1 ? "" : "s"}):`,
-        ...failureSummary.lines,
-      ].join("\n"),
-      "warning",
-    );
+  const summary = summarizeFlush(result, options.config);
+
+  if (summary.failureBatchCount > 0) {
+    const message = buildLegacyFailureMessage(summary);
+    if (options.ctx.hasUI) {
+      setAutoformatStatus(options.ctx, formatStatusLine(summary, options.ctx));
+    }
+    reportMessage(options.ctx, message, "warning");
     return;
   }
 
   if (options.config.hideSummariesInTui && options.ctx.hasUI) {
+    setAutoformatStatus(options.ctx, undefined);
     return;
   }
 
-  const successPaths = summarizeSuccessPaths(result);
-  const message = successPaths
-    ? `Autoformatted ${result.files.length} file${result.files.length === 1 ? "" : "s"}: ${successPaths}`
-    : `Autoformatted ${result.files.length} file${result.files.length === 1 ? "" : "s"}.`;
+  if (options.ctx.hasUI) {
+    setAutoformatStatus(options.ctx, formatStatusLine(summary, options.ctx));
+    return;
+  }
 
-  reportMessage(options.ctx, message, "info");
+  reportMessage(
+    options.ctx,
+    buildLegacySuccessMessage(result, summary),
+    "info",
+  );
 }
 
 function defaultReportConfigIssues(
   issues: ConfigValidationIssue[],
   options: {
-    ctx: ExtensionContextLike;
+    ctx: AutoformatExtensionContext;
   },
 ): void {
   if (issues.length === 0) {
@@ -277,7 +612,7 @@ function defaultReportConfigIssues(
 }
 
 export function createAutoformatExtension(
-  pi: ExtensionApiLike,
+  pi: ExtensionAPI,
   dependencies: AutoformatExtensionDependencies = {},
 ): void {
   const loadConfig =
@@ -290,7 +625,9 @@ export function createAutoformatExtension(
     dependencies.reportConfigIssues ?? defaultReportConfigIssues;
 
   let state: SessionState | undefined;
-  let pendingFlush = Promise.resolve();
+  let pendingFlush = Promise.resolve<PromptAutoformatterResult | undefined>(
+    undefined,
+  );
 
   function ensureState(cwd: string): SessionState {
     if (state && state.cwd === cwd) {
@@ -298,15 +635,33 @@ export function createAutoformatExtension(
     }
 
     const loadResult = loadConfig(cwd);
+    const detection = loadResult.config.shellMutationDetection;
+    const snapshotTracker =
+      detection.enabled && detection.snapshotGlobs.length > 0
+        ? new SnapshotTracker({
+            cwd,
+            globs: detection.snapshotGlobs,
+          })
+        : undefined;
+    const autoformatter = createAutoformatter(cwd, loadResult.config);
+    const unsubscribeEventBus = subscribeToEventBus(
+      pi,
+      loadResult.config,
+      autoformatter,
+    );
     state = {
       cwd,
       loadResult,
-      autoformatter: createAutoformatter(cwd, loadResult.config),
+      autoformatter,
+      snapshotTracker,
+      unsubscribeEventBus,
     };
     return state;
   }
 
-  function queueFlush(ctx: ExtensionContextLike): Promise<void> {
+  function queueFlush(
+    ctx: AutoformatExtensionContext,
+  ): Promise<PromptAutoformatterResult | undefined> {
     const sessionState = state;
     if (!sessionState) {
       return pendingFlush;
@@ -319,10 +674,12 @@ export function createAutoformatExtension(
           config: sessionState.loadResult.config,
           ctx,
         });
+        return result;
       })
       .catch((error: unknown) => {
         const message = error instanceof Error ? error.message : String(error);
         reportMessage(ctx, `Unexpected runtime error: ${message}`, "warning");
+        return undefined;
       });
 
     return pendingFlush;
@@ -331,27 +688,55 @@ export function createAutoformatExtension(
   pi.on("session_start", async (_event, ctx) => {
     const sessionState = ensureState(ctx.cwd);
     reportConfigIssues(sessionState.loadResult.issues, { ctx });
+    setAutoformatStatus(ctx, undefined);
+  });
+
+  pi.on("tool_call", async (event: ToolCallEvent, ctx) => {
+    if (event.toolName !== "bash") {
+      return;
+    }
+    const sessionState = ensureState(ctx.cwd);
+    sessionState.snapshotTracker?.before();
   });
 
-  pi.on("tool_result", async (event, ctx) => {
+  pi.on("tool_result", async (event: ToolResultEvent, ctx) => {
     if (event.isError) {
       return;
     }
 
     const sessionState = ensureState(ctx.cwd);
-    sessionState.autoformatter.recordToolResult(event.toolName, event.input);
+    const output = extractToolOutputText(event.content);
+    sessionState.autoformatter.recordToolResult(
+      event.toolName,
+      event.input,
+      output,
+    );
 
-    if (sessionState.loadResult.config.formatMode === "tool") {
-      await queueFlush(ctx);
+    if (event.toolName === "bash" && sessionState.snapshotTracker) {
+      const snapshotTouched = sessionState.snapshotTracker.after();
+      for (const touched of snapshotTouched) {
+        sessionState.autoformatter.addTouchedPath(touched);
+      }
     }
   });
 
-  pi.on("agent_end", async (_event, ctx) => {
-    const sessionState = ensureState(ctx.cwd);
-    if (sessionState.loadResult.config.formatMode !== "prompt") {
-      return;
+  pi.on("turn_end", async (_event, ctx) => {
+    const result = await queueFlush(ctx);
+    if (result) {
+      const content = buildSteeringMessageContent(result);
+      if (content) {
+        pi.sendMessage({
+          customType: "autoformat-steering",
+          content,
+          display: true,
+        });
+      }
     }
+  });
 
+  pi.on("agent_end", async (_event, ctx) => {
+    // Safety-net flush: in the normal case, turn_end has already drained
+    // the queue, so this is a no-op.
     await queueFlush(ctx);
   });
 
@@ -361,14 +746,16 @@ export function createAutoformatExtension(
       return;
     }
 
-    if (sessionState.loadResult.config.formatMode === "session") {
-      await queueFlush(ctx);
-    }
+    // Final safety-net flush for any touched files not yet formatted
+    // (e.g. files added via EventBus without an agent loop).
+    await queueFlush(ctx);
 
+    setAutoformatStatus(ctx, undefined);
+    sessionState.unsubscribeEventBus?.();
     state = undefined;
   });
 }
 
-export default function autoformatExtension(pi: ExtensionApiLike): void {
+export default function autoformatExtension(pi: ExtensionAPI): void {
   createAutoformatExtension(pi);
 }