@gotgenes/pi-autoformat 0.1.0 → 4.0.3

package/src/formatter-registry.ts

@@ -1,61 +1,170 @@
 import path from "node:path";
 
+import {
+  type BuiltinFormatter,
+  getBuiltinFormatter,
+} from "./builtin-formatters.js";
+
 export type FormatterDefinition = {
   command: string[];
-  extensions: string[];
   environment?: Record<string, string>;
   disabled?: boolean;
 };
 
+export type FallbackChainStep = {
+  fallback: string[];
+};
+
+export type ChainStep = string | FallbackChainStep;
+
+export function isFallbackChainStep(
+  step: ChainStep,
+): step is FallbackChainStep {
+  return typeof step === "object" && step !== null && "fallback" in step;
+}
+
 export type FormatterConfig = {
   formatters: Record<string, FormatterDefinition>;
-  chains?: Record<string, string[]>;
+  chains?: Record<string, ChainStep[]>;
 };
 
 export type ResolvedFormatter = {
   name: string;
   command: string[];
   environment?: Record<string, string>;
+  builtin?: BuiltinFormatter;
+};
+
+export type ResolvedSingleStep = {
+  kind: "single";
+  formatter: ResolvedFormatter;
 };
 
-export function resolveFormatterChainForFile(
-  filePath: string,
+export type ResolvedFallbackStep = {
+  kind: "fallback";
+  alternatives: ResolvedFormatter[];
+};
+
+export type ResolvedChainStep = ResolvedSingleStep | ResolvedFallbackStep;
+
+export type ChainGroup = {
+  chain: ChainStep[];
+  files: string[];
+};
+
+function encodeChainStep(step: ChainStep): string {
+  if (typeof step === "string") {
+    return `S:${step}`;
+  }
+  return `F:${step.fallback.join("|")}`;
+}
+
+function encodeChain(chain: ChainStep[]): string {
+  return chain.map(encodeChainStep).join("\u0000");
+}
+
+export const WILDCARD_CHAIN_KEY = "*";
+
+export function groupFilesByChain(
+  files: string[],
   config: FormatterConfig,
-): ResolvedFormatter[] {
-  const extension = path.extname(filePath).toLowerCase();
-  if (!extension) {
-    return [];
+): ChainGroup[] {
+  const groups: ChainGroup[] = [];
+  const indexByKey = new Map<string, number>();
+
+  const wildcardChain = config.chains?.[WILDCARD_CHAIN_KEY];
+  if (wildcardChain && wildcardChain.length > 0 && files.length > 0) {
+    groups.push({ chain: [...wildcardChain], files: [...files] });
+    indexByKey.set(`W:${encodeChain(wildcardChain)}`, 0);
   }
 
-  const chainNames = config.chains?.[extension];
-  if (!chainNames) {
-    return [];
+  for (const filePath of files) {
+    const extension = path.extname(filePath).toLowerCase();
+    if (!extension) {
+      continue;
+    }
+    const chainSteps = config.chains?.[extension];
+    if (!chainSteps || chainSteps.length === 0) {
+      continue;
+    }
+    const key = `E:${encodeChain(chainSteps)}`;
+    const existingIndex = indexByKey.get(key);
+    if (existingIndex === undefined) {
+      indexByKey.set(key, groups.length);
+      groups.push({ chain: [...chainSteps], files: [filePath] });
+    } else {
+      groups[existingIndex].files.push(filePath);
+    }
   }
 
-  return chainNames
-    .map((formatterName) =>
-      resolveFormatterByName(formatterName, filePath, config),
-    )
-    .filter((formatter): formatter is ResolvedFormatter => formatter !== null);
+  return groups;
 }
 
-function resolveFormatterByName(
-  formatterName: string,
-  filePath: string,
+export function resolveChain(
+  chainNames: string[],
   config: FormatterConfig,
-): ResolvedFormatter | null {
-  const formatter = config.formatters[formatterName];
-  if (!formatter || formatter.disabled) {
-    return null;
+): ResolvedFormatter[] {
+  const resolved: ResolvedFormatter[] = [];
+  for (const name of chainNames) {
+    const formatter = resolveFormatterByName(name, config);
+    if (formatter) {
+      resolved.push(formatter);
+    }
   }
+  return resolved;
+}
 
-  return {
-    name: formatterName,
-    command: substituteFileToken(formatter.command, filePath),
-    environment: formatter.environment,
-  };
+function resolveFormatterByName(
+  name: string,
+  config: FormatterConfig,
+): ResolvedFormatter | undefined {
+  const formatter = config.formatters[name];
+  if (formatter) {
+    if (formatter.disabled) {
+      return undefined;
+    }
+    return {
+      name,
+      command: [...formatter.command],
+      environment: formatter.environment,
+    };
+  }
+  const builtin = getBuiltinFormatter(name);
+  if (builtin) {
+    return {
+      name,
+      // Built-ins build their argv at execution time from the discovered
+      // config root. The placeholder here is replaced by the executor.
+      command: [builtin.name],
+      builtin,
+    };
+  }
+  return undefined;
 }
 
-function substituteFileToken(command: string[], filePath: string): string[] {
-  return command.map((arg) => arg.replaceAll("$FILE", filePath));
+export function resolveChainSteps(
+  steps: ChainStep[],
+  config: FormatterConfig,
+): ResolvedChainStep[] {
+  const resolved: ResolvedChainStep[] = [];
+  for (const step of steps) {
+    if (typeof step === "string") {
+      const formatter = resolveFormatterByName(step, config);
+      if (formatter) {
+        resolved.push({ kind: "single", formatter });
+      }
+      continue;
+    }
+    const alternatives: ResolvedFormatter[] = [];
+    for (const name of step.fallback) {
+      const formatter = resolveFormatterByName(name, config);
+      if (formatter) {
+        alternatives.push(formatter);
+      }
+    }
+    if (alternatives.length > 0) {
+      resolved.push({ kind: "fallback", alternatives });
+    }
+  }
+  return resolved;
 }

package/src/index.ts

@@ -15,28 +15,49 @@ export {
   createAutoformatExtension,
   default as autoformatExtension,
 } from "./extension.js";
+export {
+  type FormatScope,
+  type FormatScopeSetting,
+  isInFormatScope,
+  resolveFormatScope,
+} from "./format-scope.js";
 export {
   type AutoformatConfig,
   createFormatterConfig,
   DEFAULT_FORMATTER_CONFIG,
-  type FormatMode,
   type UserFormatterConfig,
 } from "./formatter-config.js";
 export {
+  type BatchRun,
+  type ChainGroupInput,
   type CommandRunner,
   type CommandRunnerOptions,
   type CommandRunResult,
-  executeFormatterChain,
-  type FormatterExecutionResult,
+  executeChainGroup,
 } from "./formatter-executor.js";
 export {
+  type ChainGroup,
   type FormatterConfig,
   type FormatterDefinition,
+  groupFilesByChain,
   type ResolvedFormatter,
-  resolveFormatterChainForFile,
+  resolveChain,
 } from "./formatter-registry.js";
 export {
+  type ChainGroupResult,
   PromptAutoformatter,
   type PromptAutoformatterResult,
 } from "./prompt-autoformatter.js";
-export { TouchedFilesQueue } from "./touched-files-queue.js";
+export {
+  DEFAULT_SHELL_MUTATION_DETECTION,
+  matchWrapper,
+  parseKnownCommand,
+  type ShellMutationDetectionConfig,
+  SnapshotTracker,
+  type WrapperConfig,
+} from "./shell-mutation-detector.js";
+export {
+  type MutationSourceHandler,
+  TouchedFilesQueue,
+  writeOrEditHandler,
+} from "./touched-files-queue.js";

package/src/prompt-autoformatter.ts

@@ -1,58 +1,183 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+
+import type { DiscoveryCache } from "./builtin-formatters.js";
+import {
+  type CommandProbe,
+  createCachedCommandProbe,
+  defaultCommandProbe,
+} from "./command-probe.js";
+import type { FormatScope } from "./format-scope.js";
 import {
+  type BatchRun,
   type CommandRunner,
-  executeFormatterChain,
-  type FormatterExecutionResult,
+  executeChainGroupWithPartition,
 } from "./formatter-executor.js";
+import type { ChainStep } from "./formatter-registry.js";
 import {
   type FormatterConfig,
-  resolveFormatterChainForFile,
+  groupFilesByChain,
+  resolveChainSteps,
+  WILDCARD_CHAIN_KEY,
 } from "./formatter-registry.js";
-import { TouchedFilesQueue } from "./touched-files-queue.js";
+import {
+  type MutationSourceHandler,
+  TouchedFilesQueue,
+} from "./touched-files-queue.js";
+
+export type ChainGroupResult = {
+  chain: ChainStep[];
+  files: string[];
+  runs: BatchRun[];
+  changedFiles: string[];
+};
 
 export type PromptAutoformatterResult = {
-  files: Array<{
-    path: string;
-    runs: FormatterExecutionResult[];
-  }>;
+  groups: ChainGroupResult[];
+};
+
+export type PromptAutoformatterOptions = {
+  scope?: FormatScope;
+  mutationHandlers?: MutationSourceHandler[];
+  /**
+   * Probe used to test whether a fallback alternative's command is on PATH.
+   * Wrapped in a per-flush cache so the same command is probed at most once
+   * per flush across all chain groups. Defaults to the synchronous PATH walker.
+   */
+  commandProbe?: CommandProbe;
 };
 
+async function hashFile(filePath: string): Promise<string | undefined> {
+  try {
+    const content = await readFile(filePath);
+    return createHash("sha256").update(content).digest("hex");
+  } catch {
+    return undefined;
+  }
+}
+
 export class PromptAutoformatter {
   private readonly queue: TouchedFilesQueue;
+  private readonly commandProbe: CommandProbe;
+  /** Session-scoped cache for built-in config-root discovery. */
+  private readonly discoveryCache: DiscoveryCache = new Map();
 
   constructor(
     private readonly cwd: string,
     private readonly config: FormatterConfig,
     private readonly runner: CommandRunner,
+    options?: PromptAutoformatterOptions,
   ) {
-    this.queue = new TouchedFilesQueue(cwd);
+    this.queue = new TouchedFilesQueue({
+      cwd,
+      scope: options?.scope,
+      handlers: options?.mutationHandlers,
+    });
+    this.commandProbe = options?.commandProbe ?? defaultCommandProbe;
   }
 
-  recordToolResult(toolName: string, payload: unknown): void {
-    this.queue.recordToolResult(toolName, payload);
+  recordToolResult(toolName: string, payload: unknown, output = ""): void {
+    this.queue.recordToolResult(toolName, payload, output);
+  }
+
+  addTouchedPath(filePath: string): void {
+    this.queue.addPath(filePath);
   }
 
   async flushPrompt(): Promise<PromptAutoformatterResult> {
     const touchedFiles = this.queue.flush();
-    const fileResults: PromptAutoformatterResult["files"] = [];
+    const fileGroups = groupFilesByChain(touchedFiles, this.config);
+    const groupResults: ChainGroupResult[] = [];
+
+    // One probe cache per flush, shared across all chain groups so the same
+    // fallback command is probed at most once even when many extensions share
+    // the same fallback step.
+    const cachedProbe = createCachedCommandProbe(this.commandProbe);
+    const wildcardChainSteps = this.config.chains?.[WILDCARD_CHAIN_KEY];
+    const hasWildcard =
+      Array.isArray(wildcardChainSteps) && wildcardChainSteps.length > 0;
+    const wildcardHandled = new Set<string>();
+
+    for (let i = 0; i < fileGroups.length; i += 1) {
+      const group = fileGroups[i];
+      // groupFilesByChain emits the wildcard group first when chains["*"] is
+      // configured, so the index is sufficient.
+      const isWildcard = hasWildcard && i === 0;
 
-    for (const filePath of touchedFiles) {
-      const chain = resolveFormatterChainForFile(filePath, this.config);
-      if (chain.length === 0) {
+      // For per-extension groups, drop any files claimed by the wildcard pass.
+      const inputFiles = isWildcard
+        ? group.files
+        : group.files.filter((f) => !wildcardHandled.has(f));
+      if (inputFiles.length === 0) {
         continue;
       }
 
-      const runs = await executeFormatterChain(chain, this.runner, {
-        cwd: this.cwd,
-      });
+      const resolved = resolveChainSteps(group.chain, this.config);
+      if (resolved.length === 0) {
+        continue;
+      }
+
+      // Snapshot file content hashes before formatting.
+      const preHashes = new Map<string, string>();
+      for (const file of inputFiles) {
+        const hash = await hashFile(file);
+        if (hash !== undefined) {
+          preHashes.set(file, hash);
+        }
+      }
+
+      const { runs, unhandled } = await executeChainGroupWithPartition(
+        { chain: resolved, files: inputFiles },
+        this.runner,
+        {
+          cwd: this.cwd,
+          commandProbe: cachedProbe,
+          builtinContext: { cache: this.discoveryCache },
+        },
+      );
+
+      if (isWildcard) {
+        // Files not in the unhandled tail were claimed by a built-in step;
+        // remove them from the per-extension pass.
+        const unhandledSet = new Set(unhandled);
+        for (const file of inputFiles) {
+          if (!unhandledSet.has(file)) {
+            wildcardHandled.add(file);
+          }
+        }
+      }
+
+      if (runs.length === 0) {
+        // E.g. a chain consisting of a single fallback group whose
+        // alternatives are all absent from PATH, or a built-in that skipped
+        // the entire batch. Drop the group so it does not show up as a
+        // phantom "formatted nothing" entry downstream.
+        continue;
+      }
+
+      // Determine which files were actually changed by comparing post-format
+      // hashes to the pre-format snapshots.
+      const changedFiles: string[] = [];
+      for (const file of inputFiles) {
+        const afterHash = await hashFile(file);
+        if (afterHash === undefined) {
+          // File was deleted by the formatter — exclude.
+          continue;
+        }
+        const beforeHash = preHashes.get(file);
+        if (beforeHash !== afterHash) {
+          changedFiles.push(file);
+        }
+      }
 
-      fileResults.push({
-        path: filePath,
+      groupResults.push({
+        chain: group.chain,
+        files: [...inputFiles],
         runs,
+        changedFiles,
       });
     }
 
-    return {
-      files: fileResults,
-    };
+    return { groups: groupResults };
   }
 }