@gotgenes/pi-autoformat 0.1.0

package/src/extension.ts

@@ -0,0 +1,374 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import {
+  AUTOFORMAT_EXTENSION_ID,
+  type ConfigValidationIssue,
+  type LoadConfigResult,
+  loadAutoformatConfig,
+} from "./config-loader.js";
+import type { AutoformatConfig } from "./formatter-config.js";
+import type { CommandRunner, CommandRunResult } from "./formatter-executor.js";
+import {
+  PromptAutoformatter,
+  type PromptAutoformatterResult,
+} from "./prompt-autoformatter.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;
+  };
+};
+
+type ToolResultEventLike = {
+  toolName: string;
+  input: unknown;
+  isError: boolean;
+};
+
+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;
+};
+
+type PromptAutoformatterLike = Pick<
+  PromptAutoformatter,
+  "recordToolResult" | "flushPrompt"
+>;
+
+type AutoformatExtensionDependencies = {
+  loadConfig?: (cwd: string) => LoadConfigResult;
+  createAutoformatter?: (
+    cwd: string,
+    config: AutoformatConfig,
+  ) => PromptAutoformatterLike;
+  reportFlushResult?: (
+    result: PromptAutoformatterResult,
+    options: {
+      config: AutoformatConfig;
+      ctx: ExtensionContextLike;
+    },
+  ) => void;
+  reportConfigIssues?: (
+    issues: ConfigValidationIssue[],
+    options: {
+      ctx: ExtensionContextLike;
+    },
+  ) => void;
+};
+
+type SessionState = {
+  cwd: string;
+  loadResult: LoadConfigResult;
+  autoformatter: PromptAutoformatterLike;
+};
+
+type ExecFileError = Error & {
+  code?: number | string;
+  stdout?: string | Buffer;
+  stderr?: string | Buffer;
+};
+
+function toOutputText(value: string | Buffer | undefined): string | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return typeof value === "string" ? value : value.toString("utf-8");
+}
+
+function normalizeExecError(error: unknown): CommandRunResult {
+  if (!(error instanceof Error)) {
+    return {
+      exitCode: 1,
+      stderr: String(error),
+    };
+  }
+
+  const execError = error as ExecFileError;
+  return {
+    exitCode: typeof execError.code === "number" ? execError.code : 1,
+    stdout: toOutputText(execError.stdout),
+    stderr: toOutputText(execError.stderr) ?? execError.message,
+  };
+}
+
+function createCommandRunner(commandTimeoutMs: number): CommandRunner {
+  return async (
+    command: string,
+    args: string[],
+    options,
+  ): Promise<CommandRunResult> => {
+    try {
+      const result = await execFileAsync(command, args, {
+        cwd: options?.cwd,
+        env: options?.env
+          ? {
+              ...process.env,
+              ...options.env,
+            }
+          : process.env,
+        encoding: "utf-8",
+        maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+        timeout: commandTimeoutMs,
+      });
+
+      return {
+        exitCode: 0,
+        stdout: result.stdout,
+        stderr: result.stderr,
+      };
+    } catch (error) {
+      return normalizeExecError(error);
+    }
+  };
+}
+
+function createDefaultAutoformatter(
+  cwd: string,
+  config: AutoformatConfig,
+): PromptAutoformatterLike {
+  return new PromptAutoformatter(
+    cwd,
+    config,
+    createCommandRunner(config.commandTimeoutMs),
+  );
+}
+
+function reportMessage(
+  ctx: ExtensionContextLike,
+  message: string,
+  type: NotificationType,
+): void {
+  if (ctx.hasUI) {
+    ctx.ui.notify(message, type);
+    return;
+  }
+
+  const output = `[${AUTOFORMAT_EXTENSION_ID}] ${message}`;
+  if (type === "error" || type === "warning") {
+    console.warn(output);
+    return;
+  }
+
+  console.log(output);
+}
+
+type FailureSummary = {
+  lines: string[];
+  failedRunCount: number;
+};
+
+function summarizeFailures(result: PromptAutoformatterResult): FailureSummary {
+  const lines: string[] = [];
+  let failedRunCount = 0;
+
+  for (const file of result.files) {
+    const failures = file.runs.filter((run) => !run.success);
+    if (failures.length === 0) {
+      continue;
+    }
+
+    failedRunCount += failures.length;
+    const details = failures
+      .map((run) => `${run.formatterName} (exit ${run.exitCode})`)
+      .join(", ");
+    lines.push(`${file.path}: ${details}`);
+  }
+
+  return {
+    lines,
+    failedRunCount,
+  };
+}
+
+function summarizeSuccessPaths(
+  result: PromptAutoformatterResult,
+): string | undefined {
+  if (result.files.length === 0 || result.files.length > 3) {
+    return undefined;
+  }
+
+  return result.files.map((file) => file.path).join(", ");
+}
+
+function defaultReportFlushResult(
+  result: PromptAutoformatterResult,
+  options: {
+    config: AutoformatConfig;
+    ctx: ExtensionContextLike;
+  },
+): void {
+  if (result.files.length === 0) {
+    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",
+    );
+    return;
+  }
+
+  if (options.config.hideSummariesInTui && options.ctx.hasUI) {
+    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"}.`;
+
+  reportMessage(options.ctx, message, "info");
+}
+
+function defaultReportConfigIssues(
+  issues: ConfigValidationIssue[],
+  options: {
+    ctx: ExtensionContextLike;
+  },
+): void {
+  if (issues.length === 0) {
+    return;
+  }
+
+  const lines = issues.slice(0, 3).map((issue) => {
+    if (issue.sourcePath) {
+      return `${issue.sourcePath} ${issue.path}: ${issue.message}`;
+    }
+    return `${issue.path}: ${issue.message}`;
+  });
+
+  const remainingCount = issues.length - lines.length;
+  if (remainingCount > 0) {
+    lines.push(
+      `...and ${remainingCount} more issue${remainingCount === 1 ? "" : "s"}.`,
+    );
+  }
+
+  reportMessage(
+    options.ctx,
+    ["Configuration issues detected:", ...lines].join("\n"),
+    "warning",
+  );
+}
+
+export function createAutoformatExtension(
+  pi: ExtensionApiLike,
+  dependencies: AutoformatExtensionDependencies = {},
+): void {
+  const loadConfig =
+    dependencies.loadConfig ?? ((cwd: string) => loadAutoformatConfig({ cwd }));
+  const createAutoformatter =
+    dependencies.createAutoformatter ?? createDefaultAutoformatter;
+  const reportFlushResult =
+    dependencies.reportFlushResult ?? defaultReportFlushResult;
+  const reportConfigIssues =
+    dependencies.reportConfigIssues ?? defaultReportConfigIssues;
+
+  let state: SessionState | undefined;
+  let pendingFlush = Promise.resolve();
+
+  function ensureState(cwd: string): SessionState {
+    if (state && state.cwd === cwd) {
+      return state;
+    }
+
+    const loadResult = loadConfig(cwd);
+    state = {
+      cwd,
+      loadResult,
+      autoformatter: createAutoformatter(cwd, loadResult.config),
+    };
+    return state;
+  }
+
+  function queueFlush(ctx: ExtensionContextLike): Promise<void> {
+    const sessionState = state;
+    if (!sessionState) {
+      return pendingFlush;
+    }
+
+    pendingFlush = pendingFlush
+      .then(async () => {
+        const result = await sessionState.autoformatter.flushPrompt();
+        reportFlushResult(result, {
+          config: sessionState.loadResult.config,
+          ctx,
+        });
+      })
+      .catch((error: unknown) => {
+        const message = error instanceof Error ? error.message : String(error);
+        reportMessage(ctx, `Unexpected runtime error: ${message}`, "warning");
+      });
+
+    return pendingFlush;
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    const sessionState = ensureState(ctx.cwd);
+    reportConfigIssues(sessionState.loadResult.issues, { ctx });
+  });
+
+  pi.on("tool_result", async (event, ctx) => {
+    if (event.isError) {
+      return;
+    }
+
+    const sessionState = ensureState(ctx.cwd);
+    sessionState.autoformatter.recordToolResult(event.toolName, event.input);
+
+    if (sessionState.loadResult.config.formatMode === "tool") {
+      await queueFlush(ctx);
+    }
+  });
+
+  pi.on("agent_end", async (_event, ctx) => {
+    const sessionState = ensureState(ctx.cwd);
+    if (sessionState.loadResult.config.formatMode !== "prompt") {
+      return;
+    }
+
+    await queueFlush(ctx);
+  });
+
+  pi.on("session_shutdown", async (_event, ctx) => {
+    const sessionState = state;
+    if (!sessionState) {
+      return;
+    }
+
+    if (sessionState.loadResult.config.formatMode === "session") {
+      await queueFlush(ctx);
+    }
+
+    state = undefined;
+  });
+}
+
+export default function autoformatExtension(pi: ExtensionApiLike): void {
+  createAutoformatExtension(pi);
+}

package/src/formatter-config.ts

@@ -0,0 +1,80 @@
+import type {
+  FormatterConfig,
+  FormatterDefinition,
+} from "./formatter-registry.js";
+
+export type FormatMode = "tool" | "prompt" | "session";
+
+export type UserFormatterConfig = {
+  formatMode?: FormatMode;
+  commandTimeoutMs?: number;
+  hideSummariesInTui?: boolean;
+  formatters?: Record<string, FormatterDefinition>;
+  chains?: Record<string, string[]>;
+};
+
+export type AutoformatConfig = FormatterConfig & {
+  formatMode: FormatMode;
+  commandTimeoutMs: number;
+  hideSummariesInTui: boolean;
+};
+
+export const DEFAULT_FORMATTER_CONFIG: AutoformatConfig = {
+  formatMode: "prompt",
+  commandTimeoutMs: 10000,
+  hideSummariesInTui: false,
+  formatters: {
+    prettier: {
+      command: ["prettier", "--write", "$FILE"],
+      extensions: [
+        ".js",
+        ".cjs",
+        ".mjs",
+        ".jsx",
+        ".ts",
+        ".tsx",
+        ".json",
+        ".md",
+        ".yaml",
+        ".yml",
+      ],
+    },
+    "markdownlint-cli2": {
+      command: ["markdownlint-cli2", "--fix", "$FILE"],
+      extensions: [".md"],
+    },
+  },
+  chains: {
+    ".md": ["prettier", "markdownlint-cli2"],
+    ".js": ["prettier"],
+    ".cjs": ["prettier"],
+    ".mjs": ["prettier"],
+    ".jsx": ["prettier"],
+    ".ts": ["prettier"],
+    ".tsx": ["prettier"],
+    ".json": ["prettier"],
+    ".yaml": ["prettier"],
+    ".yml": ["prettier"],
+  },
+};
+
+export function createFormatterConfig(
+  userConfig?: UserFormatterConfig,
+): AutoformatConfig {
+  return {
+    formatMode: userConfig?.formatMode ?? DEFAULT_FORMATTER_CONFIG.formatMode,
+    commandTimeoutMs:
+      userConfig?.commandTimeoutMs ?? DEFAULT_FORMATTER_CONFIG.commandTimeoutMs,
+    hideSummariesInTui:
+      userConfig?.hideSummariesInTui ??
+      DEFAULT_FORMATTER_CONFIG.hideSummariesInTui,
+    formatters: {
+      ...DEFAULT_FORMATTER_CONFIG.formatters,
+      ...userConfig?.formatters,
+    },
+    chains: {
+      ...DEFAULT_FORMATTER_CONFIG.chains,
+      ...userConfig?.chains,
+    },
+  };
+}

package/src/formatter-executor.ts

@@ -0,0 +1,68 @@
+import type { ResolvedFormatter } from "./formatter-registry.js";
+
+export type CommandRunResult = {
+  exitCode: number;
+  stdout?: string;
+  stderr?: string;
+};
+
+export type CommandRunnerOptions = {
+  cwd?: string;
+  env?: Record<string, string>;
+};
+
+export type CommandRunner = (
+  command: string,
+  args: string[],
+  options?: CommandRunnerOptions,
+) => Promise<CommandRunResult>;
+
+export type FormatterExecutionResult = {
+  formatterName: string;
+  command: string[];
+  success: boolean;
+  exitCode: number;
+  stdout?: string;
+  stderr?: string;
+};
+
+export async function executeFormatterChain(
+  chain: ResolvedFormatter[],
+  runner: CommandRunner,
+  options?: {
+    cwd?: string;
+  },
+): Promise<FormatterExecutionResult[]> {
+  const results: FormatterExecutionResult[] = [];
+
+  for (const formatter of chain) {
+    const [command, ...args] = formatter.command;
+
+    if (!command) {
+      results.push({
+        formatterName: formatter.name,
+        command: formatter.command,
+        success: false,
+        exitCode: 1,
+        stderr: "Formatter command is empty",
+      });
+      continue;
+    }
+
+    const runResult = await runner(command, args, {
+      cwd: options?.cwd,
+      env: formatter.environment,
+    });
+
+    results.push({
+      formatterName: formatter.name,
+      command: formatter.command,
+      success: runResult.exitCode === 0,
+      exitCode: runResult.exitCode,
+      stdout: runResult.stdout,
+      stderr: runResult.stderr,
+    });
+  }
+
+  return results;
+}

package/src/formatter-registry.ts

@@ -0,0 +1,61 @@
+import path from "node:path";
+
+export type FormatterDefinition = {
+  command: string[];
+  extensions: string[];
+  environment?: Record<string, string>;
+  disabled?: boolean;
+};
+
+export type FormatterConfig = {
+  formatters: Record<string, FormatterDefinition>;
+  chains?: Record<string, string[]>;
+};
+
+export type ResolvedFormatter = {
+  name: string;
+  command: string[];
+  environment?: Record<string, string>;
+};
+
+export function resolveFormatterChainForFile(
+  filePath: string,
+  config: FormatterConfig,
+): ResolvedFormatter[] {
+  const extension = path.extname(filePath).toLowerCase();
+  if (!extension) {
+    return [];
+  }
+
+  const chainNames = config.chains?.[extension];
+  if (!chainNames) {
+    return [];
+  }
+
+  return chainNames
+    .map((formatterName) =>
+      resolveFormatterByName(formatterName, filePath, config),
+    )
+    .filter((formatter): formatter is ResolvedFormatter => formatter !== null);
+}
+
+function resolveFormatterByName(
+  formatterName: string,
+  filePath: string,
+  config: FormatterConfig,
+): ResolvedFormatter | null {
+  const formatter = config.formatters[formatterName];
+  if (!formatter || formatter.disabled) {
+    return null;
+  }
+
+  return {
+    name: formatterName,
+    command: substituteFileToken(formatter.command, filePath),
+    environment: formatter.environment,
+  };
+}
+
+function substituteFileToken(command: string[], filePath: string): string[] {
+  return command.map((arg) => arg.replaceAll("$FILE", filePath));
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+export const extensionName = "pi-autoformat";
+
+export {
+  AUTOFORMAT_CONFIG_FILE_NAME,
+  AUTOFORMAT_EXTENSION_ID,
+  type ConfigValidationIssue,
+  getGlobalConfigPath,
+  getProjectConfigPath,
+  type LoadConfigResult,
+  loadAutoformatConfig,
+  type ValidateConfigResult,
+  validateUserFormatterConfig,
+} from "./config-loader.js";
+export {
+  createAutoformatExtension,
+  default as autoformatExtension,
+} from "./extension.js";
+export {
+  type AutoformatConfig,
+  createFormatterConfig,
+  DEFAULT_FORMATTER_CONFIG,
+  type FormatMode,
+  type UserFormatterConfig,
+} from "./formatter-config.js";
+export {
+  type CommandRunner,
+  type CommandRunnerOptions,
+  type CommandRunResult,
+  executeFormatterChain,
+  type FormatterExecutionResult,
+} from "./formatter-executor.js";
+export {
+  type FormatterConfig,
+  type FormatterDefinition,
+  type ResolvedFormatter,
+  resolveFormatterChainForFile,
+} from "./formatter-registry.js";
+export {
+  PromptAutoformatter,
+  type PromptAutoformatterResult,
+} from "./prompt-autoformatter.js";
+export { TouchedFilesQueue } from "./touched-files-queue.js";

package/src/prompt-autoformatter.ts

@@ -0,0 +1,58 @@
+import {
+  type CommandRunner,
+  executeFormatterChain,
+  type FormatterExecutionResult,
+} from "./formatter-executor.js";
+import {
+  type FormatterConfig,
+  resolveFormatterChainForFile,
+} from "./formatter-registry.js";
+import { TouchedFilesQueue } from "./touched-files-queue.js";
+
+export type PromptAutoformatterResult = {
+  files: Array<{
+    path: string;
+    runs: FormatterExecutionResult[];
+  }>;
+};
+
+export class PromptAutoformatter {
+  private readonly queue: TouchedFilesQueue;
+
+  constructor(
+    private readonly cwd: string,
+    private readonly config: FormatterConfig,
+    private readonly runner: CommandRunner,
+  ) {
+    this.queue = new TouchedFilesQueue(cwd);
+  }
+
+  recordToolResult(toolName: string, payload: unknown): void {
+    this.queue.recordToolResult(toolName, payload);
+  }
+
+  async flushPrompt(): Promise<PromptAutoformatterResult> {
+    const touchedFiles = this.queue.flush();
+    const fileResults: PromptAutoformatterResult["files"] = [];
+
+    for (const filePath of touchedFiles) {
+      const chain = resolveFormatterChainForFile(filePath, this.config);
+      if (chain.length === 0) {
+        continue;
+      }
+
+      const runs = await executeFormatterChain(chain, this.runner, {
+        cwd: this.cwd,
+      });
+
+      fileResults.push({
+        path: filePath,
+        runs,
+      });
+    }
+
+    return {
+      files: fileResults,
+    };
+  }
+}