@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/compactor/src/config/presets.ts

@@ -1,160 +0,0 @@
-/**
- * Preset definitions + detection for compactor config
- */
-
-import { createHash } from "node:crypto";
-import type { CompactorConfig, CompactorPreset } from "../types.js";
-import { DEFAULT_COMPACTOR_CONFIG } from "./schema.js";
-
-const pipeline = (overrides: Partial<CompactorConfig["pipeline"]> = {}): CompactorConfig["pipeline"] => ({
-  ...DEFAULT_COMPACTOR_CONFIG.pipeline,
-  ...overrides,
-  customNoisePatterns: [...(overrides.customNoisePatterns ?? DEFAULT_COMPACTOR_CONFIG.pipeline.customNoisePatterns)],
-});
-
-// Auto Injection is the only preset-controlled pipeline feature with a runtime
-// implementation. The other persisted fields are retained as ignored legacy
-// compatibility data, but presets must not advertise or enable them.
-const pipelineWithAutoInjection = (): CompactorConfig["pipeline"] => pipeline({
-  autoInjection: true,
-});
-
-const preset = (
-  overrides: Partial<CompactorConfig>,
-): CompactorConfig => ({
-  ...structuredClone(DEFAULT_COMPACTOR_CONFIG),
-  ...overrides,
-  sessionGoals: { ...DEFAULT_COMPACTOR_CONFIG.sessionGoals, ...(overrides.sessionGoals ?? {}) },
-  filesAndChanges: { ...DEFAULT_COMPACTOR_CONFIG.filesAndChanges, ...(overrides.filesAndChanges ?? {}) },
-  commits: { ...DEFAULT_COMPACTOR_CONFIG.commits, ...(overrides.commits ?? {}) },
-  outstandingContext: { ...DEFAULT_COMPACTOR_CONFIG.outstandingContext, ...(overrides.outstandingContext ?? {}) },
-  userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, ...(overrides.userPreferences ?? {}) },
-  briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, ...(overrides.briefTranscript ?? {}) },
-  sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, ...(overrides.sessionContinuity ?? {}) },
-  // Legacy compatibility data only; presets never advertise or alter it.
-  fts5Index: { ...DEFAULT_COMPACTOR_CONFIG.fts5Index },
-  sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, ...(overrides.sandboxExecution ?? {}) },
-  pipeline: pipeline(overrides.pipeline),
-  autoCompaction: { ...DEFAULT_COMPACTOR_CONFIG.autoCompaction, ...(overrides.autoCompaction ?? {}) },
-});
-
-// Active pipeline behavior per preset:
-// precise/lean: auto-injection off
-// balanced/thorough: auto-injection on
-// Reserved compatibility fields remain at their inert defaults in all presets.
-
-export const PRESET_CONFIGS: Record<CompactorPreset, CompactorConfig> = {
-  // New preset names
-  precise: preset({
-    pipeline: pipeline(),
-    sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "all" },
-  }),
-  thorough: preset({
-    pipeline: pipelineWithAutoInjection(),
-    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
-  }),
-  lean: preset({
-    pipeline: pipeline(),
-    sessionGoals: { ...DEFAULT_COMPACTOR_CONFIG.sessionGoals, enabled: true, mode: "brief" },
-    filesAndChanges: { ...DEFAULT_COMPACTOR_CONFIG.filesAndChanges, enabled: true, mode: "modified-only" },
-    commits: { ...DEFAULT_COMPACTOR_CONFIG.commits, enabled: false, mode: "off" },
-    outstandingContext: { ...DEFAULT_COMPACTOR_CONFIG.outstandingContext, enabled: true, mode: "critical-only" },
-    userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, enabled: false, mode: "off" },
-    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, enabled: true, mode: "minimal" },
-    sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, enabled: false, mode: "off" },
-    sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" },
-  }),
-  balanced: preset({
-    pipeline: pipelineWithAutoInjection(),
-    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "compact" },
-  }),
-
-  // Backward-compat aliases — map old names to new
-  opencode: preset({
-    pipeline: pipeline(),
-    sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, mode: "all" },
-  }),
-  verbose: preset({
-    pipeline: pipelineWithAutoInjection(),
-    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, mode: "full" },
-  }),
-  minimal: preset({
-    pipeline: pipeline(),
-    sessionGoals: { ...DEFAULT_COMPACTOR_CONFIG.sessionGoals, enabled: true, mode: "brief" },
-    filesAndChanges: { ...DEFAULT_COMPACTOR_CONFIG.filesAndChanges, enabled: true, mode: "modified-only" },
-    commits: { ...DEFAULT_COMPACTOR_CONFIG.commits, enabled: false, mode: "off" },
-    outstandingContext: { ...DEFAULT_COMPACTOR_CONFIG.outstandingContext, enabled: true, mode: "critical-only" },
-    userPreferences: { ...DEFAULT_COMPACTOR_CONFIG.userPreferences, enabled: false, mode: "off" },
-    briefTranscript: { ...DEFAULT_COMPACTOR_CONFIG.briefTranscript, enabled: true, mode: "minimal" },
-    sessionContinuity: { ...DEFAULT_COMPACTOR_CONFIG.sessionContinuity, enabled: false, mode: "off" },
-    sandboxExecution: { ...DEFAULT_COMPACTOR_CONFIG.sandboxExecution, enabled: false, mode: "off" },
-  }),
-  custom: structuredClone(DEFAULT_COMPACTOR_CONFIG),
-};
-
-// Pre-computed identity hashes for fast preset detection
-const presetHashes = new Map<string, string>();
-
-function presetHash(config: CompactorConfig): string {
-  return createHash("sha256").update(JSON.stringify(config)).digest("hex");
-}
-
-// Compute hashes once at module load
-for (const name of ["precise", "balanced", "thorough", "lean"] as const) {
-  presetHashes.set(name, presetHash(PRESET_CONFIGS[name]));
-}
-
-function configsEqual(a: CompactorConfig, b: CompactorConfig): boolean {
-  // Fast path: hash comparison
-  const aHash = presetHash(a);
-  const bHash = presetHash(b);
-  if (aHash !== bHash) return false;
-  // Defensive: confirm with full comparison
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
-/**
- * Detect which preset a config matches, or "custom".
- */
-export function detectPreset(config: CompactorConfig): CompactorPreset {
-  const configHash = presetHash(config);
-  for (const name of ["precise", "balanced", "thorough", "lean"] as const) {
-    if (presetHashes.get(name) === configHash && configsEqual(config, PRESET_CONFIGS[name])) {
-      return name;
-    }
-  }
-  return "custom";
-}
-
-/**
- * Apply a preset to a config.
- */
-export function applyPreset(name: CompactorPreset): CompactorConfig {
-  return structuredClone(PRESET_CONFIGS[name]);
-}
-
-// Old → new preset name mapping for backward compatibility
-const OLD_TO_NEW: Record<string, CompactorPreset> = {
-  opencode: "precise",
-  verbose: "thorough",
-  minimal: "lean",
-};
-
-/**
- * Parse a preset name (case-insensitive). Old names are mapped to new with deprecation.
- */
-export function parsePreset(raw: string): CompactorPreset | undefined {
-  const normalized = raw.trim().toLowerCase();
-
-  // Check new names first
-  if (normalized === "precise" || normalized === "balanced" || normalized === "thorough" || normalized === "lean" || normalized === "custom") {
-    return normalized;
-  }
-
-  // Map old names to new (backward compat)
-  if (OLD_TO_NEW[normalized]) {
-    return OLD_TO_NEW[normalized];
-  }
-
-  return undefined;
-}

package/packages/compactor/src/executor/executor.ts

@@ -1,233 +0,0 @@
-/**
- * PolyglotExecutor — sandboxed code execution for 11 languages
- */
-
-import { spawn, execSync } from "node:child_process";
-import { mkdtempSync, writeFileSync, rmSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { detectRuntimes, buildCommand, type RuntimeMap, type Language } from "./runtime.js";
-import type { ExecResult } from "../types.js";
-
-const isWin = process.platform === "win32";
-
-const OS_TMPDIR = isWin ? (process.env.TEMP ?? process.env.TMP ?? tmpdir()) : tmpdir();
-
-function killTree(proc: ReturnType<typeof spawn>): void {
-  if (isWin && proc.pid) {
-    try {
-      execSync(`taskkill /F /T /PID ${proc.pid}`, { stdio: "pipe" });
-    } catch { /* already dead */ }
-  } else if (proc.pid) {
-    try {
-      process.kill(-proc.pid, "SIGKILL");
-    } catch { /* already dead */ }
-  }
-}
-
-const DANGEROUS_ENV_VARS = [
-  "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN",
-  "AZURE_CLIENT_ID", "AZURE_CLIENT_SECRET", "AZURE_TENANT_ID",
-  "GCP_SERVICE_ACCOUNT_KEY", "GOOGLE_APPLICATION_CREDENTIALS",
-  "GITHUB_TOKEN", "GH_TOKEN", "GITLAB_TOKEN",
-  "DOCKER_AUTH_CONFIG", "KUBECONFIG",
-  "NPM_TOKEN", "NODE_AUTH_TOKEN", "YARN_AUTH_TOKEN",
-  "PYPI_TOKEN", "POETRY_PYPI_TOKEN_PYPI",
-  "SSH_PRIVATE_KEY", "SSH_AUTH_SOCK",
-  "DATABASE_URL", "REDIS_URL", "MONGO_URL",
-  "SECRET_KEY", "JWT_SECRET", "API_KEY", "API_SECRET",
-  "PASSWORD", "PASSPHRASE", "TOKEN", "CREDENTIALS",
-];
-
-function sanitizeEnv(): NodeJS.ProcessEnv {
-  const env = { ...process.env };
-  for (const key of DANGEROUS_ENV_VARS) {
-    delete env[key];
-  }
-  // Also strip anything matching *SECRET*, *PASSWORD*, *TOKEN*, *KEY*
-  for (const key of Object.keys(env)) {
-    const upper = key.toUpperCase();
-    if (upper.includes("SECRET") || upper.includes("PASSWORD") || upper.includes("TOKEN") || upper.includes("PRIVATE_KEY")) {
-      delete env[key];
-    }
-  }
-  return env;
-}
-
-interface ExecuteOptions {
-  language: Language;
-  code: string;
-  timeout?: number;
-  background?: boolean;
-}
-
-interface ExecuteFileOptions {
-  language: Language;
-  path: string;
-  timeout?: number;
-  background?: boolean;
-}
-
-export class PolyglotExecutor {
-  #hardCapBytes: number;
-  #projectRoot: string;
-  #runtimes: RuntimeMap;
-  #backgroundedPids = new Set<number>();
-
-  constructor(opts?: { hardCapBytes?: number; projectRoot?: string; runtimes?: RuntimeMap }) {
-    this.#hardCapBytes = opts?.hardCapBytes ?? 100 * 1024 * 1024;
-    this.#projectRoot = opts?.projectRoot ?? process.cwd();
-    this.#runtimes = opts?.runtimes ?? detectRuntimes();
-  }
-
-  get runtimes(): RuntimeMap {
-    return { ...this.#runtimes };
-  }
-
-  cleanupBackgrounded(): void {
-    for (const pid of this.#backgroundedPids) {
-      try {
-        process.kill(isWin ? pid : -pid, "SIGTERM");
-      } catch { /* already dead */ }
-    }
-    this.#backgroundedPids.clear();
-  }
-
-  async execute(opts: ExecuteOptions): Promise<ExecResult> {
-    const { language, code, timeout = 30_000, background = false } = opts;
-    const tmpDir = mkdtempSync(join(OS_TMPDIR, ".compactor-"));
-
-    try {
-      const filePath = this.#writeScript(tmpDir, code, language);
-      const cmd = buildCommand(this.#runtimes, language, filePath);
-
-      if (cmd[0] === "__rust_compile_run__") {
-        return await this.#compileAndRun(filePath, tmpDir, timeout);
-      }
-
-      const cwd = language === "shell" ? this.#projectRoot : tmpDir;
-      const result = await this.#spawn(cmd, cwd, tmpDir, timeout, background);
-
-      if (!result.backgrounded) {
-        try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
-      }
-
-      return result;
-    } catch (err: unknown) {
-      try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
-      return {
-        stdout: "",
-        stderr: (err instanceof Error ? err.message : String(err)),
-        exitCode: 1,
-        timedOut: false,
-      };
-    }
-  }
-
-  async executeFile(opts: ExecuteFileOptions): Promise<ExecResult> {
-    const { language, path, timeout = 30_000, background = false } = opts;
-    const cmd = buildCommand(this.#runtimes, language, path);
-    const cwd = language === "shell" ? this.#projectRoot : resolve(path, "..");
-    return this.#spawn(cmd, cwd, "", timeout, background);
-  }
-
-  #writeScript(tmpDir: string, code: string, language: Language): string {
-    const extensions: Record<Language, string> = {
-      javascript: "js", typescript: "ts", python: "py", shell: "sh",
-      ruby: "rb", go: "go", rust: "rs", php: "php", perl: "pl", r: "r", elixir: "ex",
-    };
-    const ext = extensions[language];
-    const filePath = join(tmpDir, `script.${ext}`);
-    writeFileSync(filePath, code, "utf-8");
-    return filePath;
-  }
-
-  async #spawn(
-    cmd: string[],
-    cwd: string,
-    tmpDir: string,
-    timeout: number,
-    background: boolean,
-  ): Promise<ExecResult> {
-    return new Promise((resolve) => {
-      const proc = spawn(cmd[0], cmd.slice(1), {
-        cwd,
-        env: sanitizeEnv(),
-        stdio: ["ignore", "pipe", "pipe"],
-        detached: !isWin,
-      });
-
-      let stdout = "";
-      let stderr = "";
-      let killed = false;
-      let stdoutLen = 0;
-      let stderrLen = 0;
-
-      const killIfOversized = () => {
-        if (stdoutLen + stderrLen > this.#hardCapBytes && !killed) {
-          killed = true;
-          killTree(proc);
-        }
-      };
-
-      proc.stdout?.on("data", (chunk: Buffer) => {
-        stdout += chunk.toString("utf-8");
-        stdoutLen += chunk.length;
-        killIfOversized();
-      });
-
-      proc.stderr?.on("data", (chunk: Buffer) => {
-        stderr += chunk.toString("utf-8");
-        stderrLen += chunk.length;
-        killIfOversized();
-      });
-
-      const timer = background ? null : setTimeout(() => {
-        if (!killed) {
-          killed = true;
-          killTree(proc);
-        }
-      }, timeout);
-
-      proc.on("error", (err) => {
-        if (timer) clearTimeout(timer);
-        resolve({ stdout, stderr: err.message, exitCode: 1, timedOut: false });
-      });
-
-      proc.on("close", (code) => {
-        if (timer) clearTimeout(timer);
-        if (background && proc.pid) {
-          this.#backgroundedPids.add(proc.pid);
-        }
-        resolve({
-          stdout: stdout.slice(0, this.#hardCapBytes),
-          stderr: stderr.slice(0, this.#hardCapBytes),
-          exitCode: code ?? 0,
-          timedOut: killed && !background,
-          backgrounded: background && !!proc.pid,
-        });
-      });
-    });
-  }
-
-  async #compileAndRun(filePath: string, tmpDir: string, timeout: number): Promise<ExecResult> {
-    const binPath = join(tmpDir, "script");
-    try {
-      execSync(`rustc "${filePath}" -o "${binPath}"`, {
-        cwd: tmpDir,
-        env: sanitizeEnv(),
-        timeout: timeout / 2,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-    } catch (err: unknown) {
-      return {
-        stdout: "",
-        stderr: (err instanceof Error && 'stderr' in err ? String((err as Error & { stderr?: Buffer }).stderr) : '') || (err instanceof Error ? err.message : String(err)) || "Rust compilation failed",
-        exitCode: 1,
-        timedOut: false,
-      };
-    }
-
-    return this.#spawn([binPath], tmpDir, tmpDir, timeout / 2, false);
-  }
-}

package/packages/compactor/src/executor/runtime.ts

@@ -1,115 +0,0 @@
-/**
- * Runtime detection for sandbox executor
- */
-
-import type { Language } from "../types.js";
-export type { Language };
-
-export interface RuntimeMap {
-  javascript: string;
-  typescript: string;
-  python: string;
-  shell: string;
-  ruby?: string;
-  go?: string;
-  rust?: string;
-  php?: string;
-  perl?: string;
-  r?: string;
-  elixir?: string;
-}
-
-export function detectRuntimes(): RuntimeMap {
-  const runtimes: Partial<RuntimeMap> = {};
-
-  // JavaScript / TypeScript — prefer Bun, fall back to Node
-  try {
-    const { execSync } = require("node:child_process");
-    try {
-      execSync("command -v bun", { stdio: "ignore" });
-      runtimes.javascript = "bun";
-      runtimes.typescript = "bun";
-    } catch {
-      runtimes.javascript = "node";
-      runtimes.typescript = "npx tsx";
-    }
-  } catch {
-    runtimes.javascript = "node";
-    runtimes.typescript = "npx tsx";
-  }
-
-  // Shell
-  runtimes.shell = "bash";
-
-  // Python
-  try {
-    const { execSync } = require("node:child_process");
-    try {
-      execSync("command -v python3", { stdio: "ignore" });
-      runtimes.python = "python3";
-    } catch {
-      runtimes.python = "python";
-    }
-  } catch {
-    runtimes.python = "python3";
-  }
-
-  // Optional runtimes
-  const optional = [
-    ["ruby", "ruby"],
-    ["go", "go"],
-    ["rustc", "rust"],
-    ["php", "php"],
-    ["perl", "perl"],
-    ["Rscript", "r"],
-    ["elixir", "elixir"],
-  ] as const;
-
-  for (const [cmd, lang] of optional) {
-    try {
-      const { execSync } = require("node:child_process");
-      execSync(`command -v ${cmd}`, { stdio: "ignore" });
-      (runtimes as any)[lang] = cmd;
-    } catch {
-      // not available
-    }
-  }
-
-  return runtimes as RuntimeMap;
-}
-
-export function buildCommand(
-  runtimes: RuntimeMap,
-  language: Language,
-  filePath: string,
-): string[] {
-  const runtime = runtimes[language];
-  if (!runtime) throw new Error(`No runtime available for ${language}`);
-
-  switch (language) {
-    case "javascript":
-      return runtime === "bun" ? ["bun", "run", filePath] : ["node", filePath];
-    case "typescript":
-      return runtime === "bun" ? ["bun", "run", filePath] : ["npx", "tsx", filePath];
-    case "python":
-      return [runtime, filePath];
-    case "shell":
-      return ["bash", filePath];
-    case "ruby":
-      return [runtime, filePath];
-    case "go":
-      return ["go", "run", filePath];
-    case "rust":
-      return ["__rust_compile_run__", filePath];
-    case "php":
-      return [runtime, filePath];
-    case "perl":
-      return [runtime, filePath];
-    case "r":
-      return [runtime, filePath];
-    case "elixir":
-      return [runtime, filePath];
-    default:
-      throw new Error(`Unsupported language: ${language}`);
-  }
-}

package/packages/compactor/src/security/evaluator.ts

@@ -1,89 +0,0 @@
-/**
- * Security evaluator — command + file path evaluation
- *
- * Supports loading permission patterns from .pi/settings.json
- */
-
-import { realpathSync, existsSync, readFileSync } from "node:fs";
-import { resolve, join } from "node:path";
-import { homedir } from "node:os";
-import type { PermissionDecision, SecurityPolicy } from "./policy.js";
-import { parseBashPattern, parseToolPattern, globToRegex, fileGlobToRegex } from "./policy.js";
-
-/**
- * Load permission patterns from .pi/settings.json in the given directory.
- * Returns a SecurityPolicy merged with the provided policy.
- */
-export function evaluateCommand(
-  command: string,
-  policy: SecurityPolicy,
-): PermissionDecision {
-  // Deny takes highest precedence
-  for (const pattern of policy.deny) {
-    const bashGlob = parseBashPattern(pattern);
-    if (bashGlob && globToRegex(bashGlob, true).test(command)) return "deny";
-    const toolPattern = parseToolPattern(pattern);
-    if (toolPattern && toolPattern.tool === "Bash" && globToRegex(toolPattern.glob, true).test(command)) {
-      return "deny";
-    }
-  }
-
-  // Ask patterns
-  for (const pattern of policy.ask) {
-    const bashGlob = parseBashPattern(pattern);
-    if (bashGlob && globToRegex(bashGlob, true).test(command)) return "ask";
-    const toolPattern = parseToolPattern(pattern);
-    if (toolPattern && toolPattern.tool === "Bash" && globToRegex(toolPattern.glob, true).test(command)) {
-      return "ask";
-    }
-  }
-
-  // Allow patterns
-  for (const pattern of policy.allow) {
-    const bashGlob = parseBashPattern(pattern);
-    if (bashGlob && globToRegex(bashGlob, true).test(command)) return "allow";
-    const toolPattern = parseToolPattern(pattern);
-    if (toolPattern && toolPattern.tool === "Bash" && globToRegex(toolPattern.glob, true).test(command)) {
-      return "allow";
-    }
-  }
-
-  return "allow";
-}
-
-export function evaluateFilePath(
-  filePath: string,
-  policy: SecurityPolicy,
-  cwd: string = process.cwd(),
-): PermissionDecision {
-  const resolved = resolve(cwd, filePath);
-
-  // Prevent symlink escape
-  try {
-    const real = realpathSync(resolved);
-    const home = homedir();
-    if (!real.startsWith(cwd) && !real.startsWith(home)) {
-      return "deny";
-    }
-  } catch {
-    // File doesn't exist yet — check path pattern
-  }
-
-  for (const pattern of policy.deny) {
-    const toolPattern = parseToolPattern(pattern);
-    if (!toolPattern) continue;
-    if (["Read", "Edit", "Write", "read", "edit", "write"].includes(toolPattern.tool)) {
-      if (fileGlobToRegex(toolPattern.glob, true).test(resolved)) return "deny";
-    }
-  }
-
-  for (const pattern of policy.ask) {
-    const toolPattern = parseToolPattern(pattern);
-    if (!toolPattern) continue;
-    if (["Read", "Edit", "Write", "read", "edit", "write"].includes(toolPattern.tool)) {
-      if (fileGlobToRegex(toolPattern.glob, true).test(resolved)) return "ask";
-    }
-  }
-
-  return "allow";
-}

package/packages/compactor/src/security/policy.ts

@@ -1,96 +0,0 @@
-/**
- * Security policy — pattern parsing, glob-to-regex
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-export type PermissionDecision = "allow" | "deny" | "ask";
-
-export interface SecurityPolicy {
-  allow: string[];
-  deny: string[];
-  ask: string[];
-}
-
-export function parseBashPattern(pattern: string): string | null {
-  const match = pattern.match(/^Bash\((.+)\)$/);
-  return match ? match[1] : null;
-}
-
-export function parseToolPattern(pattern: string): { tool: string; glob: string } | null {
-  const match = pattern.match(/^(\w+)\((.+)\)$/);
-  return match ? { tool: match[1], glob: match[2] } : null;
-}
-
-function convertGlobPart(glob: string): string {
-  // Replace wildcards FIRST, then escape the literal remainder — escaping first
-  // would turn `*` into `\*` and the wildcard replace would never fire.
-  return glob
-    .split("*")
-    .map((part) => RegExp.escape(part))
-    .join(".*");
-}
-
-export function globToRegex(glob: string, caseInsensitive: boolean = false): RegExp {
-  let regexStr: string;
-  const colonIdx = glob.indexOf(":");
-  if (colonIdx !== -1) {
-    const command = glob.slice(0, colonIdx);
-    const argsGlob = glob.slice(colonIdx + 1);
-    const escapedCmd = RegExp.escape(command);
-    const argsRegex = convertGlobPart(argsGlob);
-    regexStr = `^${escapedCmd}(\\s${argsRegex})?$`;
-  } else {
-    regexStr = `^${convertGlobPart(glob)}$`;
-  }
-  return new RegExp(regexStr, caseInsensitive ? "i" : "");
-}
-
-export function fileGlobToRegex(glob: string, caseInsensitive: boolean = false): RegExp {
-  let regexStr = "";
-  let i = 0;
-
-  while (i < glob.length) {
-    if (glob[i] === "*" && glob[i + 1] === "*") {
-      if (i + 2 < glob.length && glob[i + 2] === "/") {
-        regexStr += "(.*/)?";
-        i += 3;
-      } else {
-        regexStr += ".*";
-        i += 2;
-      }
-    } else if (glob[i] === "*") {
-      regexStr += "[^/]*";
-      i++;
-    } else if (glob[i] === "?") {
-      regexStr += "[^/]";
-      i++;
-    } else {
-      regexStr += RegExp.escape(glob[i]);
-      i++;
-    }
-  }
-
-  return new RegExp(`^${regexStr}$`, caseInsensitive ? "i" : "");
-}
-
-/**
- * Create a minimal deny-only policy by reading .pi/settings.json in cwd.
- * Returns a SecurityPolicy with deny patterns populated (fail-open: returns empty on error).
- */
-export function readsOrCreatesPolicy(cwd: string): SecurityPolicy {
-  const settingsPath = join(cwd, ".pi", "settings.json");
-  if (!existsSync(settingsPath)) return { allow: [], deny: [], ask: [] };
-  try {
-    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    const permissions = settings.permissions ?? settings.security ?? {};
-    return {
-      deny: [...(permissions.deny ?? [])],
-      ask: [...(permissions.ask ?? [])],
-      allow: [...(permissions.allow ?? [])],
-    };
-  } catch {
-    return { allow: [], deny: [], ask: [] };
-  }
-}