@czottmann/pi-automode 1.3.0 → 1.5.0

package/README.md

@@ -141,6 +141,12 @@ GitHub Actions publishes the package to npm when a GitHub Release is published.
 
 The workflow uses npm Trusted Publishing, so it does not need an npm token secret. Configure this package on npm with this repository and workflow file (`.github/workflows/publish.yml`). The workflow builds the package, runs `npm run check`, and publishes with npm provenance.
 
+### Release tag must point at the version bump
+
+The publish workflow checks out the commit the release tag points at and compares `package.json` against the tag name. **The tag must point at a commit where `package.json` already carries the new version.** Concretely: commit the version bump (`chore: release X.Y.Z`), push `main`, then create the GitHub release targeting that pushed commit. Creating the release before pushing the version bump — or targeting a commit that still has the old version — fails the `Check release tag` step with `Release tag (vX.Y.Z) does not match package.json version (x.y.z)`.
+
+If the tag was cut against the wrong commit, fix it by force-moving it to the version-bump commit and pushing, then trigger the workflow via `gh workflow run publish.yml --ref vX.Y.Z` (the `release` event fires on tag creation; re-running a failed `release`-triggered run reuses the original ref and won't pick up the moved tag).
+
 ## Author
 
 Carlo Zottmann, <carlo@zottmann.dev>

package/extensions/auto-mode/classifier.ts

@@ -55,6 +55,24 @@ async function resolveClassifier(
   return { model, apiKey: auth.apiKey, headers: auth.headers };
 }
 
+export type ClassifierCompletionFn = (
+  model: Model<any>,
+  options: { systemPrompt: string; messages: UserMessage[] },
+  callOptions: {
+    apiKey?: string;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    maxTokens: number;
+    temperature: number;
+  },
+) => Promise<AssistantMessage>;
+
+export type RetryOptions = {
+  maxAttempts?: number;
+  maxTokens?: number;
+  temperature?: number;
+};
+
 /** Parse the classifier's JSON-only response. Invalid output is handled fail-closed by the caller. */
 export function parseClassifierDecision(
   message: AssistantMessage,
@@ -90,6 +108,66 @@ export function parseClassifierDecision(
   return undefined;
 }
 
+/**
+ * Call the classifier model and parse its decision, retrying when the model
+ * returns malformed or truncated output. Small classifier models occasionally
+ * ramble into the token cap (stopReason "length") or emit prose instead of
+ * JSON; a single retry recovers most of these transient failures.
+ *
+ * Safety is preserved: an "allow" is only returned when a response actually
+ * parses to a valid allow decision. If every attempt fails to parse, the
+ * function fails closed with a block decision. Thrown errors (network/auth)
+ * are not retried — they fail closed immediately, matching prior behavior.
+ */
+export async function classifyWithRetry(
+  completeFn: ClassifierCompletionFn,
+  classifier: {
+    model: Model<any>;
+    apiKey?: string;
+    headers?: Record<string, string>;
+  },
+  prompt: { systemPrompt: string; messages: UserMessage[] },
+  signal: AbortSignal | undefined,
+  options: RetryOptions = {},
+): Promise<ClassificationDecision> {
+  const maxAttempts = options.maxAttempts ?? 2;
+  const maxTokens = options.maxTokens ?? 1200;
+  const temperature = options.temperature ?? 0;
+  let lastReason =
+    "Classifier response was not valid decision JSON; auto mode fails closed.";
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    let response: AssistantMessage;
+    try {
+      response = await completeFn(
+        classifier.model,
+        prompt,
+        {
+          apiKey: classifier.apiKey,
+          headers: classifier.headers,
+          signal,
+          maxTokens,
+          temperature,
+        },
+      );
+    } catch (error) {
+      return {
+        decision: "block",
+        tier: "none",
+        reason: `Classifier failed; auto mode fails closed: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      };
+    }
+    const decision = parseClassifierDecision(response);
+    if (decision) return decision;
+    lastReason =
+      response.stopReason === "length"
+        ? "Classifier response was truncated before producing valid decision JSON; auto mode fails closed."
+        : "Classifier response was not valid decision JSON; auto mode fails closed.";
+  }
+  return { decision: "block", tier: "none", reason: lastReason };
+}
+
 export const defaultClassifyAction: ClassifyAction = async (
   ctx,
   config,
@@ -120,33 +198,10 @@ export const defaultClassifyAction: ClassifyAction = async (
     timestamp: Date.now(),
   };
 
-  try {
-    const response = await complete(
-      classifier.model,
-      { systemPrompt: buildClassifierPrompt(config), messages: [userMessage] },
-      {
-        apiKey: classifier.apiKey,
-        headers: classifier.headers,
-        signal: ctx.signal,
-        maxTokens: 700,
-        temperature: 0,
-      },
-    );
-    return (
-      parseClassifierDecision(response) ?? {
-        decision: "block",
-        tier: "none",
-        reason:
-          "Classifier response was not valid decision JSON; auto mode fails closed.",
-      }
-    );
-  } catch (error) {
-    return {
-      decision: "block",
-      tier: "none",
-      reason: `Classifier failed; auto mode fails closed: ${
-        error instanceof Error ? error.message : String(error)
-      }`,
-    };
-  }
+  return classifyWithRetry(
+    complete,
+    classifier,
+    { systemPrompt: buildClassifierPrompt(config), messages: [userMessage] },
+    ctx.signal,
+  );
 };

package/extensions/auto-mode/extension.ts

@@ -69,6 +69,7 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
     let state: AutoModeState = {
       checkedActions: 0,
       blockedActions: 0,
+      classifierChecks: 0,
       recentDenials: [],
     };
     let loadedContext = "";
@@ -215,6 +216,7 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
       if (event.toolName === "write" || event.toolName === "edit") {
         const path = resolveInputPath(ctx.cwd, input.path);
         if (path && isProtectedPath(path, ctx.cwd, cfg.protectedPaths)) {
+          state.classifierChecks += 1;
           const decision = await classify(ctx, cfg, summary, loadedContext);
           if (decision.decision === "allow") {
             state.lastDecision = "allow";
@@ -233,6 +235,7 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
         }
       }
 
+      state.classifierChecks += 1;
       const decision = await classify(ctx, cfg, summary, loadedContext);
       if (decision.decision === "allow") {
         state.lastDecision = "allow";
@@ -295,6 +298,7 @@ export function createPiAutomode(options: PiAutomodeOptions = {}) {
         state = {
           checkedActions: 0,
           blockedActions: 0,
+          classifierChecks: 0,
           recentDenials: [],
           enabledOverride: state.enabledOverride,
         };

package/extensions/auto-mode/state.ts

@@ -15,15 +15,12 @@ export function statusLine(
   state: AutoModeState,
 ): string {
   const enabled = state.enabledOverride ?? config.enabled;
-  if (!enabled) return "Auto-mode off";
-  let line = `Auto-mode on • checked: ${state.checkedActions}`;
-  if (state.blockedActions > 0) {
-    line =
-      `Auto-mode on · blocked: ${state.blockedActions}/${state.checkedActions}`;
-    const last = state.recentDenials.at(-1);
-    if (last) line += ` · last: ${truncateMiddle(last.reason, 60)}`;
-  }
-  return line;
+  const circle = enabled ? "●" : "○";
+  const allowed = state.checkedActions - state.blockedActions;
+  const classifier = state.classifierChecks > 0
+    ? ` c:${state.classifierChecks}`
+    : "";
+  return `AM${circle} a:${allowed} d:${state.blockedActions}${classifier}`;
 }
 
 export function statusText(
@@ -35,6 +32,7 @@ export function statusText(
     `classifier: ${config.classifierModel ?? "current session model"}`,
     `checked actions: ${state.checkedActions}`,
     `blocked actions: ${state.blockedActions}`,
+    `classifier checks: ${state.classifierChecks}`,
     `permissions.deny rules: ${config.permissionDeny.length}`,
     `permissions.ask rules: ${config.permissionAsk.length}`,
     `environment entries: ${config.environment.length}`,
@@ -90,10 +88,11 @@ export function restoreState(ctx: ExtensionContext): AutoModeState {
       lastReason: entry.data.lastReason,
       checkedActions: entry.data.checkedActions ?? 0,
       blockedActions: entry.data.blockedActions ?? 0,
+      classifierChecks: entry.data.classifierChecks ?? 0,
       recentDenials: Array.isArray(entry.data.recentDenials)
         ? entry.data.recentDenials.slice(-DENIAL_HISTORY_LIMIT)
         : [],
     };
   }
-  return { checkedActions: 0, blockedActions: 0, recentDenials: [] };
+  return { checkedActions: 0, blockedActions: 0, classifierChecks: 0, recentDenials: [] };
 }

package/extensions/auto-mode/types.ts

@@ -52,6 +52,7 @@ export type AutoModeState = {
   lastReason?: string;
   checkedActions: number;
   blockedActions: number;
+  classifierChecks: number;
   recentDenials: DenialRecord[];
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@czottmann/pi-automode",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Claude Code-style auto mode guardrail for pi.",
   "repository": {
     "url": "https://github.com/czottmann/pi-automode"