@czottmann/pi-automode 1.6.0 → 1.8.0

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,9 +1,18 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+/** Observability log configuration. Off by default. */
+export type LogConfig = {
+  enabled: boolean;
+  /** When true, also log classifier prompt/response payloads. */
+  classifierIo: boolean;
+};
+
 export type AutoModeSettings = {
   enabled?: boolean;
   classifierModel?: string;
-  maxTranscriptLines?: number;
+  maxUserTranscriptTokens?: number;
+  maxToolTranscriptTokens?: number;
   environment?: unknown;
   allow?: unknown;
   protectedPaths?: unknown;
@@ -11,6 +20,7 @@ export type AutoModeSettings = {
   softDeny?: unknown;
   hard_deny?: unknown;
   hardDeny?: unknown;
+  log?: Partial<LogConfig>;
 };
 
 export type SettingsFile = {
@@ -36,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[];
@@ -44,6 +55,7 @@ export type EffectiveConfig = {
   hardDeny: string[];
   permissionDeny: ToolPattern[];
   permissionAsk: ToolPattern[];
+  log: LogConfig;
 };
 
 export type AutoModeState = {
@@ -70,12 +82,48 @@ export type DenialRecord = {
     | "setup";
 };
 
+/** Denial kind plus the read-only fast path, used for decision log entries. */
+export type DecisionKind = DenialRecord["kind"] | "read-only";
+
 export type ClassificationDecision = {
   decision: "allow" | "block";
   tier: "hard_deny" | "soft_deny" | "allow" | "explicit_intent" | "none";
   reason: string;
 };
 
+/** 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;
+    model: string;
+    timestamp: number;
+    usage: AssistantMessage["usage"];
+    errorMessage?: string;
+  };
+  parsed?: ClassificationDecision;
+  error?: string;
+  durationMs: number;
+};
+
+/** Full classifier I/O for an action, surfaced for optional observability logging. */
+export type ClassifierIo = {
+  model: string;
+  prompt: {
+    system: string;
+    context: string;
+    fastInstruction: string;
+    detailedInstruction: string;
+  };
+  attempts: ClassifierIoAttempt[];
+  durationMs: number;
+};
+
+/** Classification decision plus the I/O that produced it (when available). */
+export type ClassifyResult = ClassificationDecision & { io?: ClassifierIo };
+
 export type SettingsSources = {
   globalSettings?: SettingsFile[];
   projectLocalSettings?: SettingsFile[];
@@ -93,4 +141,4 @@ export type ClassifyAction = (
   config: EffectiveConfig,
   action: string,
   loadedContext: string,
-) => Promise<ClassificationDecision>;
+) => Promise<ClassifyResult>;

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";
@@ -11,6 +11,7 @@ export * from "./auto-mode/config.ts";
 export * from "./auto-mode/constants.ts";
 export * from "./auto-mode/extension.ts";
 export * from "./auto-mode/hard-deny.ts";
+export * from "./auto-mode/log.ts";
 export * from "./auto-mode/model.ts";
 export * from "./auto-mode/model-selector.ts";
 export * from "./auto-mode/paths.ts";

package/package.json

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