pi-command-guardian 0.2.0 → 0.3.0

package/src/index.ts

@@ -0,0 +1,70 @@
+import { tmpdir } from "node:os";
+import type { ExtensionAPI, ToolCallEvent } from "@earendil-works/pi-coding-agent";
+import { parseShellCommand } from "./command-parser.js";
+import type { ShellParseResult } from "./command-parser.js";
+import { assessDeletionCommand } from "./deletion-guard.js";
+
+const EXPLICIT_DELETION_PATTERN = /\b(?:rm|rmdir|unlink|del|erase|Remove-Item|mkfs(?:\.[A-Za-z0-9_-]+)?|wipefs|diskpart|DROP\s+(?:DATABASE|TABLE)|TRUNCATE)\b|\bdd\b[^\r\n]*\bof=(?:\/dev\/|\\\\\.\\PhysicalDrive)/i;
+const MANUAL_REVIEW_GUIDANCE = "请审阅操作和目标后，自行决定是否手动删除。";
+const STATIC_TARGET_GUIDANCE = "请先确定所有实际删除目标，再将命令简化为语法完整、直接包含静态目标的 Bash 删除命令后重新提交。";
+
+/** Extension 入口的可替换副作用。 */
+export interface CommandGuardianDependencies {
+  parseCommand?: (command: string) => Promise<ShellParseResult>;
+  tempDirectory?: string;
+}
+
+function invalidInputReason(code: string): string {
+  return `Command Guardian 阻止了本次操作，操作尚未执行：${code}`;
+}
+
+/** 创建只审查显式破坏性 Bash 命令的 Pi Extension。 */
+export function createCommandGuardianExtension(
+  dependencies: CommandGuardianDependencies = {},
+): (pi: ExtensionAPI) => void {
+  const parseCommand = dependencies.parseCommand ?? parseShellCommand;
+  const tempDirectory = dependencies.tempDirectory ?? tmpdir();
+
+  return (pi: ExtensionAPI): void => {
+    pi.on("tool_call", async (event: ToolCallEvent, ctx) => {
+      if (event.toolName !== "bash") return undefined;
+      const input = event.input as { command?: unknown };
+      if (typeof input.command !== "string" || input.command.trim().length === 0) {
+        return { block: true, reason: invalidInputReason("PCG_INVALID_BASH_INPUT") };
+      }
+
+      try {
+        const parsed = await parseCommand(input.command);
+        if (parsed.status !== "parsed") {
+          return EXPLICIT_DELETION_PATTERN.test(input.command)
+            ? {
+                block: true,
+                reason: `Command Guardian 阻止了本次删除操作，操作尚未执行：命令结构无法可靠确定。${STATIC_TARGET_GUIDANCE}`,
+              }
+            : undefined;
+        }
+
+        const result = await assessDeletionCommand(parsed, ctx.cwd, tempDirectory);
+        if (result.decision === "allow") return undefined;
+        if (result.decision === "forbidden") {
+          return {
+            block: true,
+            reason: `Command Guardian 永久阻止了本次操作，操作尚未执行：${result.reason}。该判断无法由模型重试覆盖。`,
+          };
+        }
+        const guidance = result.guidance === "static-target"
+          ? STATIC_TARGET_GUIDANCE
+          : MANUAL_REVIEW_GUIDANCE;
+        return {
+          block: true,
+          reason: `Command Guardian 阻止了本次删除操作，操作尚未执行：${result.reason}。${guidance}`,
+        };
+      } catch {
+        return { block: true, reason: invalidInputReason("PCG_INTERNAL_ERROR") };
+      }
+    });
+  };
+}
+
+/** Pi package 加载入口。 */
+export default createCommandGuardianExtension();

package/dist/command-parser.d.ts

@@ -1,43 +0,0 @@
-import type * as TreeSitterTypes from "@vscode/tree-sitter-wasm";
-/** 与 Tree-sitter 生命周期解耦的 Bash 语法节点。 */
-export interface ShellSyntaxNode {
-    type: string;
-    named: boolean;
-    startByte: number;
-    endByte: number;
-    field?: string;
-    value?: string;
-    children: ShellSyntaxNode[];
-}
-/** Bash 语法错误或缺失节点的位置。 */
-export interface ShellSyntaxIssue {
-    type: string;
-    missing: boolean;
-    startByte: number;
-    endByte: number;
-}
-/** 成功解析的 Bash 命令。 */
-export interface ParsedShellCommand {
-    status: "parsed";
-    shell: "bash";
-    source: string;
-    root: ShellSyntaxNode;
-}
-/** 无法可靠解析的 Bash 命令。 */
-export interface UnparsedShellCommand {
-    status: "unparsed";
-    shell: "bash";
-    source: string;
-    reason: "empty_command" | "syntax_error" | "parser_unavailable" | "parse_failure";
-    issues: ShellSyntaxIssue[];
-}
-/** Bash 解析结果。 */
-export type ShellParseResult = ParsedShellCommand | UnparsedShellCommand;
-type ShellParser = Pick<TreeSitterTypes.Parser, "reset" | "parse">;
-/** Bash Parser 加载边界，只暴露当前解析流程需要的方法。 */
-export type ShellParserLoader = () => Promise<ShellParser>;
-/** 创建具有独立初始化缓存和串行队列的 Shell 命令解析函数。 */
-export declare function createShellCommandParser(loadParser: ShellParserLoader): (source: string) => Promise<ShellParseResult>;
-/** 使用进程内共享的 Tree-sitter Bash Parser 解析命令。 */
-export declare const parseShellCommand: (source: string) => Promise<ShellParseResult>;
-export {};

package/dist/command-parser.js

@@ -1,109 +0,0 @@
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const TreeSitter = require("@vscode/tree-sitter-wasm");
-const runtimePath = require.resolve("@vscode/tree-sitter-wasm/wasm/tree-sitter.wasm");
-const bashGrammarPath = require.resolve("@vscode/tree-sitter-wasm/wasm/tree-sitter-bash.wasm");
-async function loadBashParser() {
-    await TreeSitter.Parser.init({ locateFile: () => runtimePath });
-    const language = await TreeSitter.Language.load(bashGrammarPath);
-    return new TreeSitter.Parser().setLanguage(language);
-}
-function unparsed(source, reason, issues = []) {
-    return { status: "unparsed", shell: "bash", source, reason, issues };
-}
-function copySyntaxNode(node, field) {
-    const children = [];
-    for (let index = 0; index < node.childCount; index += 1) {
-        const child = node.child(index);
-        if (child === null) {
-            continue;
-        }
-        const childField = node.fieldNameForChild(index) ?? undefined;
-        children.push(copySyntaxNode(child, childField));
-    }
-    const copied = {
-        type: node.type,
-        named: node.isNamed,
-        startByte: node.startIndex,
-        endByte: node.endIndex,
-        children,
-    };
-    if (field !== undefined) {
-        copied.field = field;
-    }
-    if (children.length === 0) {
-        copied.value = node.text;
-    }
-    return copied;
-}
-function collectSyntaxIssues(node, issues) {
-    if (node.isError || node.isMissing) {
-        issues.push({
-            type: node.isError ? "ERROR" : node.type,
-            missing: node.isMissing,
-            startByte: node.startIndex,
-            endByte: node.endIndex,
-        });
-    }
-    for (const child of node.children) {
-        if (child !== null) {
-            collectSyntaxIssues(child, issues);
-        }
-    }
-}
-async function parseWith(source, getParser) {
-    let parser;
-    try {
-        parser = await getParser();
-    }
-    catch {
-        return unparsed(source, "parser_unavailable");
-    }
-    let tree;
-    try {
-        parser.reset();
-        tree = parser.parse(source);
-    }
-    catch {
-        return unparsed(source, "parse_failure");
-    }
-    if (tree === null) {
-        return unparsed(source, "parse_failure");
-    }
-    try {
-        const root = tree.rootNode;
-        if (root.hasError) {
-            const issues = [];
-            collectSyntaxIssues(root, issues);
-            return unparsed(source, "syntax_error", issues);
-        }
-        return {
-            status: "parsed",
-            shell: "bash",
-            source,
-            root: copySyntaxNode(root),
-        };
-    }
-    finally {
-        tree.delete();
-    }
-}
-/** 创建具有独立初始化缓存和串行队列的 Shell 命令解析函数。 */
-export function createShellCommandParser(loadParser) {
-    let parserPromise;
-    let parseQueue = Promise.resolve();
-    const getParser = () => {
-        parserPromise ??= loadParser();
-        return parserPromise;
-    };
-    return (source) => {
-        if (typeof source !== "string" || source.trim().length === 0) {
-            return Promise.resolve(unparsed(source, "empty_command"));
-        }
-        const result = parseQueue.then(() => parseWith(source, getParser));
-        parseQueue = result.then(() => undefined, () => undefined);
-        return result;
-    };
-}
-/** 使用进程内共享的 Tree-sitter Bash Parser 解析命令。 */
-export const parseShellCommand = createShellCommandParser(loadBashParser);

package/dist/deletion-guard.d.ts

@@ -1,16 +0,0 @@
-import type { ShellParseResult } from "./command-parser.js";
-/** 显式删除命令的本地判断。 */
-export type DeletionDecision = {
-    decision: "allow";
-} | {
-    decision: "block";
-    reason: string;
-    guidance: "static-target" | "manual-review";
-} | {
-    decision: "forbidden";
-    reason: string;
-};
-/** 判断已解析命令中的显式文件、数据库和磁盘破坏操作。 */
-export declare function assessDeletionCommand(parsed: Extract<ShellParseResult, {
-    status: "parsed";
-}>, cwd: string, tempDirectory: string): Promise<DeletionDecision>;

package/dist/deletion-guard.js

@@ -1,414 +0,0 @@
-import { homedir } from "node:os";
-import { basename, isAbsolute, parse, relative, resolve, sep } from "node:path";
-import { parseShellCommand } from "./command-parser.js";
-const ALLOW = { decision: "allow" };
-const BLOCK_EXTERNAL = {
-    decision: "block",
-    reason: "删除目标位于工作区和系统临时目录之外或是受控目录根",
-    guidance: "manual-review",
-};
-const BLOCK_DYNAMIC = {
-    decision: "block",
-    reason: "删除目标包含动态内容，无法静态确定",
-    guidance: "static-target",
-};
-const BLOCK_INDETERMINATE = {
-    decision: "block",
-    reason: "删除目标为空、缺失或无法静态确定",
-    guidance: "static-target",
-};
-const BLOCK_NESTED_DEPTH = {
-    decision: "block",
-    reason: "嵌套 Shell 层级超过静态分析上限",
-    guidance: "static-target",
-};
-const FORBIDDEN_SYSTEM = {
-    decision: "forbidden",
-    reason: "操作会删除系统关键目录、用户目录或数据库数据目录",
-};
-const FORBIDDEN_DISK = {
-    decision: "forbidden",
-    reason: "操作会格式化、擦除或覆盖磁盘设备",
-};
-const BLOCK_DATABASE = {
-    decision: "block",
-    reason: "操作包含显式数据库删除",
-    guidance: "manual-review",
-};
-const BLOCK_XARGS = {
-    decision: "block",
-    reason: "删除目标来自 xargs 输入，无法静态确定",
-    guidance: "static-target",
-};
-const BLOCK_POWERSHELL = {
-    decision: "block",
-    reason: "PowerShell 删除目标无法由 Bash 解析器静态确定",
-    guidance: "static-target",
-};
-const ENV_OPTIONS_WITH_VALUES = new Set([
-    "-a", "--argv0", "-C", "--chdir", "-S", "--split-string", "-u", "--unset",
-]);
-const SUDO_OPTIONS_WITH_VALUES = new Set([
-    "-a", "--auth-type", "-C", "--close-from", "-D", "--chdir", "-g", "--group",
-    "-h", "--host", "-p", "--prompt", "-R", "--chroot", "-r", "--role", "-t", "--type",
-    "-T", "--command-timeout", "-u", "--user",
-]);
-function normalizeExecutable(value) {
-    return basename(value.replaceAll("\\", "/")).replace(/\.exe$/i, "").toLowerCase();
-}
-function containsBraceExpansion(value) {
-    return /\{[^{}]*(?:,|\.\.)[^{}]*\}/.test(value);
-}
-function staticText(node) {
-    if (["simple_expansion", "expansion", "command_substitution", "process_substitution"].includes(node.type)) {
-        return { value: "", dynamic: true };
-    }
-    if (node.children.length === 0) {
-        const value = node.value ?? "";
-        if (node.type === "raw_string" && value.length >= 2) {
-            return { value: value.slice(1, -1), dynamic: false };
-        }
-        if ((node.type === "\"" || node.type === "'") && (value === "\"" || value === "'")) {
-            return { value: "", dynamic: false };
-        }
-        return { value, dynamic: node.type === "word" && value.startsWith("~") };
-    }
-    let value = "";
-    let dynamic = false;
-    for (const child of node.children) {
-        const part = staticText(child);
-        value += part.value;
-        dynamic ||= part.dynamic;
-    }
-    if (node.type === "concatenation" && containsBraceExpansion(value)) {
-        dynamic = true;
-    }
-    return { value, dynamic };
-}
-function commandFromArguments(args) {
-    const [executable, ...commandArgs] = args;
-    if (executable === undefined || executable.dynamic || executable.value.length === 0) {
-        return undefined;
-    }
-    return {
-        executable: normalizeExecutable(executable.value),
-        args: commandArgs,
-    };
-}
-function unwrapCommandBuiltin(command) {
-    let index = 0;
-    while (index < command.args.length) {
-        const argument = command.args[index];
-        if (argument === undefined)
-            break;
-        if (argument.dynamic)
-            return undefined;
-        if (argument.value === "--") {
-            index += 1;
-            break;
-        }
-        if (/^-[^-]*[vV]/.test(argument.value))
-            return undefined;
-        if (argument.value === "-p") {
-            index += 1;
-            continue;
-        }
-        if (argument.value.startsWith("-"))
-            return undefined;
-        break;
-    }
-    return commandFromArguments(command.args.slice(index));
-}
-function unwrapEnv(command) {
-    let index = 0;
-    while (index < command.args.length) {
-        const argument = command.args[index];
-        if (argument === undefined)
-            break;
-        if (argument.dynamic)
-            return undefined;
-        const value = argument.value;
-        if (value === "--") {
-            index += 1;
-            break;
-        }
-        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(value)) {
-            index += 1;
-            continue;
-        }
-        if (ENV_OPTIONS_WITH_VALUES.has(value)) {
-            index += 2;
-            continue;
-        }
-        if (/^(?:--(?:argv0|chdir|split-string|unset)=|-[aCSu].+)/.test(value) || ["-0", "--debug", "-i", "--ignore-environment", "--null"].includes(value)) {
-            index += 1;
-            continue;
-        }
-        if (value.startsWith("-"))
-            return undefined;
-        break;
-    }
-    return commandFromArguments(command.args.slice(index));
-}
-function unwrapSudo(command) {
-    let index = 0;
-    while (index < command.args.length) {
-        const argument = command.args[index];
-        if (argument === undefined)
-            break;
-        if (argument.dynamic)
-            return undefined;
-        const value = argument.value;
-        if (value === "--") {
-            index += 1;
-            break;
-        }
-        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(value)) {
-            index += 1;
-            continue;
-        }
-        if (SUDO_OPTIONS_WITH_VALUES.has(value)) {
-            index += 2;
-            continue;
-        }
-        if (/^--[^=]+=/.test(value) || /^-[aCDghpRrtTu].+/.test(value)) {
-            index += 1;
-            continue;
-        }
-        if (value.startsWith("-")) {
-            index += 1;
-            continue;
-        }
-        break;
-    }
-    return commandFromArguments(command.args.slice(index));
-}
-function unwrapTransparentCommand(command) {
-    let current = command;
-    while (true) {
-        let unwrapped;
-        switch (current.executable) {
-            case "command":
-                unwrapped = unwrapCommandBuiltin(current);
-                break;
-            case "env":
-                unwrapped = unwrapEnv(current);
-                break;
-            case "sudo":
-                unwrapped = unwrapSudo(current);
-                break;
-            default:
-                return current;
-        }
-        if (unwrapped === undefined)
-            return current;
-        current = unwrapped;
-    }
-}
-function extractCommands(root) {
-    const commands = [];
-    const visit = (node) => {
-        if (node.type === "command") {
-            const nameNode = node.children.find((child) => child.field === "name");
-            if (nameNode !== undefined) {
-                const name = staticText(nameNode);
-                if (name.value.length > 0) {
-                    commands.push({
-                        executable: normalizeExecutable(name.value),
-                        args: node.children
-                            .filter((child) => child.field === "argument")
-                            .map(staticText),
-                    });
-                }
-            }
-        }
-        node.children.forEach(visit);
-    };
-    visit(root);
-    return commands;
-}
-function strictDescendant(root, target) {
-    const child = relative(resolve(root), resolve(target));
-    return child.length > 0 && child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
-}
-function sameOrDescendant(root, target) {
-    return resolve(root) === resolve(target) || strictDescendant(root, target);
-}
-function systemRoots() {
-    const roots = [homedir()];
-    if (process.platform === "win32") {
-        for (const value of [process.env.SystemRoot, process.env.ProgramFiles, process.env.ProgramData]) {
-            if (value !== undefined && value.length > 0)
-                roots.push(value);
-        }
-    }
-    else {
-        roots.push("/etc", "/usr", "/var", "/boot", "/bin", "/sbin", "/lib", "/lib64");
-    }
-    return roots;
-}
-function isDatabaseDataTarget(rawTarget, target) {
-    const normalized = rawTarget.replaceAll("\\", "/").toLowerCase();
-    if (/^\/(?:var\/lib\/(?:postgresql|mysql|mongodb)|var\/opt\/mssql)(?:\/|$)/.test(normalized)) {
-        return true;
-    }
-    return process.platform === "win32" && /\/(?:postgresql|mysql|mongodb|mssql)(?:\/|$)/i.test(target.replaceAll("\\", "/"));
-}
-function classifyTarget(rawTarget, cwd, tempDirectory) {
-    if (rawTarget.dynamic)
-        return BLOCK_DYNAMIC;
-    if (rawTarget.value.length === 0)
-        return BLOCK_INDETERMINATE;
-    const target = resolve(cwd, rawTarget.value);
-    if (target === parse(target).root)
-        return FORBIDDEN_SYSTEM;
-    if (isDatabaseDataTarget(rawTarget.value, target))
-        return FORBIDDEN_SYSTEM;
-    if (strictDescendant(cwd, target) || strictDescendant(tempDirectory, target))
-        return ALLOW;
-    if (systemRoots().some((root) => sameOrDescendant(root, target)))
-        return FORBIDDEN_SYSTEM;
-    return BLOCK_EXTERNAL;
-}
-function deletionOperands(args) {
-    const operands = [];
-    let optionsEnded = false;
-    for (const argument of args) {
-        if (!optionsEnded && argument.value === "--") {
-            optionsEnded = true;
-        }
-        else if (optionsEnded || !argument.value.startsWith("-")) {
-            operands.push(argument);
-        }
-    }
-    return operands;
-}
-function combine(decisions) {
-    return decisions.find((item) => item.decision === "forbidden")
-        ?? decisions.find((item) => item.decision === "block" && item.guidance === "manual-review")
-        ?? decisions.find((item) => item.decision === "block")
-        ?? ALLOW;
-}
-function assessFileDeletion(command, cwd, tempDirectory) {
-    if (!["rm", "rmdir", "unlink", "del", "erase", "rd"].includes(command.executable))
-        return undefined;
-    const targets = deletionOperands(command.args);
-    if (targets.length === 0)
-        return BLOCK_INDETERMINATE;
-    return combine(targets.map((target) => classifyTarget(target, cwd, tempDirectory)));
-}
-function findDeletionRoots(command) {
-    const deletesMatches = command.args.some((argument) => argument.value === "-delete");
-    const callbackIndex = command.args.findIndex((argument) => ["-exec", "-execdir", "-ok", "-okdir"].includes(argument.value));
-    const callback = callbackIndex < 0
-        ? undefined
-        : commandFromArguments(command.args.slice(callbackIndex + 1));
-    const callbackExecutable = callback === undefined
-        ? undefined
-        : unwrapTransparentCommand(callback).executable;
-    const deletesThroughCallback = callbackExecutable !== undefined &&
-        ["rm", "rmdir", "unlink"].includes(callbackExecutable);
-    if (!deletesMatches && !deletesThroughCallback)
-        return undefined;
-    const expressionIndex = command.args.findIndex((argument) => argument.value.startsWith("-") || ["!", "("].includes(argument.value));
-    const roots = command.args.slice(0, expressionIndex < 0 ? command.args.length : expressionIndex);
-    return roots.length === 0 ? [{ value: ".", dynamic: false }] : roots;
-}
-function assessFindDeletion(command, cwd, tempDirectory) {
-    if (command.executable !== "find")
-        return undefined;
-    const roots = findDeletionRoots(command);
-    return roots === undefined
-        ? undefined
-        : combine(roots.map((target) => classifyTarget(target, cwd, tempDirectory)));
-}
-function rawDevice(value) {
-    return /^\/dev\/(?:sd[a-z]|hd[a-z]|vd[a-z]|xvd[a-z]|nvme\d+n\d+|mmcblk\d+|disk\d+|rdisk\d+)(?:p?\d+)?$/i.test(value) ||
-        /^\\\\\.\\PhysicalDrive\d+$/i.test(value);
-}
-function assessRawDeviceRedirects(root) {
-    let destructive = false;
-    const visit = (node) => {
-        if (node.type === "file_redirect") {
-            const operator = node.children.find((child) => child.field === undefined)?.value ?? "";
-            const targets = node.children
-                .filter((child) => child.field === "destination")
-                .map(staticText);
-            if (/^(?:>|>>|>\||&>|&>>)$/.test(operator) && targets.some((target) => !target.dynamic && rawDevice(target.value))) {
-                destructive = true;
-            }
-        }
-        node.children.forEach(visit);
-    };
-    visit(root);
-    return destructive ? FORBIDDEN_DISK : undefined;
-}
-function assessFixedDestructiveCommand(command) {
-    const joined = command.args.map((argument) => argument.value).join(" ");
-    if (/^mkfs(?:\.|$)/.test(command.executable))
-        return FORBIDDEN_DISK;
-    if (command.executable === "wipefs" && /(?:^|\s)(?:-a|--all)(?:\s|$)/.test(joined))
-        return FORBIDDEN_DISK;
-    if (command.executable === "dd" && command.args.some((argument) => {
-        const output = argument.value.match(/^of=(.+)$/i)?.[1];
-        return output !== undefined && rawDevice(output);
-    })) {
-        return FORBIDDEN_DISK;
-    }
-    if (command.executable === "parted" && /(?:^|\s)(?:mklabel|mkpart|rm|resizepart)(?:\s|$)/i.test(joined))
-        return FORBIDDEN_DISK;
-    if (["fdisk", "sfdisk", "cfdisk"].includes(command.executable) && /(?:^|\s)(?:--delete|-d)(?:\s|$)/i.test(joined))
-        return FORBIDDEN_DISK;
-    if (command.executable === "diskpart" && /(?:^|\s)clean(?:\s|$)/i.test(joined))
-        return FORBIDDEN_DISK;
-    if (command.executable === "format" && command.args.some((argument) => /^[A-Za-z]:$/.test(argument.value)))
-        return FORBIDDEN_DISK;
-    if (["psql", "mysql", "mariadb", "sqlcmd"].includes(command.executable) && /\b(?:DROP\s+(?:DATABASE|TABLE)|TRUNCATE(?:\s+TABLE)?)\b/i.test(joined)) {
-        return BLOCK_DATABASE;
-    }
-    if (command.executable === "xargs" && command.args.some((argument) => ["rm", "rmdir", "unlink"].includes(normalizeExecutable(argument.value)))) {
-        return BLOCK_XARGS;
-    }
-    if (["powershell", "pwsh"].includes(command.executable) && /\bRemove-Item\b/i.test(joined))
-        return BLOCK_POWERSHELL;
-    return undefined;
-}
-async function assessNestedShell(command, cwd, tempDirectory, depth) {
-    if (!["bash", "sh", "dash", "zsh"].includes(command.executable))
-        return undefined;
-    const codeIndex = command.args.findIndex((argument) => argument.value === "-c");
-    const code = codeIndex < 0 ? undefined : command.args[codeIndex + 1];
-    if (code === undefined)
-        return undefined;
-    if (code.dynamic)
-        return BLOCK_DYNAMIC;
-    if (code.value.length === 0)
-        return BLOCK_INDETERMINATE;
-    if (depth >= 8)
-        return BLOCK_NESTED_DEPTH;
-    const nested = await parseShellCommand(code.value);
-    if (nested.status !== "parsed")
-        return BLOCK_INDETERMINATE;
-    return assessParsed(nested, cwd, tempDirectory, depth + 1);
-}
-async function assessParsed(parsed, cwd, tempDirectory, depth) {
-    const decisions = [];
-    const redirectDecision = assessRawDeviceRedirects(parsed.root);
-    if (redirectDecision !== undefined)
-        decisions.push(redirectDecision);
-    for (const extractedCommand of extractCommands(parsed.root)) {
-        const command = unwrapTransparentCommand(extractedCommand);
-        const nested = await assessNestedShell(command, cwd, tempDirectory, depth);
-        const decision = nested
-            ?? assessFileDeletion(command, cwd, tempDirectory)
-            ?? assessFindDeletion(command, cwd, tempDirectory)
-            ?? assessFixedDestructiveCommand(command);
-        if (decision !== undefined)
-            decisions.push(decision);
-    }
-    return combine(decisions);
-}
-/** 判断已解析命令中的显式文件、数据库和磁盘破坏操作。 */
-export function assessDeletionCommand(parsed, cwd, tempDirectory) {
-    return assessParsed(parsed, cwd, tempDirectory, 0);
-}

package/dist/index.d.ts

@@ -1,12 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { ShellParseResult } from "./command-parser.js";
-/** Extension 入口的可替换副作用。 */
-export interface CommandGuardianDependencies {
-    parseCommand?: (command: string) => Promise<ShellParseResult>;
-    tempDirectory?: string;
-}
-/** 创建只审查显式破坏性 Bash 命令的 Pi Extension。 */
-export declare function createCommandGuardianExtension(dependencies?: CommandGuardianDependencies): (pi: ExtensionAPI) => void;
-/** Pi package 加载入口。 */
-declare const _default: (pi: ExtensionAPI) => void;
-export default _default;