surgent 0.7.0-alpha.0

package/src/permission/pattern.ts

@@ -0,0 +1,51 @@
+import { bashToPattern } from "./bash.js";
+import type { PermissiveToolName } from "./types.js";
+
+export function filePathToPattern(path: string): string {
+  if (!path || path.endsWith("/")) return path;
+
+  const lastSlash = path.lastIndexOf("/");
+  const dir = lastSlash >= 0 ? path.slice(0, lastSlash + 1) : "";
+  const filename = lastSlash >= 0 ? path.slice(lastSlash + 1) : path;
+
+  if (!filename) return path;
+
+  const depth = dir.split("/").filter(Boolean).length;
+
+  if (depth >= 3) return `${dir}**`;
+
+  if (filename.startsWith(".")) {
+    const extDot = filename.lastIndexOf(".");
+    return extDot > 0 ? `${dir}.*${filename.slice(extDot)}` : `${dir}.*`;
+  }
+
+  const extDot = filename.lastIndexOf(".");
+  return extDot > 0 ? `${dir}*${filename.slice(extDot)}` : `${dir}*`;
+}
+
+export function urlToPattern(url: string): string {
+  if (!url) return "";
+  try {
+    const { origin } = new URL(url);
+    return `${origin}/**`;
+  } catch {
+    return url;
+  }
+}
+
+export function toPattern(toolName: PermissiveToolName, input: string): string {
+  const firstLine = input.replace(/\r\n?/g, "\n").split("\n")[0] ?? "";
+  switch (toolName) {
+    case "read":
+    case "write":
+    case "edit":
+    case "grep":
+      return filePathToPattern(firstLine);
+    case "web_fetch":
+      return urlToPattern(firstLine);
+    case "bash":
+      return bashToPattern(input);
+    case "call_mcp_tool":
+      return input;
+  }
+}

package/src/permission/piignore.ts

@@ -0,0 +1,148 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { getRelativePathInRoot } from "./resolution.js";
+import { matchesPattern, specificity } from "./precedence.js";
+import { isMissingFileError } from "../utils.js";
+import type {
+  GrepToolCallEvent,
+  ReadToolCallEvent,
+  ToolCallEvent,
+} from "@earendil-works/pi-coding-agent";
+
+const PI_IGNORE_FILE = ".piignore";
+
+interface PiIgnoreRule {
+  pattern: string;
+  matcher: string;
+  negated: boolean;
+  score: number;
+  order: number;
+}
+
+const piIgnoreCache: { contents: string; rules: PiIgnoreRule[] } = { contents: "", rules: [] };
+
+function normalizePathToRoot(rawPath: string, rootPath: string): string | null {
+  const relativePath = getRelativePathInRoot(rawPath, rootPath);
+  if (relativePath === null) return null;
+
+  const posixPath = (relativePath === "" ? "." : relativePath).replace(/\\/g, "/");
+  if (posixPath === "/") return posixPath;
+
+  const trimmedPath = posixPath.replace(/\/+$/, "");
+  return trimmedPath || ".";
+}
+
+function normalizePiIgnorePattern(pattern: string): string | null {
+  let normalizedPattern = pattern.replace(/\\/g, "/");
+  const directoryOnly = normalizedPattern.endsWith("/");
+
+  normalizedPattern = normalizedPattern.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!normalizedPattern || normalizedPattern === ".") {
+    return null;
+  }
+  if (directoryOnly) {
+    return `${normalizedPattern}/**`;
+  }
+
+  return normalizedPattern;
+}
+
+function parsePiIgnoreRules(contents: string): PiIgnoreRule[] {
+  const rules: PiIgnoreRule[] = [];
+
+  for (const [order, pattern] of contents.split(/\r?\n/).entries()) {
+    if (!pattern || pattern.startsWith("#")) continue;
+
+    const negated = pattern.startsWith("!") && pattern !== "!";
+    const rawPattern = negated ? pattern.slice(1) : pattern;
+    const matcher = normalizePiIgnorePattern(rawPattern);
+    if (!matcher) continue;
+
+    rules.push({ pattern, matcher, negated, score: specificity(matcher), order });
+  }
+
+  return rules;
+}
+
+async function loadPiIgnoreRules(cwd: string): Promise<PiIgnoreRule[]> {
+  const piIgnorePath = resolve(cwd, PI_IGNORE_FILE);
+  let contents = "";
+
+  try {
+    contents = await readFile(piIgnorePath, "utf8");
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      piIgnoreCache.contents = "";
+      piIgnoreCache.rules = [];
+      return [];
+    }
+    throw error;
+  }
+
+  if (piIgnoreCache.contents === contents) {
+    return piIgnoreCache.rules;
+  }
+
+  const rules = parsePiIgnoreRules(contents);
+  piIgnoreCache.contents = contents;
+  piIgnoreCache.rules = rules;
+  return rules;
+}
+
+function findBestPiIgnoreRule(
+  rules: PiIgnoreRule[],
+  rawPath: string,
+  cwd: string,
+): PiIgnoreRule | null {
+  const normalizedPath = normalizePathToRoot(rawPath, cwd);
+  if (!normalizedPath) return null;
+
+  let bestRule: PiIgnoreRule | null = null;
+
+  for (const rule of rules) {
+    if (!matchesPattern(normalizedPath, rule.matcher)) continue;
+
+    if (
+      bestRule === null ||
+      rule.score > bestRule.score ||
+      (rule.score === bestRule.score && rule.order > bestRule.order)
+    ) {
+      bestRule = rule;
+    }
+  }
+
+  return bestRule;
+}
+
+export async function resolvePiIgnorePathBlock(
+  cwd: string,
+  rawPath: string,
+): Promise<string | null> {
+  const rules = await loadPiIgnoreRules(cwd);
+  if (rules.length === 0) return null;
+
+  const matchedRule = findBestPiIgnoreRule(rules, rawPath, cwd);
+  if (!matchedRule || matchedRule.negated) {
+    return null;
+  }
+
+  return `Path blocked by .piignore rule "${matchedRule.pattern}"`;
+}
+
+export function getPiIgnoreInputs(event: ToolCallEvent): string[] {
+  switch (event.toolName) {
+    case "read":
+    case "write":
+    case "edit":
+      return [(event as ReadToolCallEvent).input.path];
+    case "grep": {
+      const grepEvent = event as GrepToolCallEvent;
+      const inputs: string[] = [];
+      if (grepEvent.input.path) inputs.push(grepEvent.input.path);
+      if (grepEvent.input.glob) inputs.push(grepEvent.input.glob);
+      return inputs;
+    }
+    default:
+      return [];
+  }
+}

package/src/permission/precedence.ts

@@ -0,0 +1,54 @@
+import pm from "picomatch";
+import type { FileAccess } from "./types.js";
+
+const GLOB_CHARS = /[*?[\]{}]/;
+
+export function specificity(pattern: string): number {
+  return GLOB_CHARS.test(pattern) ? pattern.length : Infinity;
+}
+
+export function matchesPattern(input: string, pattern: string, bash = false): boolean {
+  if (pattern === input) return true;
+  if (!GLOB_CHARS.test(pattern)) return false;
+
+  try {
+    return pm(pattern, { dot: true, bash })(input);
+  } catch {
+    return false;
+  }
+}
+
+export function findScopedPermission(
+  scopes: Array<Record<string, FileAccess | boolean>>,
+  input: string,
+  bash = false,
+  fileOp?: "read" | "write",
+): "allowed" | "blocked" | "ask" {
+  for (const rules of scopes) {
+    let best: { permission: "allowed" | "blocked"; score: number } | null = null;
+    for (const [pattern, value] of Object.entries(rules)) {
+      if (!matchesPattern(input, pattern, bash)) continue;
+
+      const permission =
+        typeof value === "boolean"
+          ? value
+            ? "allowed"
+            : "blocked"
+          : value === "write" || value === fileOp
+            ? "allowed"
+            : "blocked";
+      const score = specificity(pattern);
+
+      if (
+        best === null ||
+        score > best.score ||
+        (score === best.score && permission === "blocked")
+      ) {
+        best = { permission, score };
+      }
+    }
+    if (best) return best.permission;
+  }
+
+  return "ask";
+}

package/src/permission/resolution.ts

@@ -0,0 +1,116 @@
+import { homedir } from "node:os";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import type { AgentMeta, AgentMode } from "../agent/types.js";
+import { readRules } from "./storage.js";
+import type { Category, FileAccess, PermissionRule, PermissionCheck } from "./types.js";
+import { getPiPath } from "../utils.js";
+import { findSubsession } from "../subagent/storage.js";
+import { findScopedPermission, matchesPattern } from "./precedence.js";
+import { extractOpAndPath } from "./helpers.js";
+
+function getSchemaRules(
+  schema: PermissionRule | undefined,
+  category: Category,
+): Record<string, FileAccess | boolean> {
+  if (!schema) return {};
+  if (category === "file") return schema.file ?? {};
+  if (category === "web") return schema.web ?? {};
+  if (category === "mcp") return schema.mcp ?? {};
+  return schema.bash ?? {};
+}
+
+function getBlockedRules(schema: PermissionRule): PermissionRule {
+  const keys = ["file", "web", "bash", "mcp"] as const;
+  const rules: PermissionRule = {};
+  for (const key of keys) {
+    rules[key] = Object.fromEntries(
+      Object.entries(schema[key] ?? {}).filter(([, access]) => !access || access === "blocked"),
+    );
+  }
+  return rules;
+}
+
+function isAllowedByPattern(raw: string, allowList?: string[], bash?: boolean): boolean {
+  return Boolean(!allowList || allowList.some((pattern) => matchesPattern(raw, pattern, bash)));
+}
+
+export function checkAgentRules(meta: AgentMeta, check: PermissionCheck): boolean {
+  const { category, extracted } = check;
+  if (category === "bash") {
+    return extracted.every((item) => isAllowedByPattern(item, meta.bash, true));
+  }
+  if (category === "file") {
+    return extracted.every((item) => {
+      const [op, path] = extractOpAndPath(item);
+      return isAllowedByPattern(path, meta[`files.${op}`]);
+    });
+  }
+  if (category === "mcp") {
+    return extracted.every((item) => isAllowedByPattern(item, meta.mcp_tools));
+  }
+  return true;
+}
+
+export function expandFilePath(path: string, cwd: string): string | null {
+  if (!path) return null;
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) {
+    return resolve(homedir(), path.slice(2));
+  }
+  return resolve(cwd, path);
+}
+
+export function getRelativePathInRoot(path: string, root: string): string | null {
+  const resolvedPath = expandFilePath(path, root);
+  if (!resolvedPath) return null;
+
+  const relativePath = relative(root, resolvedPath);
+  if (relativePath !== "" && (relativePath.startsWith("..") || isAbsolute(relativePath))) {
+    return null;
+  }
+
+  return relativePath;
+}
+
+export async function resolvePermission(cwd: string, check: PermissionCheck, mode: AgentMode) {
+  let shouldAsk = false;
+  const { category, extracted, sessionId } = check;
+  const [local, global, subsession] = await Promise.all([
+    readRules(cwd),
+    readRules(),
+    findSubsession(cwd, sessionId),
+  ]);
+
+  const scopes: Array<PermissionRule | undefined> = [local[sessionId]];
+  if (subsession?.pid && subsession.pid !== sessionId) {
+    scopes.push(local[subsession.pid]);
+  }
+  scopes.push(local.project);
+  scopes.push(mode === "restricted" ? getBlockedRules(global) : global);
+
+  for (const item of extracted) {
+    const [fileOp, normalized] = category === "file" ? extractOpAndPath(item) : [undefined, item];
+    let permission: "allowed" | "blocked" | "ask" = findScopedPermission(
+      scopes.map((schema) => getSchemaRules(schema, category)),
+      normalized,
+      category === "bash",
+      fileOp,
+    );
+
+    if (
+      category === "file" &&
+      permission === "ask" &&
+      (mode !== "restricted" || fileOp !== "write")
+    ) {
+      const inAllowedDir =
+        getRelativePathInRoot(normalized, cwd) !== null ||
+        getRelativePathInRoot(normalized, dirname(getPiPath("settings"))) !== null;
+      permission = inAllowedDir ? "allowed" : "ask";
+    }
+
+    if (permission === "blocked") return "blocked";
+    if (permission === "ask") shouldAsk = true;
+  }
+
+  return shouldAsk ? "ask" : "allowed";
+}

package/src/permission/storage.ts

@@ -0,0 +1,142 @@
+import { readJson, writeJson } from "../utils.js";
+import type {
+  Category,
+  GroupedDisplayRules,
+  FileAccess,
+  PermissionRule,
+  Scope,
+  DisplayRule,
+} from "./types.js";
+import { getPiPath } from "../utils.js";
+import { CATEGORIES } from "./constants.js";
+import type { AgentMode, SettingsSchema } from "../agent/types.js";
+
+interface LocalSchema {
+  project?: PermissionRule;
+  [sessionId: string]: PermissionRule | undefined;
+}
+
+export async function writeRules(data: PermissionRule | LocalSchema, cwd: string = "") {
+  return writeJson(getPiPath("permissions", cwd), data);
+}
+
+export function readRules(cwd: string): Promise<LocalSchema>;
+export function readRules(): Promise<PermissionRule>;
+export function readRules(cwd: string = ""): Promise<LocalSchema | PermissionRule> {
+  return readJson<LocalSchema | PermissionRule>(getPiPath("permissions", cwd), {});
+}
+
+export async function readAgentMode(): Promise<AgentMode> {
+  const settings = await readJson<SettingsSchema>(getPiPath("settings"), {});
+  return settings.agent?.mode ?? "assistant";
+}
+
+export async function writeAgentMode(agentMode: AgentMode) {
+  const settingsPath = getPiPath("settings");
+  const settings = await readJson<SettingsSchema>(settingsPath, {});
+  settings.agent = { ...settings.agent, mode: agentMode };
+  await writeJson(settingsPath, settings);
+}
+
+async function mutateRules(
+  cwd: string,
+  sessionId: string,
+  scope: Scope,
+  category: Category,
+  mutate: (rules: Record<string, FileAccess | boolean>) => void,
+) {
+  if (scope === "always") {
+    const global = await readRules();
+    const rules = { ...global[category] };
+
+    mutate(rules);
+    global[category] = rules;
+    await writeRules(global);
+    return;
+  }
+
+  const local = await readRules(cwd);
+  const scopeKey = scope === "project" ? "project" : sessionId;
+  const scopeSchema: PermissionRule = local[scopeKey] ?? {};
+  const rules = { ...scopeSchema[category] };
+
+  mutate(rules);
+  scopeSchema[category] = rules;
+  local[scopeKey] = scopeSchema;
+  await writeRules(local, cwd);
+}
+
+export async function addRules(
+  cwd: string,
+  sessionId: string,
+  scope: Scope,
+  category: Category,
+  rules: Map<string, FileAccess | boolean>,
+) {
+  await mutateRules(cwd, sessionId, scope, category, (rulesSet) => {
+    for (const [pattern, perm] of rules) {
+      rulesSet[pattern] = perm;
+    }
+  });
+}
+
+export async function removeRule(
+  cwd: string,
+  sessionId: string,
+  scope: Scope,
+  category: Category,
+  pattern: string,
+) {
+  await mutateRules(cwd, sessionId, scope, category, (rules) => {
+    delete rules[pattern];
+  });
+}
+
+export async function toggleRule(
+  cwd: string,
+  sessionId: string,
+  scope: Scope,
+  category: Category,
+  pattern: string,
+) {
+  await mutateRules(cwd, sessionId, scope, category, (rules) => {
+    if (category === "file") {
+      const cycle: FileAccess[] = ["write", "read", "blocked"];
+      const currentValue = rules[pattern] as FileAccess | undefined;
+      const cycleIndex = cycle.indexOf(currentValue as FileAccess);
+      rules[pattern] = cycle[(cycleIndex + 1) % cycle.length]!;
+      return;
+    }
+
+    const currentValue = rules[pattern] as boolean | undefined;
+    rules[pattern] = !currentValue;
+  });
+}
+
+export async function getRulesForDisplay(
+  cwd: string,
+  sessionId: string,
+): Promise<GroupedDisplayRules> {
+  const [local, global] = await Promise.all([readRules(cwd), readRules()]);
+  const rules = Object.fromEntries(
+    CATEGORIES.map((cat) => [cat, [] as DisplayRule[]]),
+  ) as GroupedDisplayRules;
+
+  const addFromSchema = (schema: PermissionRule | undefined, scope: Scope) => {
+    if (!schema) return;
+
+    for (const category of CATEGORIES) {
+      if (!rules[category]) return;
+      const categoryRules = schema[category] ?? {};
+      for (const [pattern, value] of Object.entries(categoryRules)) {
+        rules[category].push({ pattern, value: value as FileAccess | boolean, scope, category });
+      }
+    }
+  };
+
+  addFromSchema(local[sessionId], "session");
+  addFromSchema(local.project, "project");
+  addFromSchema(global, "always");
+
+  return rules;
+}

package/src/permission/types.ts

@@ -0,0 +1,57 @@
+import { SCOPES, PERMISSIVE_TOOLS } from "./constants.js";
+
+type FileOp = "read" | "write";
+
+export type PermissiveToolName = keyof typeof PERMISSIVE_TOOLS;
+export type Scope = (typeof SCOPES)[number];
+export type Category = (typeof PERMISSIVE_TOOLS)[PermissiveToolName];
+export type FileAccess = FileOp | "blocked";
+
+export interface PermissionRule {
+  file?: Record<string, FileAccess>;
+  web?: Record<string, boolean>;
+  bash?: Record<string, boolean>;
+  mcp?: Record<string, boolean>;
+}
+
+export interface PermissionCheck {
+  sessionId: string;
+  toolName: PermissiveToolName;
+  category: Category;
+  raw: string;
+  extracted: string[];
+  purpose: string;
+  uncertainty?: string;
+}
+
+export interface PromptDecision {
+  allowed: boolean;
+  amended?: string;
+}
+
+export interface DisplayRule {
+  category: Category;
+  pattern: string;
+  value: FileAccess | boolean;
+  scope: Scope;
+}
+
+export type GroupedDisplayRules = {
+  file: DisplayRule[];
+  web: DisplayRule[];
+  bash: DisplayRule[];
+  mcp: DisplayRule[];
+};
+
+export type PromptOptions = {
+  label: string;
+  value: PromptDecision;
+  persists: boolean;
+  separator: string;
+  defaultText?: string;
+};
+
+export interface BashCommand {
+  text: string;
+  unresolved: boolean;
+}