@herbertgao/pi-extensions 2026.8.1 → 2026.8.2

package/node_modules/@czottmann/pi-automode/extensions/auto-mode/paths.ts

@@ -7,7 +7,7 @@ import {
   relative,
   resolve,
 } from "node:path";
-import { HOME, PROFILE_FILES } from "./constants.ts";
+import { HOME, PATH_BEARING_TOOLS, PROFILE_FILES } from "./constants.ts";
 
 function stripLeadingAt(value: string): string {
   return value.startsWith("@") ? value.slice(1) : value;
@@ -22,6 +22,28 @@ export function resolveInputPath(
   return isAbsolute(raw) ? resolve(raw) : resolve(cwd, raw);
 }
 
+/** The target path a file tool operates on, from `input.path` (or undefined). */
+export function extractInputPath(
+  toolName: string,
+  input: Record<string, unknown>,
+): string | undefined {
+  if (!PATH_BEARING_TOOLS.has(toolName)) return undefined;
+  const value = input.path;
+  return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+
+/** Expand a leading `~`, `$HOME`, or `${HOME}` in a path-denial pattern. */
+export function expandHomePattern(pattern: string): string {
+  const home = HOME.replace(/\\/g, "/");
+  if (pattern === "~" || pattern === "$HOME" || pattern === "${HOME}") {
+    return home;
+  }
+  if (pattern.startsWith("~/")) return `${home}/${pattern.slice(2)}`;
+  if (pattern.startsWith("$HOME/")) return `${home}/${pattern.slice(6)}`;
+  if (pattern.startsWith("${HOME}/")) return `${home}/${pattern.slice(8)}`;
+  return pattern;
+}
+
 export function normalizePathForMatch(path: string, cwd: string): string {
   const normalized = normalize(path);
   const rel = relative(cwd, normalized);

package/node_modules/@czottmann/pi-automode/extensions/auto-mode/permissions.ts

@@ -1,5 +1,9 @@
 import type { ToolPattern } from "./types.ts";
-import { normalizePathForMatch, resolveInputPath } from "./paths.ts";
+import {
+  expandHomePattern,
+  normalizePathForMatch,
+  resolveInputPath,
+} from "./paths.ts";
 
 function normalizeToolName(name: string): string {
   const lower = name.trim().replace(/^@/, "").toLowerCase();
@@ -75,6 +79,23 @@ function getPrimaryArgument(
   return JSON.stringify(input);
 }
 
+/**
+ * Whether a resolved absolute path matches a configured path-denial pattern.
+ * Patterns support `~`/`$HOME` expansion and `*` globs, where `*` matches any
+ * characters, including `/`. Matching is case-insensitive and
+ * conservative-safe: over-matching only blocks more.
+ */
+export function matchesDeniedPath(
+  resolvedPath: string,
+  deniedPaths: string[],
+): boolean {
+  const normalized = resolvedPath.replace(/\\/g, "/");
+  return deniedPaths.some((pattern) => {
+    const expanded = expandHomePattern(pattern).replace(/\\/g, "/");
+    return wildcardToRegExp(expanded).test(normalized);
+  });
+}
+
 /** Match a scoped permission rule against a concrete tool call. */
 export function matchesToolPattern(
   pattern: ToolPattern,

package/node_modules/@czottmann/pi-automode/extensions/auto-mode/types.ts

@@ -40,6 +40,14 @@ export type AutoModeSettings = {
   enabled?: boolean;
   classifierModel?: string;
   classifierReasoningLevel?: ClassifierReasoningLevel;
+  /** When true, read-only tools (read/grep/find/ls) are classified instead of auto-allowed. */
+  classifyReadOnlyTools?: boolean;
+  /** Override the fast-stage completion token budget (default 512). */
+  fastClassifierMaxTokens?: number;
+  /** When true, file tools whose resolved path is inside the working directory are allowed deterministically (no classifier), and outside-CWD file access is classified. */
+  allowInsideWorkingDirectory?: boolean;
+  /** Path glob patterns (file tools) that are always denied before the classifier. Supports `~` and `*` (matches any characters, including `/`). */
+  deniedPaths?: unknown;
   maxUserTranscriptTokens?: number;
   maxToolTranscriptTokens?: number;
   environment?: unknown;
@@ -76,6 +84,10 @@ export type EffectiveConfig = {
   enabled: boolean;
   classifierModel?: string;
   classifierReasoningLevel?: ClassifierReasoningLevel;
+  classifyReadOnlyTools: boolean;
+  fastClassifierMaxTokens: number;
+  allowInsideWorkingDirectory: boolean;
+  deniedPaths: string[];
   maxUserTranscriptTokens: number;
   maxToolTranscriptTokens: number;
   environment: string[];
@@ -108,12 +120,16 @@ export type DenialRecord = {
     | "permissions.deny"
     | "permissions.ask"
     | "deterministic-hard-deny"
+    | "deterministic-path-deny"
     | "classifier"
     | "setup";
 };
 
-/** Denial kind plus the read-only fast path, used for decision log entries. */
-export type DecisionKind = DenialRecord["kind"] | "read-only";
+/** Denial kind plus the deterministic allow fast paths, used for decision log entries. */
+export type DecisionKind =
+  | DenialRecord["kind"]
+  | "read-only"
+  | "inside-working-directory";
 
 export type ClassificationDecision = {
   decision: "allow" | "block";

package/node_modules/@czottmann/pi-automode/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@czottmann/pi-automode",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Claude Code-style auto mode guardrail for pi.",
   "repository": {
     "url": "https://github.com/czottmann/pi-automode"
@@ -41,9 +41,9 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.81.1",
-    "@earendil-works/pi-coding-agent": "^0.81.1",
-    "@earendil-works/pi-tui": "^0.81.1",
+    "@earendil-works/pi-ai": "^0.84.1",
+    "@earendil-works/pi-coding-agent": "^0.84.1",
+    "@earendil-works/pi-tui": "^0.84.1",
     "@types/node": "^24.0.0",
     "tsx": "^4.22.4",
     "typescript": "^5.8.0"

package/node_modules/@dietrichgebert/ponytail/.opencode/command/ponytail-audit.md

@@ -0,0 +1,5 @@
+---
+description: Audit the whole repo for over-engineering, what can be deleted
+---
+
+Audit the entire repository for over-engineering only, not correctness. Scan the whole tree, not a diff. One line per finding, ranked biggest cut first: <tag> <what to cut>. <replacement>. [path]. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines and dependencies removable. If nothing to cut: 'Lean already. Ship.'

package/node_modules/@dietrichgebert/ponytail/.opencode/command/ponytail-debt.md

@@ -0,0 +1,5 @@
+---
+description: "Harvest ponytail: comments into a tracked debt ledger"
+---
+
+Harvest every `ponytail:` comment in this repository into a debt ledger so deferrals do not rot into 'later means never'. Grep the whole tree for comment markers (grep -rnE '(#|//) ?ponytail:' ., skipping node_modules/.git/build output). One row per marker, grouped by file: <file>:<line>, <what was simplified>. ceiling: <the limit named in the comment>. upgrade: <the trigger to revisit>. Tag any marker that names no upgrade path or trigger as no-trigger, those rot silently. End with the count of markers and how many lack a trigger. If none: 'No ponytail: debt. Clean ledger.' Report only, change nothing.

package/node_modules/@dietrichgebert/ponytail/.opencode/command/ponytail-gain.md

@@ -0,0 +1,5 @@
+---
+description: Show ponytail's measured impact scoreboard (less code, cost, time)
+---
+
+Show the ponytail gain scoreboard. One shot, change nothing: do not switch mode, write flag files, or persist anything. Render the published benchmark medians (5 everyday tasks; models Haiku, Sonnet, Opus; source benchmarks/ and the README) as plain ASCII bars: Lines of code, no-skill 100% vs ponytail 6-20% (down 80-94%); Cost, no-skill 100% vs ponytail 23-53% (down 47-77%); Speed, ponytail 3-6x faster. The bar length shows the measured range, the label carries the exact figure. These are benchmark medians, not this repo. NEVER print a per-repo savings number: the unbuilt version was never written, so there is no real baseline to subtract from in a live repo. For real per-repo figures, point to /ponytail-debt (the counted shortcut ledger) and /ponytail-audit (what is still cuttable). Report only.

package/node_modules/@dietrichgebert/ponytail/.opencode/command/ponytail-help.md

@@ -0,0 +1,5 @@
+---
+description: Quick reference for ponytail levels, skills, and commands
+---
+
+Show the ponytail quick reference. One shot, change nothing: do not switch mode, write flag files, or persist anything. Levels: /ponytail lite (build what's asked, name the lazier alternative in one line), /ponytail (full, the default ladder: YAGNI then stdlib then native then one line then minimum), /ponytail ultra (deletion before addition, challenges the requirement before building). Commands: /ponytail-review (over-engineering review of the current changes), /ponytail-audit (whole-repo over-engineering audit), /ponytail-debt (harvest ponytail: comments into a tracked ledger), /ponytail-gain (measured-impact scoreboard from the benchmark), /ponytail-help (this card). Deactivate with 'stop ponytail', 'normal mode', or /ponytail off; resume anytime with /ponytail. Default mode is full; change it with the PONYTAIL_DEFAULT_MODE environment variable (off|lite|full|ultra) or a config file at ~/.config/ponytail/config.json (Windows: %APPDATA%\ponytail\config.json) with {"defaultMode": "lite"}. Resolution order: env var, then config file, then full.

package/node_modules/@dietrichgebert/ponytail/.opencode/command/ponytail-review.md

@@ -0,0 +1,5 @@
+---
+description: Review changes for over-engineering, what can be deleted
+---
+
+Review the current code changes for over-engineering only, not correctness. One line per finding: L<line>: <tag> <what to cut>. <replacement>. Tags: delete (dead code/speculative feature), stdlib (reinvented standard library), native (dependency doing what the platform does), yagni (abstraction with one implementation), shrink (same logic, fewer lines). End with the net lines removable. If nothing to cut: 'Lean already. Ship.'

package/node_modules/@dietrichgebert/ponytail/.opencode/command/ponytail.md

@@ -0,0 +1,5 @@
+---
+description: Switch ponytail intensity level (lite/full/ultra/off)
+---
+
+Switch to ponytail $ARGUMENTS mode. If no level specified, use full. Lazy senior dev mode, before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark deliberate simplifications that cut a real corner with a known ceiling using a ponytail: comment that names the ceiling and upgrade path.

package/node_modules/@dietrichgebert/ponytail/.opencode/plugins/ponytail-frontmatter.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+// ponytail command-file frontmatter parser.
+//
+// Pulled out of ponytail.mjs so the plugin module's only top-level export is
+// the plugin function itself. OpenCode's legacy plugin loader (the one that
+// runs before v1 plugins are detected) treats every function exported from a
+// plugin module as a plugin; calling the frontmatter parser as one threw
+// "path must be a string or a file descriptor" because it got the plugin
+// context object as its first argument. Keeping the parser in its own module
+// leaves exactly one plugin-shaped export on ponytail.mjs.
+
+function parseCommandFile(filePath) {
+  const fs = require('fs');
+  const content = fs.readFileSync(filePath, 'utf8');
+  // Tolerate CRLF: a Windows checkout (autocrlf) delivers \r\n, npm ships \n.
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+  if (!match) return null;
+  const description = match[1].match(/description:\s*(.+)/)?.[1]?.trim();
+  return { description, template: match[2].trim() };
+}
+
+module.exports = { parseCommandFile };

package/node_modules/@dietrichgebert/ponytail/.opencode/plugins/ponytail.mjs

@@ -0,0 +1,99 @@
+// ponytail — OpenCode plugin.
+//
+// Injects the ponytail ruleset into every chat's system prompt at the active
+// intensity, persists /ponytail mode switches, and registers slash commands so
+// they work when the package is installed from npm. Reuses the shared
+// instruction builder so Claude Code, Codex, pi, and OpenCode all read one
+// source of truth.
+//
+// OpenCode loads this as a server plugin — add it to your opencode.json:
+//   { "plugin": ["@dietrichgebert/ponytail"] }
+
+import { createRequire } from 'module';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// The shared instruction builder is CommonJS; bridge to it from this ES module.
+const require = createRequire(import.meta.url);
+const { getPonytailInstructions } = require('../../hooks/ponytail-instructions');
+const { getDefaultMode, normalizePersistedMode } = require('../../hooks/ponytail-config');
+const { parseCommandFile } = require('./ponytail-frontmatter.cjs');
+
+// OpenCode has no flag-file convention of its own; keep mode beside its config.
+const statePath = path.join(
+  process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'),
+  'opencode',
+  '.ponytail-active',
+);
+
+function readMode() {
+  try {
+    return normalizePersistedMode(fs.readFileSync(statePath, 'utf8').trim()) || getDefaultMode();
+  } catch (e) {
+    return getDefaultMode();
+  }
+}
+
+function writeMode(mode) {
+  fs.mkdirSync(path.dirname(statePath), { recursive: true });
+  fs.writeFileSync(statePath, mode);
+}
+
+export default async ({ client } = {}) => {
+  const log = (level, message) => {
+    try { client && client.app && client.app.log({ body: { service: 'ponytail', level, message } }); } catch (e) {}
+  };
+
+  const ponytailSkillsDir = path.resolve(__dirname, '../../skills');
+
+  return {
+    // Register slash commands + skills directory.
+    config: async (config) => {
+      if (!config.command) config.command = {};
+      const commandDir = path.join(__dirname, '..', 'command');
+      try {
+        for (const file of fs.readdirSync(commandDir).filter((f) => f.endsWith('.md'))) {
+          const name = path.basename(file, '.md');
+          const parsed = parseCommandFile(path.join(commandDir, file));
+          if (parsed) config.command[name] = parsed;
+        }
+      } catch (e) {}
+
+      config.skills = config.skills || {};
+      config.skills.paths = config.skills.paths || [];
+      if (!config.skills.paths.includes(ponytailSkillsDir)) {
+        config.skills.paths.push(ponytailSkillsDir);
+      }
+    },
+
+    // Append the ruleset to the system prompt every turn.
+    'experimental.chat.system.transform': async (_input, output) => {
+      const mode = readMode();
+      if (mode === 'off') return;
+      const instructions = getPonytailInstructions(mode);
+      if (output.system.length > 0) {
+        output.system[output.system.length - 1] += '\n\n' + instructions;
+      } else {
+        output.system.push(instructions);
+      }
+    },
+
+    // Persist `/ponytail <level>` so the next turn's injection follows it.
+    // ponytail: mode applies from the next message, not the current one — the
+    // transform reads the flag the command writes. Good enough; switch to a
+    // synchronous store if same-turn switching ever matters.
+    'command.execute.before': async (input) => {
+      if (!input || input.command !== 'ponytail') return;
+      // `off` is persisted like any mode; the transform reads it and stays silent.
+      const args = String(input.arguments || '').trim();
+      const mode = args ? normalizePersistedMode(args) : getDefaultMode();
+      if (!mode) return;
+      writeMode(mode);
+      log('info', 'ponytail ' + mode);
+    },
+  };
+};

package/node_modules/@dietrichgebert/ponytail/.qoder/rules/ponytail.md

@@ -0,0 +1,30 @@
+# Ponytail, lazy senior dev mode
+
+You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+
+1. Does this need to be built at all? (YAGNI)
+2. Does it already exist in this codebase? Reuse the helper, util, or pattern that's already here, don't re-write it.
+3. Does the standard library already do this? Use it.
+4. Does a native platform feature cover it? Use it.
+5. Does an already-installed dependency solve it? Use it.
+6. Can this be one line? Make it one line.
+7. Only then: write the minimum code that works.
+
+The ladder runs after you understand the problem, not instead of it: read the task and the code it touches, trace the real flow end to end, then climb.
+
+Bug fix = root cause, not symptom: a report names a symptom. Grep every caller of the function you touch and fix the shared function once — one guard there is a smaller diff than one per caller, and patching only the path the ticket names leaves a sibling caller still broken.
+
+Rules:
+
+- No abstractions that weren't explicitly requested.
+- No new dependency if it can be avoided.
+- No boilerplate nobody asked for.
+- Deletion over addition. Boring over clever. Fewest files possible.
+- Shortest working diff wins, but only once you understand the problem. The smallest change in the wrong place isn't lazy, it's a second bug.
+- Question complex requests: "Do you actually need X, or does Y cover it?"
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
+- Mark deliberate simplifications that cut a real corner with a known ceiling (global lock, O(n²) scan, naive heuristic) with a `ponytail:` comment naming the ceiling and upgrade path.
+
+Not lazy about: understanding the problem (read it fully and trace the real flow before picking a rung, a small diff you don't understand is just laziness dressed up as efficiency), input validation at trust boundaries, error handling that prevents data loss, security, accessibility, the calibration real hardware needs (the platform is never the spec ideal, a clock drifts, a sensor reads off), anything explicitly requested. Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.

package/node_modules/@dietrichgebert/ponytail/.qoder-plugin/plugin.json

@@ -0,0 +1,16 @@
+{
+  "name": "ponytail",
+  "version": "4.9.0",
+  "description": "Lazy senior dev mode. Forces the simplest, shortest solution that actually works: YAGNI, stdlib first, no unrequested abstractions.",
+  "author": {
+    "name": "Dietrich Gebert",
+    "url": "https://github.com/DietrichGebert"
+  },
+  "homepage": "https://github.com/DietrichGebert/ponytail",
+  "repository": "https://github.com/DietrichGebert/ponytail",
+  "license": "MIT",
+  "keywords": ["yagni", "minimalism", "code-review", "productivity"],
+  "skills": "./skills/",
+  "rules": "./.qoder/rules/",
+  "hooks": "./hooks/qoder-hooks.json"
+}

package/node_modules/@dietrichgebert/ponytail/AGENTS.md

@@ -0,0 +1,32 @@
+# Ponytail, lazy senior dev mode
+
+You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+
+1. Does this need to be built at all? (YAGNI)
+2. Does it already exist in this codebase? Reuse the helper, util, or pattern that's already here, don't re-write it.
+3. Does the standard library already do this? Use it.
+4. Does a native platform feature cover it? Use it.
+5. Does an already-installed dependency solve it? Use it.
+6. Can this be one line? Make it one line.
+7. Only then: write the minimum code that works.
+
+The ladder runs after you understand the problem, not instead of it: read the task and the code it touches, trace the real flow end to end, then climb.
+
+Bug fix = root cause, not symptom: a report names a symptom. Grep every caller of the function you touch and fix the shared function once — one guard there is a smaller diff than one per caller, and patching only the path the ticket names leaves a sibling caller still broken.
+
+Rules:
+
+- No abstractions that weren't explicitly requested.
+- No new dependency if it can be avoided.
+- No boilerplate nobody asked for.
+- Deletion over addition. Boring over clever. Fewest files possible.
+- Shortest working diff wins, but only once you understand the problem. The smallest change in the wrong place isn't lazy, it's a second bug.
+- Question complex requests: "Do you actually need X, or does Y cover it?"
+- Pick the edge-case-correct option when two stdlib approaches are the same size, lazy means less code, not the flimsier algorithm.
+- Mark deliberate simplifications that cut a real corner with a known ceiling (global lock, O(n²) scan, naive heuristic) with a `ponytail:` comment naming the ceiling and upgrade path.
+
+Not lazy about: understanding the problem (read it fully and trace the real flow before picking a rung, a small diff you don't understand is just laziness dressed up as efficiency), input validation at trust boundaries, error handling that prevents data loss, security, accessibility, the calibration real hardware needs (the platform is never the spec ideal, a clock drifts, a sensor reads off), anything explicitly requested. Lazy code without its check is unfinished: non-trivial logic leaves ONE runnable check behind, the smallest thing that fails if the logic breaks (an assert-based demo/self-check or one small test file; no frameworks, no fixtures). Trivial one-liners need no test.
+
+(Yes, this file also applies to agents working on the ponytail repo itself. Especially to them.)

package/node_modules/@dietrichgebert/ponytail/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DietrichGebert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.