pi-mono-all 1.0.0

package/node_modules/pi-mono-ask-user-question/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "pi-mono-ask-user-question",
+  "version": "1.7.3",
+  "description": "Pi extension for asking users structured interactive questions",
+  "keywords": [
+    "pi-package",
+    "pi-extension"
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*",
+    "@sinclair/typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emanuelcasco/pi-mono-extensions.git",
+    "directory": "extensions/ask-user-question"
+  },
+  "bugs": {
+    "url": "https://github.com/emanuelcasco/pi-mono-extensions/issues"
+  },
+  "homepage": "https://github.com/emanuelcasco/pi-mono-extensions#readme"
+}

package/node_modules/pi-mono-auto-fix/CHANGELOG.md

@@ -0,0 +1,59 @@
+# pi-mono-auto-fix
+
+## 0.3.0
+
+### Added
+
+- **ESLint version-aware dispatch with config detection**: Auto-fix now determines the project's ESLint version and config format before running.
+  - Walks from the file's directory up to `package.json` to find the project root.
+  - Detects flat (`eslint.config.*`) vs. legacy (`.eslintrc.*`) configs.
+  - Reads the installed ESLint major version from `node_modules/eslint/package.json`.
+    | Local ESLint | Config Format | Action |
+    | --- | --- | --- |
+    | v8 | Flat config | **Skip** — incompatible |
+    | v9+ | Legacy config | Use local + `ESLINT_USE_FLAT_CONFIG=false` |
+    | v8 | Legacy config | Use local binary directly |
+    | v9+ | Flat config | Use local binary directly |
+    | None | Legacy config | `npx --yes eslint@8` |
+    | None | Flat config | `npx --yes eslint@9` |
+    | None | No config | **Skip** — avoids injecting rules on projects that don't use ESLint |
+
+### Changed
+
+- `resolveSpawnTarget` now returns `{ command, spawnCwd, env? }` so fixers can pass environment overrides (e.g. `ESLINT_USE_FLAT_CONFIG`).
+- `runFixer` branches labelled `"eslint"` through the new `resolveEslintCommand` resolver.
+
+### Fixed
+
+- Tightened `spawn` invocation typing for the release package without changing runtime behavior.
+
+## 0.2.2
+
+### Fixed
+
+- **eslint failing on every file in projects pinned to v8**: The `0.2.1` neutral-cwd fix made `npx eslint` resolve from `/tmp`, which auto-installs the latest ESLint (v10+) and ignores the project's pinned version and config. Projects on ESLint v8 with `.eslintrc.*` then failed with "ESLint couldn't find an eslint.config.(js|mjs|cjs) file." on every file. Auto-fix now walks up from each file to find a project-local `node_modules/.bin/<tool>` and execs it directly with the project root as cwd, falling back to neutral-cwd npx only when no local install exists.
+
+## 0.2.0
+
+### Fixed
+
+- **Auto-install dependencies**: Fixers now use `npx` (without `--no-install`) for eslint/prettier and `uvx` for ruff, auto-installing if missing — no manual install required.
+- **False failure reporting with eslint**: `eslint --fix` exits non-zero when it finds unfixable issues, even if it successfully fixed others in the same pass. Failure detection now checks mtime (file actually changed) instead of exit code, so successful fixes are no longer reported as failures.
+- **npx broken in pnpm monorepos**: `npx` delegates to pnpm when `package.json` declares `"packageManager": "pnpm"`, but `pnpm exec` doesn't auto-install like npx does. Fixers now use a neutral cwd (`/tmp`) for npx commands to bypass project-level toolchain interference.
+
+### Changed
+
+- Python fixer swapped from `black` (global install required) to `uvx ruff check --fix && uvx ruff format` (auto-installs via PyPI, faster).
+
+## 0.1.0
+
+### Minor Changes
+
+### New Extension: auto-fix
+
+End-of-turn formatter/linter dispatcher. Subscribes to `tool_result` (for `edit` / `write`) and the `context-guard:file-modified` event bus to collect every path written during a turn, then on `agent_end` routes each path to a language-appropriate fixer (eslint / black / prettier by default) and runs them in parallel. Re-emits `context-guard:file-modified` for files whose mtime actually changed so downstream read caches evict.
+
+- Configurable via `~/.pi/agent/auto-fix.json` (fixers, ignore patterns, timeout, concurrency)
+- Disable with `PI_AUTO_FIX=0`
+- Silent stdout/stderr; single summary notification per flush
+- Paths outside `ctx.cwd` and deleted files are skipped automatically

package/node_modules/pi-mono-auto-fix/README.md

@@ -0,0 +1,77 @@
+# pi-mono-auto-fix
+
+End-of-turn formatter/linter dispatcher for pi. Collects every file written during a turn and applies language-appropriate fixers (eslint, black, prettier, …) in one batch once the agent stops talking.
+
+## What it does
+
+- Subscribes to `tool_result` for the built-in `edit` and `write` tools, plus the `context-guard:file-modified` event that `multi-edit` and other writers emit.
+- Buffers absolute paths of touched files in a per-turn `Set`.
+- On `agent_end`, groups paths by matching fixer, runs each fixer once per group (parallel up to `concurrency`).
+- After each run, re-emits `context-guard:file-modified` for any file whose mtime actually changed, so downstream read caches evict.
+- Emits a single notification at the end (`auto-fix: N/M files updated`).
+
+Fixers are invoked silently — stdout/stderr are swallowed. Failures are reported in the summary notification but never surfaced into the LLM context.
+
+## Built-in fixer rules
+
+| Extensions                                        | Command                                                        |
+| ------------------------------------------------- | -------------------------------------------------------------- |
+| `.ts .tsx .js .jsx .mjs .cjs`                     | `npx --no-install eslint --fix --no-error-on-unmatched-pattern {files}` |
+| `.py`                                             | `black -q {files}`                                             |
+| `.json .md .yml .yaml .css .scss .html`           | `npx --no-install prettier --write --log-level=warn {files}`   |
+
+`{files}` is replaced with shell-quoted, space-separated absolute paths. If the token is missing, files are appended to the end of the command.
+
+Commands run with `shell: true`, `cwd = ctx.cwd`, and a per-invocation timeout (default 60s).
+
+## Configuration
+
+Resolution order (first hit wins):
+
+1. `PI_AUTO_FIX=0` → extension is fully disabled (no listeners registered)
+2. `~/.pi/agent/auto-fix.json`
+3. built-in defaults
+
+Example `~/.pi/agent/auto-fix.json`:
+
+```json
+{
+  "enabled": true,
+  "timeoutMs": 90000,
+  "concurrency": 2,
+  "ignore": ["node_modules/", "dist/", ".git/", "vendor/"],
+  "fixers": [
+    {
+      "label": "biome",
+      "extensions": [".ts", ".tsx", ".js", ".jsx"],
+      "command": "npx --no-install biome check --write --no-errors-on-unmatched {files}"
+    },
+    {
+      "label": "ruff",
+      "extensions": [".py"],
+      "command": "ruff check --fix {files} && ruff format {files}"
+    }
+  ]
+}
+```
+
+All fields are optional; anything omitted falls back to the built-in default.
+
+## Install
+
+```bash
+pi install npm:pi-mono-auto-fix
+```
+
+Or load directly for testing:
+
+```bash
+pi -e /path/to/pi-extensions/extensions/auto-fix/index.ts
+```
+
+## Notes
+
+- Paths outside `ctx.cwd` are skipped for safety.
+- Paths matching any substring in `ignore` are skipped.
+- Files deleted during the turn are skipped (existence is re-checked at flush time).
+- The mtime diff catches fixers that are no-ops on already-clean files, so the summary reflects real changes rather than just invocations.

package/node_modules/pi-mono-auto-fix/index.ts

@@ -0,0 +1,488 @@
+/**
+ * auto-fix — end-of-turn formatter/linter dispatcher.
+ *
+ * Collects every file written during a turn (via `edit` / `write` tool
+ * results and `context-guard:file-modified` events), then on `agent_end`
+ * dispatches each file to a language-appropriate fixer command (eslint,
+ * black, prettier, etc.). Fixes are applied silently; the user is only
+ * notified of the final summary.
+ *
+ * Config resolution order (first hit wins):
+ *   1. PI_AUTO_FIX=0 → extension is disabled entirely
+ *   2. ~/.pi/agent/auto-fix.json
+ *   3. built-in defaults (see DEFAULT_FIXERS below)
+ */
+
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, extname, isAbsolute, relative, resolve } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+interface FixerRule {
+  /** File extensions this rule matches (include leading dot, lowercase). */
+  extensions: string[];
+  /** Shell command; `{files}` is replaced with space-separated, quoted paths. */
+  command: string;
+  /** Optional human-readable label used in notifications. */
+  label?: string;
+}
+
+interface Config {
+  enabled: boolean;
+  fixers: FixerRule[];
+  /** Glob-ish substring ignore patterns applied to the relative path. */
+  ignore: string[];
+  /** Per-fixer timeout in ms. */
+  timeoutMs: number;
+  /** Max parallel fixer invocations. */
+  concurrency: number;
+}
+
+const DEFAULT_FIXERS: FixerRule[] = [
+  {
+    label: "eslint",
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+    command: "npx eslint --fix --no-error-on-unmatched-pattern {files}",
+  },
+  {
+    label: "ruff",
+    extensions: [".py"],
+    command:
+      "uvx ruff check --fix --quiet {files} && uvx ruff format --quiet {files}",
+  },
+  {
+    label: "prettier",
+    extensions: [".json", ".md", ".yml", ".yaml", ".css", ".scss", ".html"],
+    command: "npx prettier --write --log-level=warn {files}",
+  },
+];
+
+const DEFAULT_CONFIG: Config = {
+  enabled: true,
+  fixers: DEFAULT_FIXERS,
+  ignore: ["node_modules/", "dist/", "build/", ".git/", ".next/", "coverage/"],
+  timeoutMs: 60_000,
+  concurrency: 3,
+};
+
+const CONFIG_PATH = `${homedir()}/.pi/agent/auto-fix.json`;
+
+function loadConfig(): Config {
+  if (process.env.PI_AUTO_FIX === "0") {
+    return { ...DEFAULT_CONFIG, enabled: false };
+  }
+  if (!existsSync(CONFIG_PATH)) return DEFAULT_CONFIG;
+  try {
+    const parsed = JSON.parse(
+      readFileSync(CONFIG_PATH, "utf-8"),
+    ) as Partial<Config>;
+    return {
+      enabled: parsed.enabled ?? DEFAULT_CONFIG.enabled,
+      fixers: parsed.fixers ?? DEFAULT_CONFIG.fixers,
+      ignore: parsed.ignore ?? DEFAULT_CONFIG.ignore,
+      timeoutMs: parsed.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,
+      concurrency: parsed.concurrency ?? DEFAULT_CONFIG.concurrency,
+    };
+  } catch {
+    return DEFAULT_CONFIG;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function shellQuote(s: string): string {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+
+function matchFixer(
+  absPath: string,
+  fixers: FixerRule[],
+): FixerRule | undefined {
+  const ext = extname(absPath).toLowerCase();
+  if (!ext) return undefined;
+  return fixers.find((f) => f.extensions.includes(ext));
+}
+
+function isIgnored(relPath: string, ignore: string[]): boolean {
+  return ignore.some((p) => relPath.includes(p));
+}
+
+function mtimeSafe(path: string): number {
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return -1;
+  }
+}
+
+/**
+ * Walk up from `startDir` until a directory containing `node_modules/.bin/<tool>`
+ * is found. Returns `{ binPath, projectRoot }` or undefined.
+ */
+function findLocalBin(
+  startDir: string,
+  tool: string,
+): { binPath: string; projectRoot: string } | undefined {
+  let dir = startDir;
+  while (true) {
+    const binPath = `${dir}/node_modules/.bin/${tool}`;
+    if (existsSync(binPath)) return { binPath, projectRoot: dir };
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+/**
+ * Walk up from `startDir` until a `package.json` is found.
+ */
+function findProjectRoot(startDir: string): string | undefined {
+  let dir = startDir;
+  while (true) {
+    if (existsSync(`${dir}/package.json`)) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+}
+
+const ESLINT_FLAT_CONFIG_FILES = [
+  "eslint.config.mjs",
+  "eslint.config.js",
+  "eslint.config.cjs",
+  "eslint.config.ts",
+  "eslint.config.mts",
+  "eslint.config.cts",
+];
+
+const ESLINT_LEGACY_CONFIG_FILES = [
+  ".eslintrc.cjs",
+  ".eslintrc.mjs",
+  ".eslintrc.js",
+  ".eslintrc.json",
+  ".eslintrc.yaml",
+  ".eslintrc.yml",
+  ".eslintrc",
+];
+
+function detectEslintConfigType(projectRoot: string): "flat" | "legacy" | "none" {
+  for (const f of ESLINT_FLAT_CONFIG_FILES) {
+    if (existsSync(`${projectRoot}/${f}`)) return "flat";
+  }
+  for (const f of ESLINT_LEGACY_CONFIG_FILES) {
+    if (existsSync(`${projectRoot}/${f}`)) return "legacy";
+  }
+  return "none";
+}
+
+function getEslintVersion(projectRoot: string): number | null {
+  const pkgPath = `${projectRoot}/node_modules/eslint/package.json`;
+  if (!existsSync(pkgPath)) return null;
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const major = parseInt(pkg.version.split(".")[0], 10);
+    return isNaN(major) ? null : major;
+  } catch {
+    return null;
+  }
+}
+
+interface SpawnTarget {
+  command: string | null;
+  spawnCwd: string;
+  env?: Record<string, string>;
+}
+
+/**
+ * ESLint-specific resolver that avoids version / config mismatches.
+ *
+ * Logic:
+ *   1. Local ESLint installed?
+ *      a. v9+  + legacy config → use local + ESLINT_USE_FLAT_CONFIG=false
+ *      b. v8   + flat   config → skip (incompatible)
+ *      c. otherwise              → use local binary directly
+ *   2. No local ESLint?
+ *      a. legacy config → `npx --yes eslint@8`  (pin v8)
+ *      b. flat   config → `npx --yes eslint@9`  (pin v9+)
+ *      c. no config     → skip
+ */
+function resolveEslintCommand(
+  commandTemplate: string,
+  files: string[],
+  cwd: string,
+): SpawnTarget {
+  const firstFile = files[0];
+  const fileDir = firstFile ? dirname(firstFile) : cwd;
+  const projectRoot = findProjectRoot(fileDir) ?? cwd;
+
+  const local = findLocalBin(fileDir, "eslint");
+  const configType = detectEslintConfigType(projectRoot);
+  const filesArg = files.map(shellQuote).join(" ");
+
+  // Strip the binary invocation and {files} placeholder to keep only flags.
+  const extraArgs = commandTemplate
+    .replace(/^npx\s+/, "")
+    .replace(/^(?:[.\\/][\S]+[\\/])?eslint(?:\.exe)?\b\s*/, "")
+    .replace("{files}", "")
+    .trim();
+
+  // CASE 1: Local ESLint installed — honour project's pinned version.
+  if (local) {
+    const version = getEslintVersion(local.projectRoot);
+
+    // ESLint v9+ on a legacy-config project: force legacy mode so the v9
+    // binary can still read .eslintrc.* files.
+    if (version !== null && version >= 9 && configType === "legacy") {
+      return {
+        command: `${shellQuote(local.binPath)} ${extraArgs} ${filesArg}`.trim(),
+        spawnCwd: local.projectRoot,
+        env: { ESLINT_USE_FLAT_CONFIG: "false" },
+      };
+    }
+
+    // ESLint v8 on a flat-config project: incompatible — skip.
+    if (version !== null && version < 9 && configType === "flat") {
+      return { command: null, spawnCwd: local.projectRoot };
+    }
+
+    return {
+      command: `${shellQuote(local.binPath)} ${extraArgs} ${filesArg}`.trim(),
+      spawnCwd: local.projectRoot,
+    };
+  }
+
+  // CASE 2: No local ESLint — pin a version compatible with the project's
+  // config format so we never install latest v9 on a legacy-config repo.
+  if (configType === "legacy") {
+    return {
+      command: `npx --yes eslint@8 ${extraArgs} ${filesArg}`.trim(),
+      spawnCwd: projectRoot,
+    };
+  }
+
+  if (configType === "flat") {
+    return {
+      command: `npx --yes eslint@9 ${extraArgs} ${filesArg}`.trim(),
+      spawnCwd: projectRoot,
+    };
+  }
+
+  // CASE 3: No ESLint config found — skip to avoid injecting unwanted rules.
+  return { command: null, spawnCwd: projectRoot };
+}
+
+/**
+ * If `command` starts with `npx <tool>`, attempt to resolve a project-local
+ * binary by walking up from the first file. On hit, rewrite the command to
+ * exec the local bin directly and return the project root as cwd. On miss,
+ * fall back to `/tmp` so npx can fetch the latest from the registry without
+ * being delegated through pnpm.
+ */
+function resolveSpawnTarget(
+  command: string,
+  files: string[],
+  cwd: string,
+): SpawnTarget {
+  const npxMatch = command.match(/^npx\s+(\S+)/);
+  if (!npxMatch) return { command, spawnCwd: cwd };
+
+  const tool = npxMatch[1];
+  const firstFile = files[0];
+  if (firstFile) {
+    const local = findLocalBin(dirname(firstFile), tool);
+    if (local) {
+      return {
+        command: command.replace(/^npx\s+\S+/, shellQuote(local.binPath)),
+        spawnCwd: local.projectRoot,
+      };
+    }
+  }
+  // No local install — neutral cwd avoids pnpm delegating npx.
+  return { command, spawnCwd: "/tmp" };
+}
+
+async function runFixer(
+  rule: FixerRule,
+  files: string[],
+  cwd: string,
+  timeoutMs: number,
+): Promise<{ ok: boolean; stderr: string }> {
+  const filesArg = files.map(shellQuote).join(" ");
+
+  let resolved: SpawnTarget;
+
+  if (rule.label === "eslint") {
+    // ESLint gets version-aware command resolution so we don't install a
+    // global v9 on a legacy v8-configured project (or vice-versa).
+    resolved = resolveEslintCommand(rule.command, files, cwd);
+  } else {
+    const rawCommand = rule.command.includes("{files}")
+      ? rule.command.replace("{files}", filesArg)
+      : `${rule.command} ${filesArg}`;
+    // Prefer the project's locally installed binary when available so we
+    // honor the pinned version + config. Only fall back to neutral-cwd npx
+    // when no local install is found, which sidesteps pnpm's delegation of
+    // npx without auto-install.
+    resolved = resolveSpawnTarget(rawCommand, files, cwd);
+  }
+
+  const command = resolved.command;
+  if (command === null) {
+    return {
+      ok: true,
+      stderr: `Skipped ${rule.label ?? rule.command}: no compatible target found.`,
+    };
+  }
+
+  return new Promise((resolvePromise) => {
+    const child = spawn(command, [], {
+      cwd: resolved.spawnCwd,
+      shell: true,
+      env: { ...process.env, ...resolved.env },
+    });
+    let stderr = "";
+    const timer = setTimeout(() => child.kill("SIGTERM"), timeoutMs);
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolvePromise({ ok: false, stderr });
+    });
+    child.on("close", (code: number | null) => {
+      clearTimeout(timer);
+      resolvePromise({ ok: code === 0, stderr });
+    });
+  });
+}
+
+async function runWithConcurrency<T>(
+  items: T[],
+  limit: number,
+  worker: (item: T) => Promise<void>,
+): Promise<void> {
+  const queue = [...items];
+  const workers = Array.from(
+    { length: Math.min(limit, queue.length) },
+    async () => {
+      while (queue.length) {
+        const item = queue.shift();
+        if (item === undefined) return;
+        await worker(item);
+      }
+    },
+  );
+  await Promise.all(workers);
+}
+
+// ---------------------------------------------------------------------------
+// Extension
+// ---------------------------------------------------------------------------
+
+export default function (pi: ExtensionAPI): void {
+  const cfg = loadConfig();
+  if (!cfg.enabled) return;
+
+  /** Absolute paths written during the current turn. */
+  const pending = new Set<string>();
+
+  function collect(rawPath: string, cwd: string): void {
+    if (!rawPath) return;
+    const absolutePath = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
+    const rel = relative(cwd, absolutePath);
+    if (rel.startsWith("..")) return; // outside cwd — skip
+    if (isIgnored(rel, cfg.ignore)) return;
+    pending.add(absolutePath);
+  }
+
+  // Reset between agent runs (turn boundary for pi's purposes).
+  pi.on("agent_start", () => {
+    pending.clear();
+  });
+
+  // Collector 1: direct edit/write tool results.
+  pi.on("tool_result", async (event, ctx) => {
+    if (event.isError) return;
+    if (event.toolName !== "edit" && event.toolName !== "write") return;
+    const rawPath = (event.input as { path?: string }).path;
+    if (rawPath) collect(rawPath, ctx.cwd);
+  });
+
+  // End-of-turn flush.
+  pi.on("agent_end", async (_event, ctx) => {
+    if (!pending.size) return;
+    const paths = [...pending];
+    pending.clear();
+
+    await flush(paths, ctx);
+  });
+
+  async function flush(paths: string[], ctx: ExtensionContext): Promise<void> {
+    // Filter to existing files and group by fixer rule.
+    const groups = new Map<FixerRule, string[]>();
+    for (const p of paths) {
+      if (!existsSync(p)) continue;
+      const rule = matchFixer(p, cfg.fixers);
+      if (!rule) continue;
+      const bucket = groups.get(rule) ?? [];
+      bucket.push(p);
+      groups.set(rule, bucket);
+    }
+    if (!groups.size) return;
+
+    let changed = 0;
+    const failures: string[] = [];
+    const jobs = [...groups.entries()];
+
+    await runWithConcurrency(jobs, cfg.concurrency, async ([rule, files]) => {
+      // Snapshot mtimes *before* running this fixer group.
+      const groupBefore = new Map(files.map((p) => [p, mtimeSafe(p)]));
+
+      const result = await runFixer(rule, files, ctx.cwd, cfg.timeoutMs);
+
+      // Count how many files this fixer actually changed.
+      const groupChanged = files.filter(
+        (p) => mtimeSafe(p) !== groupBefore.get(p),
+      ).length;
+      changed += groupChanged;
+
+      // Only count as failure if the tool failed AND no files changed.
+      // Some tools (eslint --fix) exit non-zero even when they fix things.
+      if (!result.ok && groupChanged === 0) {
+        failures.push(
+          `${rule.label ?? rule.command.split(" ")[0]} (${files.length} file${files.length === 1 ? "" : "s"})`,
+        );
+      }
+
+      // Re-emit file-modified for anything the fixer actually rewrote so
+      // context-guard evicts its stale read cache.
+      for (const p of files) {
+        if (mtimeSafe(p) !== groupBefore.get(p)) {
+          pi.events.emit("context-guard:file-modified", { path: p });
+        }
+      }
+    });
+
+    const total = [...groups.values()].reduce((n, b) => n + b.length, 0);
+    if (changed > 0 || failures.length) {
+      const parts: string[] = [
+        `auto-fix: ${changed}/${total} file${total === 1 ? "" : "s"} updated`,
+      ];
+      if (failures.length) parts.push(`failed: ${failures.join(", ")}`);
+      ctx.ui.notify(
+        `[auto-fix] ${parts.join(" — ")}`,
+        failures.length ? "warning" : "info",
+      );
+    }
+  }
+}

package/node_modules/pi-mono-auto-fix/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "pi-mono-auto-fix",
+  "version": "0.3.0",
+  "description": "Pi extension that runs language-appropriate fixers (eslint, black, prettier, ...) on files touched during a turn",
+  "keywords": [
+    "pi-package",
+    "pi-extension"
+  ],
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@sinclair/typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emanuelcasco/pi-mono-extensions.git",
+    "directory": "extensions/auto-fix"
+  }
+}