@czottmann/pi-automode 1.1.0 → 1.2.0

package/extensions/auto-mode/state.ts

@@ -0,0 +1,103 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { DENIAL_HISTORY_LIMIT } from "./constants.ts";
+import type { AutoModeState, DenialRecord, EffectiveConfig } from "./types.ts";
+import { safeJson, truncateMiddle } from "./utils.ts";
+
+export function pushDenial(state: AutoModeState, denial: DenialRecord): void {
+  state.recentDenials = [
+    ...state.recentDenials.slice(-(DENIAL_HISTORY_LIMIT - 1)),
+    denial,
+  ];
+}
+
+export function statusLine(
+  config: EffectiveConfig,
+  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;
+}
+
+export function statusText(
+  config: EffectiveConfig,
+  state: AutoModeState,
+): string {
+  return [
+    `enabled: ${(state.enabledOverride ?? config.enabled) ? "yes" : "no"}`,
+    `classifier: ${
+      state.classifierModelOverride ?? config.classifierModel ??
+        "current session model"
+    }`,
+    `checked actions: ${state.checkedActions}`,
+    `blocked actions: ${state.blockedActions}`,
+    `permissions.deny rules: ${config.permissionDeny.length}`,
+    `permissions.ask rules: ${config.permissionAsk.length}`,
+    `environment entries: ${config.environment.length}`,
+    `allow entries: ${config.allow.length}`,
+    `soft_deny entries: ${config.softDeny.length}`,
+    `hard_deny entries: ${config.hardDeny.length}`,
+    `last decision: ${state.lastDecision ?? "none"}`,
+    `last reason: ${state.lastReason ?? "none"}`,
+  ].join("\n");
+}
+
+export function formatDenials(state: AutoModeState): string {
+  if (state.recentDenials.length === 0) return "No recent auto-mode denials.";
+  return state.recentDenials
+    .slice()
+    .reverse()
+    .map(
+      (denial) =>
+        `${
+          new Date(denial.timestamp).toLocaleTimeString()
+        } ${denial.kind} ${denial.toolName}: ${denial.reason}\n  ${
+          truncateMiddle(denial.action, 300)
+        }`,
+    )
+    .join("\n\n");
+}
+
+export function actionSummary(
+  toolName: string,
+  input: Record<string, unknown>,
+): string {
+  return `${toolName} ${safeJson(input, 6000)}`;
+}
+
+export function restoreState(ctx: ExtensionContext): AutoModeState {
+  const entries = ctx.sessionManager.getEntries();
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i] as {
+      type?: string;
+      customType?: string;
+      data?: Partial<AutoModeState>;
+    };
+    if (
+      entry.type !== "custom" ||
+      entry.customType !== "pi-automode-state" ||
+      !entry.data
+    ) {
+      continue;
+    }
+    return {
+      enabledOverride: entry.data.enabledOverride,
+      classifierModelOverride: entry.data.classifierModelOverride,
+      lastDecision: entry.data.lastDecision,
+      lastReason: entry.data.lastReason,
+      checkedActions: entry.data.checkedActions ?? 0,
+      blockedActions: entry.data.blockedActions ?? 0,
+      recentDenials: Array.isArray(entry.data.recentDenials)
+        ? entry.data.recentDenials.slice(-DENIAL_HISTORY_LIMIT)
+        : [],
+    };
+  }
+  return { checkedActions: 0, blockedActions: 0, recentDenials: [] };
+}

package/extensions/auto-mode/transcript.ts

@@ -0,0 +1,88 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { safeJson, truncateMiddle } from "./utils.ts";
+
+function flattenUserContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  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 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[] {
+  if (!Array.isArray(content)) return [];
+  return content
+    .filter(
+      (
+        block,
+      ): block is {
+        type: string;
+        name?: string;
+        arguments?: unknown;
+        input?: unknown;
+      } => !!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)
+        }`,
+    );
+}
+
+export function buildTranscript(
+  ctx: ExtensionContext,
+  maxLines: number,
+): string {
+  const lines: string[] = [];
+  for (const entry of ctx.sessionManager.getBranch()) {
+    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}`);
+      }
+    }
+  }
+  return lines.slice(-maxLines).join("\n");
+}
+
+export function loadedContextFromSystemPromptOptions(options: unknown): string {
+  const contextFiles = (
+    options as
+      | { contextFiles?: Array<{ path?: string; content?: string }> }
+      | undefined
+  )?.contextFiles;
+  if (!Array.isArray(contextFiles)) return "";
+  return contextFiles
+    .map(
+      (file) =>
+        `# ${file.path ?? "context"}\n${
+          truncateMiddle(file.content ?? "", 4000)
+        }`,
+    )
+    .join("\n\n");
+}

package/extensions/auto-mode/types.ts

@@ -0,0 +1,95 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+export type AutoModeSettings = {
+  enabled?: boolean;
+  classifierModel?: string;
+  maxTranscriptLines?: number;
+  environment?: unknown;
+  allow?: unknown;
+  protectedPaths?: unknown;
+  soft_deny?: unknown;
+  softDeny?: unknown;
+  hard_deny?: unknown;
+  hardDeny?: unknown;
+};
+
+export type SettingsFile = {
+  autoMode?: AutoModeSettings;
+  permissions?: {
+    deny?: unknown;
+    ask?: unknown;
+  };
+};
+
+export type LoadedSettingsFile = {
+  path: string;
+  settings?: SettingsFile;
+  diagnostics: string[];
+};
+
+export type ToolPattern = {
+  raw: string;
+  toolName?: string;
+  argumentPattern?: string;
+};
+
+export type EffectiveConfig = {
+  enabled: boolean;
+  classifierModel?: string;
+  maxTranscriptLines: number;
+  environment: string[];
+  allow: string[];
+  protectedPaths: string[];
+  softDeny: string[];
+  hardDeny: string[];
+  permissionDeny: ToolPattern[];
+  permissionAsk: ToolPattern[];
+};
+
+export type AutoModeState = {
+  enabledOverride?: boolean;
+  classifierModelOverride?: string;
+  lastDecision?: "allow" | "block";
+  lastReason?: string;
+  checkedActions: number;
+  blockedActions: number;
+  recentDenials: DenialRecord[];
+};
+
+export type DenialRecord = {
+  timestamp: number;
+  toolName: string;
+  reason: string;
+  action: string;
+  kind:
+    | "permissions.deny"
+    | "permissions.ask"
+    | "deterministic-hard-deny"
+    | "classifier"
+    | "setup";
+};
+
+export type ClassificationDecision = {
+  decision: "allow" | "block";
+  tier: "hard_deny" | "soft_deny" | "allow" | "explicit_intent" | "none";
+  reason: string;
+};
+
+export type SettingsSources = {
+  globalSettings?: SettingsFile[];
+  projectLocalSettings?: SettingsFile[];
+  projectSharedSettings?: SettingsFile[];
+  inlineSettings?: SettingsFile[];
+};
+
+export type ConfigLoadResult = {
+  config: EffectiveConfig;
+  diagnostics: string[];
+};
+
+export type ClassifyAction = (
+  ctx: ExtensionContext,
+  config: EffectiveConfig,
+  action: string,
+  loadedContext: string,
+) => Promise<ClassificationDecision>;

package/extensions/auto-mode/utils.ts

@@ -0,0 +1,46 @@
+export function stringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  return value.filter(
+    (entry): entry is string =>
+      typeof entry === "string" && entry.trim().length > 0,
+  );
+}
+
+export function hasOwn(object: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+
+export function truncateMiddle(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  const head = Math.floor(maxLength * 0.65);
+  const tail = maxLength - head - 18;
+  return `${text.slice(0, head)}… […] …${text.slice(text.length - tail)}`;
+}
+
+export function safeJson(value: unknown, maxLength = 4000): string {
+  const seen = new WeakSet<object>();
+  let text = "{}";
+  try {
+    text = JSON.stringify(
+      value,
+      (_key, current) => {
+        if (typeof current === "string") {
+          return truncateMiddle(
+            current,
+            Math.max(200, Math.floor(maxLength / 4)),
+          );
+        }
+        if (Array.isArray(current)) return current.slice(0, 30);
+        if (current && typeof current === "object") {
+          if (seen.has(current)) return "[Circular]";
+          seen.add(current);
+        }
+        return current;
+      },
+      2,
+    ) ?? "{}";
+  } catch {
+    text = String(value);
+  }
+  return truncateMiddle(text, maxLength);
+}