@czottmann/pi-automode 1.7.0 → 1.8.1

package/extensions/auto-mode/log.ts

@@ -2,6 +2,7 @@ import { randomBytes } from "node:crypto";
 import { appendFileSync, mkdirSync } from "node:fs";
 import { basename, dirname, extname, join } from "node:path";
 import type {
+  ClassifierIo,
   ClassifierIoAttempt,
   ClassificationDecision,
   DecisionKind,
@@ -28,13 +29,27 @@ export type ClassifierLogEntry = {
   ts: string;
   decisionId: string;
   model: string;
-  prompt: { system: string; user: string };
+  prompt: ClassifierIo["prompt"];
   attempts: ClassifierIoAttempt[];
   durationMs: number;
   parsed: ClassificationDecision;
 };
 
-export type LogEntry = DecisionLogEntry | ClassifierLogEntry;
+/** A ccusage-compatible record for one classifier model response. */
+export type ClassifierUsageLogEntry = {
+  type: "message";
+  timestamp: string;
+  message: {
+    role: "assistant";
+    model: string;
+    usage: NonNullable<ClassifierIoAttempt["response"]>["usage"];
+  };
+};
+
+export type LogEntry =
+  | DecisionLogEntry
+  | ClassifierLogEntry
+  | ClassifierUsageLogEntry;
 
 export type Logger = {
   enabled: boolean;

package/extensions/auto-mode/paths.ts

@@ -1,9 +1,8 @@
-import { realpathSync } from "node:fs";
+import { lstatSync, readlinkSync, realpathSync } from "node:fs";
 import {
   basename,
   dirname,
   isAbsolute,
-  join,
   normalize,
   relative,
   resolve,
@@ -34,53 +33,85 @@ export function isInside(child: string, parent: string): boolean {
   return rel === "" || (!!rel && !rel.startsWith("..") && !isAbsolute(rel));
 }
 
-export function isProtectedPath(
+/** Resolve symlinks through the nearest existing ancestor of a path. */
+export function resolvePathForPolicy(path: string): string | undefined {
+  return resolvePathForPolicyInner(resolve(path), new Set<string>());
+}
+
+function resolvePathForPolicyInner(
   path: string,
-  cwd: string,
-  protectedPaths: string[],
-): boolean {
-  // Resolve symlinks so writes through symlinks (e.g. not-git -> .git) are caught.
-  let resolved = path;
-  try {
-    resolved = realpathSync(path);
-  } catch {
-    // File doesn't exist yet — try resolving the parent directory.
+  visitedSymlinks: Set<string>,
+): string | undefined {
+  let current = path;
+  const missingSegments: string[] = [];
+
+  while (true) {
     try {
-      const dir = dirname(path);
-      const base = basename(path);
-      resolved = join(realpathSync(dir), base);
+      return resolve(realpathSync(current), ...missingSegments);
     } catch {
-      // Parent doesn't exist either — fall through with raw path.
+      try {
+        const stat = lstatSync(current);
+        if (!stat.isSymbolicLink() || visitedSymlinks.has(current)) {
+          return undefined;
+        }
+        visitedSymlinks.add(current);
+        const target = resolve(dirname(current), readlinkSync(current));
+        return resolvePathForPolicyInner(
+          resolve(target, ...missingSegments),
+          visitedSymlinks,
+        );
+      } catch (error) {
+        const code = error && typeof error === "object" && "code" in error
+          ? String(error.code)
+          : undefined;
+        if (code !== "ENOENT" && code !== "ENOTDIR") return undefined;
+        const parent = dirname(current);
+        if (parent === current) return undefined;
+        missingSegments.unshift(basename(current));
+        current = parent;
+      }
     }
   }
+}
+
+export function matchesProtectedPath(
+  relativePath: string,
+  protectedPaths: string[],
+): boolean {
+  const normalizedPath = relativePath.replace(/\\/g, "/");
+  return protectedPaths.some((pattern) => {
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    return normalizedPath === normalizedPattern ||
+      normalizedPath.startsWith(`${normalizedPattern}/`);
+  });
+}
+
+export function isProtectedPath(
+  path: string,
+  cwd: string,
+  protectedPaths: string[],
+): boolean {
+  // Resolve through the nearest existing ancestor so symlinked directories are
+  // respected even when the final write target does not exist yet.
+  const resolved = resolvePathForPolicy(path) ?? path;
+  const resolvedCwd = resolvePathForPolicy(cwd) ?? cwd;
 
   // For paths inside the project: use relative path for matching.
-  if (resolved.startsWith(cwd)) {
-    const relativePath = relative(cwd, resolved);
-    for (const pattern of protectedPaths) {
-      if (
-        relativePath === pattern ||
-        relativePath.startsWith(`${pattern}/`)
-      ) {
-        return true;
-      }
-    }
-    return false;
+  if (isInside(resolved, resolvedCwd)) {
+    return matchesProtectedPath(
+      relative(resolvedCwd, resolved),
+      protectedPaths,
+    );
   }
 
   // For paths outside the project: check every path component suffix.
   // This catches writes like ../other-project/.git/config even when cwd
   // doesn't contain the target.
-  const segments = resolved.split("/").filter(Boolean);
+  const normalizedResolved = resolved.replace(/\\/g, "/");
+  const segments = normalizedResolved.split("/").filter(Boolean);
   for (let i = 0; i < segments.length; i++) {
-    const suffix = segments.slice(i).join("/");
-    for (const pattern of protectedPaths) {
-      if (
-        suffix === pattern ||
-        suffix.startsWith(`${pattern}/`)
-      ) {
-        return true;
-      }
+    if (matchesProtectedPath(segments.slice(i).join("/"), protectedPaths)) {
+      return true;
     }
   }
   return false;

package/extensions/auto-mode/transcript.ts

@@ -1,6 +1,23 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { safeJson, truncateMiddle } from "./utils.ts";
 
+const MAX_USER_ENTRY_TOKENS = 1000;
+const MAX_TOOL_ENTRY_TOKENS = 1000;
+const MAX_RECENT_TOOL_ENTRIES = 40;
+const CHARS_PER_APPROX_TOKEN = 4;
+
+type TranscriptEntry = {
+  index: number;
+  order: number;
+  kind: "user" | "tool";
+  text: string;
+};
+
+export type ClassifierTranscriptBudgets = {
+  maxUserTokens: number;
+  maxToolTokens: number;
+};
+
 function flattenUserContent(content: unknown): string {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -14,19 +31,10 @@ function flattenUserContent(content: unknown): string {
     .join("\n");
 }
 
-function flattenAssistantText(content: unknown): string {
-  if (!Array.isArray(content)) return "";
-  return content
-    .filter(
-      (block): block is { type: string; text?: string } =>
-        !!block && typeof block === "object" && "type" in block,
-    )
-    .filter((block) => block.type === "text" && typeof block.text === "string")
-    .map((block) => block.text ?? "")
-    .join("\n");
-}
-
-function collectAssistantToolCalls(content: unknown): string[] {
+function collectAssistantToolCalls(content: unknown): Array<{
+  name: string;
+  input: unknown;
+}> {
   if (!Array.isArray(content)) return [];
   return content
     .filter(
@@ -40,34 +48,174 @@ function collectAssistantToolCalls(content: unknown): string[] {
       } => !!block && typeof block === "object" && "type" in block,
     )
     .filter((block) => block.type === "toolCall" || block.type === "tool_use")
-    .map(
-      (block) =>
-        `${String(block.name ?? "tool")} ${
-          safeJson("arguments" in block ? block.arguments : block.input, 1200)
-        }`,
-    );
+    .map((block) => ({
+      name: String(block.name ?? "tool"),
+      input: "arguments" in block ? block.arguments : block.input,
+    }));
 }
 
-export function buildTranscript(
-  ctx: ExtensionContext,
-  maxLines: number,
-): string {
-  const lines: string[] = [];
-  for (const entry of ctx.sessionManager.getBranch()) {
+export function approximateTokenCount(text: string): number {
+  return Math.ceil(text.length / CHARS_PER_APPROX_TOKEN);
+}
+
+function truncateToTokenCap(
+  text: string,
+  maxTokens: number,
+): { text: string; truncated: boolean } {
+  if (approximateTokenCount(text) <= maxTokens) {
+    return { text, truncated: false };
+  }
+  const maxCharacters = Math.max(1, maxTokens * CHARS_PER_APPROX_TOKEN);
+  const omittedTokens = Math.max(
+    1,
+    approximateTokenCount(text) - maxTokens,
+  );
+  const marker = `<truncated approx_tokens="${omittedTokens}" />`;
+  if (marker.length >= maxCharacters) {
+    return { text: marker.slice(0, maxCharacters), truncated: true };
+  }
+
+  const retainedCharacters = maxCharacters - marker.length;
+  const prefixCharacters = Math.ceil(retainedCharacters * 0.65);
+  const suffixCharacters = retainedCharacters - prefixCharacters;
+  return {
+    text: `${text.slice(0, prefixCharacters)}${marker}${
+      suffixCharacters > 0 ? text.slice(-suffixCharacters) : ""
+    }`,
+    truncated: true,
+  };
+}
+
+function collectTranscriptEntries(ctx: ExtensionContext): TranscriptEntry[] {
+  const entries: TranscriptEntry[] = [];
+  const sessionManager = ctx.sessionManager as typeof ctx.sessionManager & {
+    buildContextEntries?: () => ReturnType<typeof ctx.sessionManager.getBranch>;
+  };
+  const contextEntries = sessionManager.buildContextEntries?.() ??
+    sessionManager.getBranch();
+
+  for (const [index, entry] of contextEntries.entries()) {
     if (entry.type !== "message") continue;
     const message = entry.message as { role?: string; content?: unknown };
     if (message.role === "user") {
       const text = flattenUserContent(message.content).trim();
-      if (text) lines.push(`User: ${truncateMiddle(text, 2000)}`);
-    } else if (message.role === "assistant") {
-      const text = flattenAssistantText(message.content).trim();
-      if (text) lines.push(`Assistant: ${truncateMiddle(text, 2000)}`);
-      for (const toolCall of collectAssistantToolCalls(message.content)) {
-        lines.push(`AssistantAction: ${toolCall}`);
-      }
+      if (text) entries.push({ index, order: 0, kind: "user", text });
+      continue;
     }
+    if (message.role !== "assistant") continue;
+
+    for (const [order, toolCall] of collectAssistantToolCalls(
+      message.content,
+    ).entries()) {
+      entries.push({
+        index,
+        order,
+        kind: "tool",
+        text: `${toolCall.name}: ${safeJson(toolCall.input, 8000)}`,
+      });
+    }
+  }
+
+  return entries;
+}
+
+function selectUserEntries(
+  entries: TranscriptEntry[],
+  maxTokens: number,
+): { selected: TranscriptEntry[]; omitted: boolean } {
+  const users = entries.filter((entry) => entry.kind === "user");
+  if (users.length === 0) return { selected: [], omitted: false };
+
+  const distinctAnchors = users.length > 1;
+  const anchorBudget = distinctAnchors
+    ? Math.max(1, Math.floor(maxTokens / 2))
+    : maxTokens;
+  const entryCap = Math.min(MAX_USER_ENTRY_TOKENS, anchorBudget);
+  const rendered = users.map((entry) => {
+    const truncated = truncateToTokenCap(`User: ${entry.text}`, entryCap);
+    return { ...entry, text: truncated.text, truncated: truncated.truncated };
+  });
+  const selectedIndices = new Set<number>();
+  let usedTokens = 0;
+
+  const include = (index: number): void => {
+    if (selectedIndices.has(index)) return;
+    const entry = rendered[index];
+    if (!entry) return;
+    const tokens = approximateTokenCount(entry.text);
+    if (usedTokens + tokens > maxTokens) return;
+    selectedIndices.add(index);
+    usedTokens += tokens;
+  };
+
+  // Prefer the latest user instruction when an extremely small configured
+  // budget cannot retain both intent anchors.
+  include(rendered.length - 1);
+  include(0);
+  for (let index = rendered.length - 2; index > 0; index -= 1) {
+    include(index);
+  }
+
+  return {
+    selected: rendered.filter((_entry, index) => selectedIndices.has(index)),
+    omitted: selectedIndices.size < users.length || rendered.some((entry) =>
+      entry.truncated
+    ),
+  };
+}
+
+function selectToolEntries(
+  entries: TranscriptEntry[],
+  maxTokens: number,
+): { selected: TranscriptEntry[]; omitted: boolean } {
+  const tools = entries.filter((entry) => entry.kind === "tool");
+  const selected: TranscriptEntry[] = [];
+  let usedTokens = 0;
+
+  for (let index = tools.length - 1; index >= 0; index -= 1) {
+    if (selected.length >= MAX_RECENT_TOOL_ENTRIES) break;
+    const entry = tools[index];
+    if (!entry) continue;
+    const truncated = truncateToTokenCap(
+      `ToolCall ${entry.text}`,
+      Math.min(MAX_TOOL_ENTRY_TOKENS, maxTokens),
+    );
+    const tokens = approximateTokenCount(truncated.text);
+    if (usedTokens + tokens > maxTokens) continue;
+    selected.push({ ...entry, text: truncated.text });
+    usedTokens += tokens;
+  }
+
+  selected.reverse();
+  return {
+    selected,
+    omitted: selected.length < tools.length || tools.some((entry) =>
+      approximateTokenCount(`ToolCall ${entry.text}`) >
+        Math.min(MAX_TOOL_ENTRY_TOKENS, maxTokens)
+    ),
+  };
+}
+
+/** Build classifier evidence from user text and assistant tool-call payloads only. */
+export function buildClassifierTranscript(
+  ctx: ExtensionContext,
+  budgets: ClassifierTranscriptBudgets,
+): string {
+  const entries = collectTranscriptEntries(ctx);
+  const users = selectUserEntries(entries, budgets.maxUserTokens);
+  const tools = selectToolEntries(entries, budgets.maxToolTokens);
+  const selected = [...users.selected, ...tools.selected].sort(
+    (left, right) => left.index - right.index || left.order - right.order,
+  );
+  if (users.omitted || tools.omitted) {
+    selected.push({
+      index: Number.MAX_SAFE_INTEGER,
+      order: 0,
+      kind: "tool",
+      text: "<transcript_entries_omitted />",
+    });
   }
-  return lines.slice(-maxLines).join("\n");
+  return selected.map((entry) => entry.text).join("\n");
 }
 
 export function loadedContextFromSystemPromptOptions(options: unknown): string {

package/extensions/auto-mode/types.ts

@@ -1,3 +1,4 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 /** Observability log configuration. Off by default. */
@@ -10,7 +11,8 @@ export type LogConfig = {
 export type AutoModeSettings = {
   enabled?: boolean;
   classifierModel?: string;
-  maxTranscriptLines?: number;
+  maxUserTranscriptTokens?: number;
+  maxToolTranscriptTokens?: number;
   environment?: unknown;
   allow?: unknown;
   protectedPaths?: unknown;
@@ -44,7 +46,8 @@ export type ToolPattern = {
 export type EffectiveConfig = {
   enabled: boolean;
   classifierModel?: string;
-  maxTranscriptLines: number;
+  maxUserTranscriptTokens: number;
+  maxToolTranscriptTokens: number;
   environment: string[];
   allow: string[];
   protectedPaths: string[];
@@ -90,8 +93,16 @@ export type ClassificationDecision = {
 
 /** One classifier attempt: the raw model response (or error) and parsed decision. */
 export type ClassifierIoAttempt = {
+  stage: "fast" | "detailed";
   attempt: number;
-  response?: { stopReason?: string; text: string };
+  response?: {
+    stopReason?: string;
+    text: string;
+    model: string;
+    timestamp: number;
+    usage: AssistantMessage["usage"];
+    errorMessage?: string;
+  };
   parsed?: ClassificationDecision;
   error?: string;
   durationMs: number;
@@ -100,7 +111,12 @@ export type ClassifierIoAttempt = {
 /** Full classifier I/O for an action, surfaced for optional observability logging. */
 export type ClassifierIo = {
   model: string;
-  prompt: { system: string; user: string };
+  prompt: {
+    system: string;
+    context: string;
+    fastInstruction: string;
+    detailedInstruction: string;
+  };
   attempts: ClassifierIoAttempt[];
   durationMs: number;
 };

package/extensions/auto-mode.ts

@@ -3,7 +3,7 @@
  *
  * The enforcement order is deliberately different from simple "auto reviewer" plugins:
  * permission deny/ask rules and deterministic hard-deny checks run before any fast-path allow.
- * Only then do read-only tools pass, and all remaining tools go through the classifier.
+ * Only read-only built-in tools bypass classification; every side-effecting action goes through the classifier.
  */
 
 export * from "./auto-mode/classifier.ts";

package/package.json

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