surgent 0.7.0-alpha.0

package/src/optimizers/pruner/session.ts

@@ -0,0 +1,34 @@
+import { getLastEntryId, readSessionEntries, writeSessionEntries } from "../entries.js";
+import { removeEntries } from "./cleanup.js";
+import type { PruneEntriesResult } from "./types.js";
+
+function pruneEntries(
+  entries: Record<string, unknown>[],
+  leafId: string | null,
+): PruneEntriesResult {
+  const entryRemoval = removeEntries(entries);
+  let activeLeafId = leafId;
+  while (activeLeafId && entryRemoval.replacementParents.has(activeLeafId)) {
+    activeLeafId = entryRemoval.replacementParents.get(activeLeafId) ?? null;
+  }
+
+  return {
+    activeLeafId,
+    changed: entryRemoval.changed,
+    entries: entryRemoval.entries,
+  };
+}
+
+export function rewritePrunedSessionFile(
+  sessionFile: string,
+  leafId: string | null,
+  fallbackToLastEntry: boolean,
+) {
+  const entries = readSessionEntries(sessionFile);
+  if (!entries) return;
+
+  const effectiveLeafId = leafId ?? (fallbackToLastEntry ? getLastEntryId(entries) : null);
+  const pruned = pruneEntries(entries, effectiveLeafId);
+  if (!pruned.changed) return;
+  writeSessionEntries(sessionFile, pruned.entries);
+}

package/src/optimizers/pruner/types.ts

@@ -0,0 +1,18 @@
+import type { ContextEvent } from "@earendil-works/pi-coding-agent";
+
+export interface ContextPruneResult {
+  changed: boolean;
+  messages: ContextEvent["messages"];
+}
+
+export interface RemovedEntryRemoval {
+  changed: boolean;
+  entries: Record<string, unknown>[];
+  replacementParents: Map<string, string | null>;
+}
+
+export interface PruneEntriesResult {
+  activeLeafId: string | null;
+  changed: boolean;
+  entries: Record<string, unknown>[];
+}

package/src/permission/bash.ts

@@ -0,0 +1,124 @@
+import Parser, { type SyntaxNode } from "tree-sitter";
+import Bash from "tree-sitter-bash";
+import type { BashCommand } from "./types.js";
+
+const parser = new Parser();
+parser.setLanguage(Bash as unknown as Parser.Language);
+
+const DYNAMIC_TYPES = new Set([
+  "ansi_c_string",
+  "arithmetic_expansion",
+  "command_substitution",
+  "expansion",
+  "process_substitution",
+  "simple_expansion",
+]);
+
+function containsDynamic(node: SyntaxNode): boolean {
+  if (DYNAMIC_TYPES.has(node.type)) return true;
+  for (const child of node.namedChildren) {
+    if (containsDynamic(child)) return true;
+  }
+  return false;
+}
+
+function decodeCommandName(value: string): string | null {
+  if (value.startsWith("$'")) return null;
+
+  let result = "";
+  let quote: "single" | "double" | null = null;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index]!;
+    if (quote === "single") {
+      if (char === "'") quote = null;
+      else result += char;
+      continue;
+    }
+    if (quote === "double") {
+      if (char === '"') {
+        quote = null;
+      } else if (char === "\\" && index + 1 < value.length) {
+        const escaped = value[index + 1]!;
+        if ('$`"\\\n'.includes(escaped)) {
+          result += escaped;
+          index += 1;
+        } else {
+          result += char;
+        }
+      } else {
+        result += char;
+      }
+      continue;
+    }
+    if (char === "'") {
+      quote = "single";
+    } else if (char === '"') {
+      quote = "double";
+    } else if (char === "\\" && index + 1 < value.length) {
+      result += value[index + 1]!;
+      index += 1;
+    } else {
+      result += char;
+    }
+  }
+
+  return quote === null ? result : null;
+}
+
+function commandFromNode(node: SyntaxNode): BashCommand {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) {
+    return { text: node.text.trim(), unresolved: true };
+  }
+
+  const args = node.childrenForFieldName("argument").map((argument) => argument.text);
+  return {
+    text: [nameNode.text, ...args].join(" "),
+    unresolved: containsDynamic(nameNode) || decodeCommandName(nameNode.text) === null,
+  };
+}
+
+function patternFromNode(node: SyntaxNode): string {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode) return node.text.trim();
+
+  const commandName = decodeCommandName(nameNode.text) ?? nameNode.text;
+  const args = node.childrenForFieldName("argument");
+  if (!args.length) return commandName;
+
+  if (commandName === "git" && !containsDynamic(args[0]!)) {
+    return `${commandName} ${args[0]!.text} *`;
+  }
+  return `${commandName} *`;
+}
+
+export function extractBashCommands(source: string): BashCommand[] {
+  const trimmed = source.trim();
+  if (!trimmed) return [];
+
+  const tree = parser.parse(trimmed);
+  if (tree.rootNode.hasError) {
+    return [{ text: trimmed, unresolved: true }];
+  }
+
+  const commands = new Map<string, BashCommand>();
+  for (const node of tree.rootNode.descendantsOfType("command")) {
+    const command = commandFromNode(node);
+    const existing = commands.get(command.text);
+    if (!existing || command.unresolved) commands.set(command.text, command);
+  }
+
+  return [...commands.values()];
+}
+
+export function bashToPattern(source: string): string {
+  const trimmed = source.trim();
+  if (!trimmed) return "";
+
+  const tree = parser.parse(trimmed);
+  if (tree.rootNode.hasError) return trimmed;
+
+  const commandNode = tree.rootNode.descendantsOfType("command")[0];
+  return commandNode ? patternFromNode(commandNode) : trimmed;
+}

package/src/permission/command.ts

@@ -0,0 +1,111 @@
+import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey } from "@earendil-works/pi-tui";
+import type { Category, DisplayRule, FileAccess, PermissionRule } from "./types.js";
+import { getRulesForDisplay, addRules, readRules, writeRules } from "./storage.js";
+import PermissionRulesList from "./components/rules-list.js";
+import { Frame } from "../ui/components/frame.js";
+import { FormField } from "../ui/components/form-field.js";
+import {
+  formatRuleOptionLabel,
+  getRulePatternPlaceholder,
+  cycleRuleScope,
+  cycleRuleValue,
+} from "./helpers.js";
+
+async function persistRules(
+  ctx: ExtensionCommandContext,
+  sessionId: string,
+  data: { session: PermissionRule; project: PermissionRule; global: PermissionRule },
+): Promise<void> {
+  const local = await readRules(ctx.cwd);
+  local[sessionId] = data.session;
+  local.project = data.project;
+
+  if (Object.keys(data.session).length > 0 || Object.keys(data.project).length > 0) {
+    await writeRules(local, ctx.cwd);
+  }
+  if (Object.keys(data.global).length > 0) {
+    await writeRules(data.global);
+  }
+}
+
+function notifyError(ctx: ExtensionContext, error: unknown, done?: () => void) {
+  const message = error instanceof Error ? error.message : String(error);
+  ctx.ui.notify(`Failed to save permission rule: ${message}`, "error");
+  done?.();
+}
+
+export async function handlePermissionsCommand(ctx: ExtensionCommandContext) {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("The /permissions command requires an interactive UI.", "error");
+    return;
+  }
+
+  const sessionId = ctx.sessionManager.getSessionId();
+  while (true) {
+    const rules = await getRulesForDisplay(ctx.cwd, sessionId);
+    const action = await ctx.ui.custom<"exit" | "add">((tui, theme, keybindings, done) => {
+      const component = new PermissionRulesList(tui, keybindings, theme, rules);
+      component.onDone = done;
+      component.onSave = async (data) => persistRules(ctx, sessionId, data);
+      component.onSaveErr = (error) => notifyError(ctx, error);
+      return component;
+    });
+    if (action !== "add") break;
+
+    const categoryLabel = await ctx.ui.select("Category", ["File", "Web", "Bash", "MCP"]);
+    if (!categoryLabel) continue;
+
+    const category = categoryLabel.toLowerCase() as Category;
+    const defaultValue: FileAccess | boolean = category === "file" ? "read" : true;
+    const toAdd: DisplayRule = { pattern: "", value: defaultValue, scope: "session", category };
+
+    await ctx.ui.custom<void>((tui, theme, keybindings, done) => {
+      const frame = new Frame(theme);
+      const option = new FormField(tui, keybindings, theme, {
+        key: "pattern",
+        label: formatRuleOptionLabel(toAdd.scope, toAdd.value),
+        mode: {
+          type: "input",
+          placeholder: getRulePatternPlaceholder(category),
+          startEditing: true,
+        },
+      });
+
+      option.focused = true;
+      option.onInputSubmit = (inputValue) => {
+        const nextPattern = inputValue.trim();
+        if (!nextPattern) return false;
+
+        const rules = new Map([[nextPattern, toAdd.value]]);
+        void addRules(ctx.cwd, sessionId, toAdd.scope, category, rules)
+          .then(done)
+          .catch((error) => notifyError(ctx, error, done));
+        return true;
+      };
+      option.onInputCancel = done;
+      frame.addCustom(option);
+
+      return {
+        render: (width) => frame.render(width),
+        invalidate: () => {
+          frame.invalidate();
+          option.invalidate();
+        },
+        handleInput: (data: string) => {
+          if (matchesKey(data, Key.shift("tab"))) {
+            cycleRuleScope(toAdd);
+            option.setLabel(formatRuleOptionLabel(toAdd.scope, toAdd.value));
+            return;
+          }
+          if (matchesKey(data, Key.tab)) {
+            cycleRuleValue(toAdd);
+            option.setLabel(formatRuleOptionLabel(toAdd.scope, toAdd.value));
+            return;
+          }
+          option.handleInput(data);
+        },
+      };
+    });
+  }
+}

package/src/permission/components/prompt.ts

@@ -0,0 +1,255 @@
+import { Input, Key, visibleWidth, wrapTextWithAnsi, type Focusable } from "@earendil-works/pi-tui";
+import type { PromptDecision, PermissionCheck, PromptOptions, FileAccess } from "../types.js";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Frame } from "../../ui/components/frame.js";
+import { SCOPES } from "../constants.js";
+import { Lines } from "../../ui/components/lines.js";
+import { getScopeLabel, mapToRules } from "../helpers.js";
+import { addRules } from "../storage.js";
+import { toPattern } from "../pattern.js";
+import { unique } from "../../utils.js";
+
+export default class PermissionPrompt extends Frame implements Focusable {
+  private cursor: number = 0;
+  private amending: boolean = false;
+  private readonly input = new Input();
+  private scopeIdx = 0;
+  private options: PromptOptions[] = [];
+  private _focused = false;
+  private cachedLines: string[] | undefined;
+  private inputError: string | undefined;
+  private readonly patterns: string[] = [];
+
+  onDone?: (decision: PromptDecision) => void;
+
+  constructor(
+    protected theme: Theme,
+    private readonly check: PermissionCheck,
+    private readonly cwd: string,
+  ) {
+    super(theme);
+    if (!check.uncertainty) {
+      this.patterns = unique(
+        check.extracted.map((item) => toPattern(check.toolName, item)).filter(Boolean),
+      );
+    }
+
+    this.setOptions();
+    this.registerKeybindings([
+      {
+        key: Key.escape,
+        hint: "dismiss",
+        handler: () => {
+          if (this.amending) {
+            this.setAmending(false);
+            return;
+          }
+          this.onDone?.({ allowed: false });
+          this.cachedLines = undefined;
+        },
+      },
+      {
+        key: Key.shift("tab"),
+        hint: "cycle scope",
+        handler: () => {
+          this.scopeIdx = (this.scopeIdx + 1) % SCOPES.length;
+          this.setOptions();
+          this.cachedLines = undefined;
+        },
+      },
+      {
+        key: { navigation: "vertical" },
+        hint: "navigate",
+        navigate: (keyId) => {
+          if (keyId === Key.up) {
+            this.cursor = Math.max(0, this.cursor - 1);
+          } else {
+            this.cursor = Math.min(this.options.length - 1, this.cursor + 1);
+          }
+          this.setAmending(false);
+          this.cachedLines = undefined;
+        },
+      },
+      {
+        key: Key.tab,
+        hint: "amend",
+        handler: () => {
+          if (this.amending) return;
+          const option = this.options[this.cursor];
+          if (option) {
+            this.input.setValue(option.defaultText ?? "");
+            this.setAmending(true);
+          }
+          this.cachedLines = undefined;
+        },
+      },
+      {
+        key: Key.enter,
+        handler: () => {
+          this.commitSelection();
+          this.cachedLines = undefined;
+        },
+      },
+      {
+        key: Key.backspace,
+        handler: () => {
+          if (this.input.getValue() !== "" || !this.amending) return;
+          this.setAmending(false);
+        },
+      },
+    ]);
+  }
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.input.focused = value && this.amending;
+  }
+
+  override invalidate() {
+    this.cachedLines = undefined;
+    super.invalidate();
+    this.input.invalidate();
+  }
+
+  protected override children(width: number): string[] {
+    if (this.cachedLines) return this.cachedLines;
+
+    const lines = new Lines(width);
+    const { toolName, extracted, uncertainty } = this.check;
+    const uncertaintyNote = uncertainty ? `${uncertainty} detected. ` : "";
+
+    lines.add(this.theme.italic(`${uncertaintyNote}Allow agent to use '${toolName}' tool?`));
+    for (const line of wrapTextWithAnsi(this.check.purpose, width)) {
+      lines.add(this.theme.fg("muted", line));
+    }
+
+    lines.space();
+    this.addRawLines(lines, extracted.join(", "), width);
+    lines.space();
+
+    for (const [i, option] of this.options.entries()) {
+      const isSelected = i === this.cursor;
+      const label = `${isSelected ? "→" : " "} ${i + 1}. ${option.label}`;
+
+      if (isSelected && this.amending) {
+        const fullLabel = this.theme.fg("accent", `${label}${option.separator}`);
+        const inputWidth = width - visibleWidth(fullLabel);
+        const inputLine = this.input.render(Math.max(4, inputWidth))[0]!.slice(1);
+        lines.add(fullLabel + inputLine);
+      } else {
+        const suffix = option.defaultText ? `${option.separator} ${option.defaultText}` : "";
+        lines.add(this.theme.fg(isSelected ? "accent" : "text", label + suffix));
+      }
+    }
+
+    if (this.inputError) {
+      lines.space();
+      lines.add(this.theme.fg("warning", this.inputError));
+    }
+
+    this.cachedLines = lines.get();
+    return this.cachedLines;
+  }
+
+  handleInput(data: string) {
+    if (this.handleKb(data) || !this.amending) return;
+    this.cachedLines = undefined;
+    this.inputError = undefined;
+    this.input.handleInput(data);
+  }
+
+  private addRawLines(lines: Lines, raw: string, width: number) {
+    const normalized = raw.replace(/\r\n?/g, "\n");
+    const truncated = normalized.length > 100 ? `${normalized.slice(0, 100)}…` : normalized;
+
+    for (const line of truncated.split("\n")) {
+      if (!line) {
+        lines.space();
+        continue;
+      }
+      for (const wrapped of wrapTextWithAnsi(this.theme.bold(line), width)) {
+        lines.add(wrapped);
+      }
+    }
+  }
+
+  private setAmending(value: boolean) {
+    this.amending = value;
+    this.inputError = undefined;
+    this.input.focused = this._focused && value;
+    this.setKeyAccess(Key.backspace, !value);
+    if (!value) this.input.setValue("");
+  }
+
+  private commitSelection() {
+    const option = this.options[this.cursor];
+    if (!option) return;
+
+    const inputText = this.amending ? this.input.getValue().trim() : "";
+    if (option.persists) {
+      let patterns = this.patterns;
+      if (inputText) {
+        try {
+          const parsed: unknown[] = JSON.parse(`[${inputText}]`);
+          patterns = unique(
+            parsed
+              .map((pattern) => (typeof pattern === "string" ? pattern.trim() : ""))
+              .filter(Boolean),
+          );
+          if (parsed.length === 0) throw new Error();
+        } catch {
+          this.inputError = "Enter non-empty patterns in double quotes, separated by commas";
+          return;
+        }
+      }
+
+      const rules = mapToRules(patterns, this.check.category, option.value.allowed);
+      this.setAmending(false);
+      void addRules(
+        this.cwd,
+        this.check.sessionId,
+        SCOPES[this.scopeIdx]!,
+        this.check.category,
+        rules,
+      );
+      this.onDone?.({ allowed: option.value.allowed });
+      return;
+    }
+
+    const decision: PromptDecision = { ...option.value };
+    if (inputText) decision.amended = inputText;
+    this.onDone?.(decision);
+  }
+
+  private setOptions() {
+    const { toolName } = this.check;
+    const scopeLabel = getScopeLabel(SCOPES[this.scopeIdx]!);
+    this.options = [
+      { label: "Yes", separator: ",", value: { allowed: true }, persists: false },
+      { label: "No", separator: ",", value: { allowed: false }, persists: false },
+    ];
+    if (this.check.uncertainty) return;
+
+    const defaultText = this.patterns.map((pattern) => JSON.stringify(pattern)).join(", ");
+    this.options.push(
+      {
+        label: `Yes, allow ${toolName} tool call ${scopeLabel} for`,
+        defaultText,
+        separator: ":",
+        value: { allowed: true },
+        persists: true,
+      },
+      {
+        label: `No, disallow ${toolName} tool call ${scopeLabel} for`,
+        defaultText,
+        separator: ":",
+        value: { allowed: false },
+        persists: true,
+      },
+    );
+  }
+}