@kylecheng3146/agent-ops 0.0.1

package/dist/runtime/src/fs/transaction.js

@@ -0,0 +1,498 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { lstat, readFile, realpath, stat } from "node:fs/promises";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { sha256 } from "./hash.js";
+import { AgentOpsError, resolveContainedPath } from "./paths.js";
+export { AgentOpsError } from "./paths.js";
+const MUTATION_WORKER_PATH = fileURLToPath(new URL("./mutation-worker.js", import.meta.url));
+function isMissing(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function normalizedPath(path) {
+    return process.platform === "win32" ? path.toLowerCase() : path;
+}
+async function captureParentGuard(parent) {
+    const [canonicalPath, status] = await Promise.all([
+        realpath(parent),
+        stat(parent, { bigint: true })
+    ]);
+    if (!status.isDirectory() ||
+        normalizedPath(canonicalPath) !== normalizedPath(parent)) {
+        throw new AgentOpsError("PRECONDITION_CHANGED", `Destination directory changed before mutation: ${parent}`);
+    }
+    return {
+        expectedParentPath: canonicalPath,
+        parentDevice: status.dev.toString(),
+        parentInode: status.ino.toString()
+    };
+}
+async function runAnchoredMutation(targetPath, action, expectedHash, content, mode) {
+    const parent = dirname(targetPath);
+    const guard = await captureParentGuard(parent);
+    const request = {
+        action,
+        targetName: basename(targetPath),
+        expectedHash,
+        ...guard,
+        ...(mode === undefined ? {} : { mode })
+    };
+    const encodedRequest = Buffer.from(JSON.stringify(request), "utf8").toString("base64url");
+    await new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(process.execPath, [MUTATION_WORKER_PATH, encodedRequest], {
+            cwd: parent,
+            shell: false,
+            stdio: ["pipe", "ignore", "pipe"]
+        });
+        let standardError = "";
+        let settled = false;
+        const rejectOnce = (error) => {
+            if (!settled) {
+                settled = true;
+                rejectPromise(error);
+            }
+        };
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            if (standardError.length < 4096) {
+                standardError += chunk.slice(0, 4096 - standardError.length);
+            }
+        });
+        child.once("error", (error) => {
+            const code = typeof error === "object" &&
+                error !== null &&
+                "code" in error &&
+                ["ENOENT", "ENOTDIR"].includes(String(error.code))
+                ? "PRECONDITION_CHANGED"
+                : "ANCHORED_MUTATION_FAILED";
+            rejectOnce(new AgentOpsError(code, "Unable to start an anchored file mutation.", {
+                cause: error
+            }));
+        });
+        child.once("close", (exitCode) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (exitCode === 0) {
+                resolvePromise();
+                return;
+            }
+            const preconditionChanged = exitCode === 10 ||
+                standardError.trim() === "PRECONDITION_CHANGED";
+            rejectPromise(new AgentOpsError(preconditionChanged
+                ? "PRECONDITION_CHANGED"
+                : "ANCHORED_MUTATION_FAILED", preconditionChanged
+                ? "The target changed before anchored mutation."
+                : "The anchored file mutation failed."));
+        });
+        child.stdin.on("error", () => undefined);
+        child.stdin.end(action === "write" ? content : undefined);
+    });
+}
+async function atomicWrite(targetPath, content, mode, expectedHash) {
+    await runAnchoredMutation(targetPath, "write", expectedHash, content, mode);
+}
+async function atomicRemove(targetPath, expectedHash) {
+    await runAnchoredMutation(targetPath, "remove", expectedHash);
+}
+async function atomicMakeDirectory(targetPath, mode) {
+    await runAnchoredMutation(targetPath, "mkdir", null, undefined, mode);
+}
+async function atomicRemoveDirectory(targetPath) {
+    await runAnchoredMutation(targetPath, "rmdir", null);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+    const allowedKeys = new Set(allowed);
+    return Object.keys(value).every((key) => allowedKeys.has(key));
+}
+function isExpectedHash(value) {
+    return (value === null ||
+        (typeof value === "string" && /^[a-f0-9]{64}$/.test(value)));
+}
+function assertTransactionPlan(plan) {
+    if (!isRecord(plan) ||
+        !hasOnlyKeys(plan, ["operations"]) ||
+        !Array.isArray(plan.operations)) {
+        throw new AgentOpsError("INVALID_TRANSACTION_PLAN", "Transaction plan must contain only an operations array.");
+    }
+    for (let index = 0; index < plan.operations.length; index += 1) {
+        if (!Object.hasOwn(plan.operations, index)) {
+            throw new AgentOpsError("INVALID_TRANSACTION_PLAN", "Transaction operations must be a dense array.");
+        }
+        const operation = plan.operations[index];
+        if (!isRecord(operation) ||
+            typeof operation.path !== "string" ||
+            !isExpectedHash(operation.expectedHash)) {
+            throw new AgentOpsError("INVALID_TRANSACTION_PLAN", `Invalid transaction operation at index ${index}.`);
+        }
+        if (operation.kind === "write") {
+            if (typeof operation.content !== "string" ||
+                !hasOnlyKeys(operation, ["kind", "path", "content", "expectedHash"])) {
+                throw new AgentOpsError("INVALID_TRANSACTION_PLAN", `Invalid write operation at index ${index}.`);
+            }
+            continue;
+        }
+        if (operation.kind !== "remove" ||
+            !hasOnlyKeys(operation, ["kind", "path", "expectedHash"])) {
+            throw new AgentOpsError("INVALID_TRANSACTION_PLAN", `Invalid remove operation at index ${index}.`);
+        }
+    }
+}
+async function createRecoveryDirectory(root) {
+    const recoveryDirectory = join(root, `.agent-ops-backup-${randomUUID()}`);
+    await atomicMakeDirectory(recoveryDirectory, 0o700);
+    return recoveryDirectory;
+}
+async function createBackup(snapshot, recoveryDirectory) {
+    if (!snapshot.existed || snapshot.content === null) {
+        return null;
+    }
+    const backupPath = join(recoveryDirectory, `${basename(snapshot.targetPath)}-${randomUUID()}`);
+    await atomicWrite(backupPath, snapshot.content, 0o600, null);
+    return backupPath;
+}
+async function snapshotOperation(root, operation) {
+    const targetPath = await resolveContainedPath(root, operation.path);
+    try {
+        const status = await lstat(targetPath);
+        if (!status.isFile()) {
+            throw new AgentOpsError("UNSUPPORTED_FILE_TYPE", `Managed target must be a regular file: ${operation.path}`);
+        }
+        const content = await readFile(targetPath);
+        return {
+            operation,
+            targetPath,
+            existed: true,
+            content,
+            mode: status.mode & 0o777,
+            actualHash: sha256(content),
+            device: status.dev.toString(),
+            inode: status.ino.toString(),
+            backupPath: null,
+            createdDirectories: []
+        };
+    }
+    catch (error) {
+        if (!isMissing(error)) {
+            throw error;
+        }
+        return {
+            operation,
+            targetPath,
+            existed: false,
+            content: null,
+            mode: 0o600,
+            actualHash: null,
+            device: null,
+            inode: null,
+            backupPath: null,
+            createdDirectories: []
+        };
+    }
+}
+async function currentHash(path) {
+    try {
+        const status = await lstat(path);
+        if (!status.isFile()) {
+            throw new AgentOpsError("PRECONDITION_CHANGED", `A managed path is no longer a regular file: ${path}`);
+        }
+        return sha256(await readFile(path));
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function currentIdentity(path) {
+    try {
+        const status = await lstat(path, { bigint: true });
+        if (!status.isFile() || status.isSymbolicLink()) {
+            throw new AgentOpsError("PRECONDITION_CHANGED", `A managed path is no longer a regular file: ${path}`);
+        }
+        return {
+            device: status.dev.toString(),
+            inode: status.ino.toString()
+        };
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+async function assertSnapshotIdentity(snapshot, path) {
+    if (!snapshot.existed) {
+        return;
+    }
+    const identity = await currentIdentity(path);
+    if (identity === null ||
+        identity.device !== snapshot.device ||
+        identity.inode !== snapshot.inode) {
+        throw new AgentOpsError("PRECONDITION_CHANGED", `Target identity changed for ${snapshot.operation.path}.`);
+    }
+}
+async function assertMutationBoundary(root, snapshot) {
+    try {
+        const resolved = await resolveContainedPath(root, snapshot.operation.path);
+        await assertSnapshotIdentity(snapshot, resolved);
+        if ((await currentHash(resolved)) !== snapshot.actualHash) {
+            throw new AgentOpsError("PRECONDITION_CHANGED", `Precondition changed for ${snapshot.operation.path}.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof AgentOpsError &&
+            error.code === "PRECONDITION_CHANGED") {
+            throw error;
+        }
+        throw new AgentOpsError("PRECONDITION_CHANGED", `Target safety changed for ${snapshot.operation.path}.`, { cause: error });
+    }
+}
+async function ensureParentDirectories(root, snapshot) {
+    const parent = dirname(snapshot.targetPath);
+    const fromRoot = relative(root, parent);
+    if (fromRoot === "" ||
+        fromRoot === ".." ||
+        fromRoot.startsWith(`..${sep}`)) {
+        return;
+    }
+    let current = root;
+    for (const segment of fromRoot.split(sep)) {
+        current = join(current, segment);
+        try {
+            const status = await lstat(current);
+            if (!status.isDirectory() || status.isSymbolicLink()) {
+                throw new AgentOpsError("PRECONDITION_CHANGED", `Managed parent is not a stable directory: ${snapshot.operation.path}`);
+            }
+        }
+        catch (error) {
+            if (!isMissing(error)) {
+                throw error;
+            }
+            try {
+                await atomicMakeDirectory(current, 0o700);
+                snapshot.createdDirectories.push(current);
+            }
+            catch (mkdirError) {
+                throw new AgentOpsError("PRECONDITION_CHANGED", `Managed parent changed while it was created: ${snapshot.operation.path}`, { cause: mkdirError });
+            }
+        }
+    }
+}
+function desiredHash(snapshot) {
+    return snapshot.operation.kind === "write"
+        ? sha256(snapshot.operation.content)
+        : null;
+}
+async function removeCreatedDirectories(snapshot) {
+    for (const directory of [...snapshot.createdDirectories].reverse()) {
+        await atomicRemoveDirectory(directory);
+    }
+}
+async function rollback(root, snapshots) {
+    for (const snapshot of [...snapshots].reverse()) {
+        const resolved = await resolveContainedPath(root, snapshot.operation.path);
+        const observedHash = await currentHash(resolved);
+        if (observedHash === snapshot.actualHash) {
+            await removeCreatedDirectories(snapshot);
+            continue;
+        }
+        if (observedHash !== desiredHash(snapshot)) {
+            throw new AgentOpsError("PRECONDITION_CHANGED", `Cannot overwrite a concurrent change during rollback: ${snapshot.operation.path}`);
+        }
+        if (snapshot.existed && snapshot.content !== null) {
+            await atomicWrite(resolved, snapshot.content, snapshot.mode, desiredHash(snapshot));
+        }
+        else {
+            const expectedHash = desiredHash(snapshot);
+            if (expectedHash === null) {
+                throw new AgentOpsError("PRECONDITION_CHANGED", `Rollback target disappeared before removal: ${snapshot.operation.path}`);
+            }
+            await atomicRemove(resolved, expectedHash);
+            await removeCreatedDirectories(snapshot);
+        }
+    }
+}
+async function removeRecoveryDirectory(recoveryDirectory, snapshots) {
+    if (recoveryDirectory === null) {
+        return;
+    }
+    const cleanupProbe = join(dirname(recoveryDirectory), `.agent-ops-cleanup-probe-${randomUUID()}`);
+    await atomicMakeDirectory(cleanupProbe, 0o700);
+    await atomicRemoveDirectory(cleanupProbe);
+    for (const snapshot of snapshots) {
+        if (snapshot.backupPath !== null && snapshot.actualHash !== null) {
+            await atomicRemove(snapshot.backupPath, snapshot.actualHash);
+        }
+    }
+    await atomicRemoveDirectory(recoveryDirectory);
+}
+async function recoveryPaths(snapshots) {
+    const retained = [];
+    for (const snapshot of snapshots) {
+        if (snapshot.backupPath === null) {
+            continue;
+        }
+        try {
+            const status = await lstat(snapshot.backupPath);
+            if (status.isFile() && !status.isSymbolicLink()) {
+                retained.push(snapshot.backupPath);
+            }
+        }
+        catch (error) {
+            if (!isMissing(error)) {
+                retained.push(snapshot.backupPath);
+            }
+        }
+    }
+    return retained;
+}
+async function cleanupPreparedDirectories(root, snapshot) {
+    if (snapshot.createdDirectories.length === 0) {
+        return;
+    }
+    try {
+        const resolved = await resolveContainedPath(root, snapshot.operation.path);
+        const identity = await currentIdentity(resolved);
+        const identityMatches = snapshot.existed
+            ? identity !== null &&
+                identity.device === snapshot.device &&
+                identity.inode === snapshot.inode
+            : identity === null;
+        if (identityMatches &&
+            (await currentHash(resolved)) === snapshot.actualHash) {
+            await removeCreatedDirectories(snapshot);
+        }
+    }
+    catch {
+        // A concurrent change owns the path now. Leaving empty directories is safer
+        // than deleting through a path whose identity can no longer be proven.
+    }
+}
+export class FileTransaction {
+    #root;
+    #options;
+    constructor(root, options = {}) {
+        this.#root = root;
+        this.#options = options;
+    }
+    async apply(plan, validate = async () => undefined) {
+        assertTransactionPlan(plan);
+        const root = await realpath(resolve(this.#root));
+        const snapshots = [];
+        const ownership = new Set();
+        for (const operation of plan.operations) {
+            const snapshot = await snapshotOperation(root, operation);
+            const ownershipKey = snapshot.targetPath.toLowerCase();
+            if (ownership.has(ownershipKey)) {
+                throw new AgentOpsError("DUPLICATE_OPERATION", `A transaction may manage a path only once: ${operation.path}`);
+            }
+            ownership.add(ownershipKey);
+            if (snapshot.actualHash !== operation.expectedHash) {
+                throw new AgentOpsError("PRECONDITION_CHANGED", `Precondition changed for ${operation.path}.`);
+            }
+            snapshots.push(snapshot);
+        }
+        const applied = [];
+        let recoveryDirectory = null;
+        try {
+            for (const [index, snapshot] of snapshots.entries()) {
+                const isNoOp = snapshot.operation.kind === "write"
+                    ? snapshot.actualHash === sha256(snapshot.operation.content)
+                    : !snapshot.existed;
+                if (isNoOp) {
+                    continue;
+                }
+                if (snapshot.existed && recoveryDirectory === null) {
+                    recoveryDirectory = await createRecoveryDirectory(root);
+                }
+                snapshot.backupPath =
+                    recoveryDirectory === null
+                        ? null
+                        : await createBackup(snapshot, recoveryDirectory);
+                await assertMutationBoundary(root, snapshot);
+                if (snapshot.operation.kind === "write") {
+                    await ensureParentDirectories(root, snapshot);
+                    await assertMutationBoundary(root, snapshot);
+                }
+                try {
+                    await this.#options.beforeReplace?.({
+                        index,
+                        targetPath: snapshot.targetPath,
+                        backupPath: snapshot.backupPath
+                    });
+                }
+                catch (error) {
+                    await cleanupPreparedDirectories(root, snapshot);
+                    throw error;
+                }
+                applied.push(snapshot);
+                try {
+                    if (snapshot.operation.kind === "write") {
+                        await atomicWrite(snapshot.targetPath, snapshot.operation.content, snapshot.existed ? snapshot.mode : 0o600, snapshot.actualHash);
+                    }
+                    else {
+                        if (snapshot.actualHash === null) {
+                            throw new AgentOpsError("PRECONDITION_CHANGED", `Remove target disappeared before mutation: ${snapshot.operation.path}`);
+                        }
+                        await atomicRemove(snapshot.targetPath, snapshot.actualHash);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof AgentOpsError &&
+                        error.code === "PRECONDITION_CHANGED") {
+                        applied.pop();
+                        await cleanupPreparedDirectories(root, snapshot);
+                    }
+                    throw error;
+                }
+            }
+            await validate();
+        }
+        catch (error) {
+            try {
+                await rollback(root, applied);
+            }
+            catch (rollbackError) {
+                const retainedRecoveryPaths = await recoveryPaths(snapshots);
+                throw new AgentOpsError("ROLLBACK_FAILED", "The transaction failed and rollback was incomplete.", {
+                    cause: rollbackError,
+                    recoveryPaths: retainedRecoveryPaths
+                });
+            }
+            try {
+                await removeRecoveryDirectory(recoveryDirectory, snapshots);
+            }
+            catch (cleanupError) {
+                throw new AgentOpsError("ROLLED_BACK_CLEANUP_FAILED", "The transaction was rolled back, but recovery cleanup failed.", {
+                    cause: cleanupError,
+                    recoveryPaths: await recoveryPaths(snapshots)
+                });
+            }
+            if (error instanceof AgentOpsError &&
+                error.code === "PRECONDITION_CHANGED") {
+                throw error;
+            }
+            throw new AgentOpsError("TRANSACTION_FAILED", "The transaction failed and all applied operations were rolled back.", { cause: error });
+        }
+        try {
+            await removeRecoveryDirectory(recoveryDirectory, snapshots);
+        }
+        catch (cleanupError) {
+            throw new AgentOpsError("COMMITTED_CLEANUP_FAILED", "The transaction committed, but recovery cleanup failed.", {
+                cause: cleanupError,
+                recoveryPaths: await recoveryPaths(snapshots)
+            });
+        }
+    }
+}

package/dist/runtime/src/guardrails/destructive.js

@@ -0,0 +1,207 @@
+import { GUARDRAIL_RULE_IDS } from "./types.js";
+const AMBIGUOUS_TARGET = /(?:^|[^\\])(?:\$\{?|\*|\?|\[)/;
+const PUSH_LONG_OPTIONS_WITH_VALUES = new Set([
+    "--exec",
+    "--push-option",
+    "--receive-pack",
+    "--recurse-submodules",
+    "--repo"
+]);
+const WINDOWS_ENVIRONMENT_TARGET = /%[^%\s]+%/;
+const TILDE_TARGET = /^~[A-Za-z0-9._-]*(?:[\\/]|$)/;
+const WINDOWS_ROOT = /^[A-Za-z]:\/?$/;
+function executableName(command) {
+    return command.split(/[\\/]/).at(-1)?.replace(/\.exe$/i, "").toLowerCase() ?? "";
+}
+function isShortFlag(argument, flag, caseInsensitive = false) {
+    const flags = argument.slice(1);
+    return (argument.startsWith("-") &&
+        !argument.startsWith("--") &&
+        (caseInsensitive
+            ? flags.toLowerCase().includes(flag.toLowerCase())
+            : flags.includes(flag)));
+}
+function hasAmbiguousExpansion(target) {
+    return (AMBIGUOUS_TARGET.test(target) ||
+        WINDOWS_ENVIRONMENT_TARGET.test(target) ||
+        TILDE_TARGET.test(target));
+}
+function normalizeTarget(target) {
+    if (target.length === 0) {
+        return target;
+    }
+    const portable = target.replace(/\\/g, "/");
+    const drive = /^([A-Za-z]:)(?:\/|$)/.exec(portable)?.[1];
+    const absolute = drive !== undefined || portable.startsWith("/");
+    const remainder = drive === undefined
+        ? portable.replace(/^\/+/, "")
+        : portable.slice(drive.length).replace(/^\/+/, "");
+    const segments = [];
+    for (const segment of remainder.split("/")) {
+        if (segment.length === 0 || segment === ".") {
+            continue;
+        }
+        if (segment === "..") {
+            if (segments.length > 0 && segments.at(-1) !== "..") {
+                segments.pop();
+            }
+            else if (!absolute) {
+                segments.push(segment);
+            }
+            continue;
+        }
+        segments.push(segment);
+    }
+    const normalized = segments.join("/");
+    if (drive !== undefined) {
+        return normalized.length === 0 ? `${drive}/` : `${drive}/${normalized}`;
+    }
+    if (absolute) {
+        return normalized.length === 0 ? "/" : `/${normalized}`;
+    }
+    return normalized.length === 0 ? "." : normalized;
+}
+function isBroadTarget(target) {
+    const normalized = normalizeTarget(target);
+    return (normalized === "/" ||
+        normalized === "." ||
+        normalized === ".." ||
+        normalized === "~" ||
+        WINDOWS_ROOT.test(normalized));
+}
+function removalDecision(command, args) {
+    const isRm = command === "rm";
+    const isPowerShellRemove = command === "remove-item";
+    const isWindowsRemove = command === "rd" || command === "rmdir";
+    if (!isRm && !isPowerShellRemove && !isWindowsRemove) {
+        return { action: "allow" };
+    }
+    const recursive = args.some((argument) => isRm
+        ? argument === "--recursive" || isShortFlag(argument, "r", true)
+        : isPowerShellRemove
+            ? argument.toLowerCase() === "-recurse"
+            : argument.toLowerCase() === "/s");
+    if (!recursive) {
+        return { action: "allow" };
+    }
+    const targets = args.filter((argument) => {
+        if (argument === "--") {
+            return false;
+        }
+        if (isWindowsRemove) {
+            return !argument.startsWith("/");
+        }
+        return !argument.startsWith("-");
+    });
+    if (targets.some(isBroadTarget)) {
+        return {
+            action: "block",
+            ruleId: GUARDRAIL_RULE_IDS.broadDelete,
+            reason: "Recursive deletion of a broad filesystem target is blocked.",
+            saferAlternative: "Delete an explicitly named project-relative path after reviewing its resolved value."
+        };
+    }
+    if (targets.some(hasAmbiguousExpansion)) {
+        return {
+            action: "warn",
+            ruleId: GUARDRAIL_RULE_IDS.ambiguousTarget,
+            reason: "The recursive deletion target contains unresolved environment or glob expansion."
+        };
+    }
+    return { action: "allow" };
+}
+function gitSubcommand(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index] ?? "";
+        if (argument === "-C" || argument === "-c") {
+            index += 1;
+            continue;
+        }
+        if (argument.startsWith("-")) {
+            continue;
+        }
+        return { name: argument, args: args.slice(index + 1) };
+    }
+    return { name: undefined, args: [] };
+}
+function hasDestructivePushArgument(args) {
+    let repositorySupplied = false;
+    const operands = [];
+    let optionsEnded = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index] ?? "";
+        if (optionsEnded) {
+            operands.push(argument);
+            continue;
+        }
+        if (argument === "--") {
+            optionsEnded = true;
+            continue;
+        }
+        if (argument.startsWith("--")) {
+            const equalsIndex = argument.indexOf("=");
+            const option = equalsIndex === -1 ? argument : argument.slice(0, equalsIndex);
+            if (option === "--force" ||
+                option === "--force-with-lease" ||
+                option === "--mirror") {
+                return true;
+            }
+            if (PUSH_LONG_OPTIONS_WITH_VALUES.has(option)) {
+                if (option === "--repo") {
+                    repositorySupplied = true;
+                }
+                if (equalsIndex === -1) {
+                    index += 1;
+                }
+            }
+            continue;
+        }
+        if (argument.startsWith("-") && argument !== "-") {
+            const flags = argument.slice(1);
+            for (let flagIndex = 0; flagIndex < flags.length; flagIndex += 1) {
+                const flag = flags[flagIndex];
+                if (flag === "f") {
+                    return true;
+                }
+                if (flag === "o") {
+                    if (flagIndex === flags.length - 1) {
+                        index += 1;
+                    }
+                    break;
+                }
+            }
+            continue;
+        }
+        operands.push(argument);
+    }
+    const refspecs = repositorySupplied ? operands : operands.slice(1);
+    return refspecs.some((argument) => argument.startsWith("+") && argument.length > 1);
+}
+function gitDecision(args) {
+    const subcommand = gitSubcommand(args);
+    if (subcommand.name === "reset" && subcommand.args.includes("--hard")) {
+        return {
+            action: "block",
+            ruleId: GUARDRAIL_RULE_IDS.reset,
+            reason: "A destructive Git hard reset can discard uncommitted work.",
+            saferAlternative: "Create a backup branch or use git revert instead of git reset --hard."
+        };
+    }
+    if (subcommand.name === "push" &&
+        hasDestructivePushArgument(subcommand.args)) {
+        return {
+            action: "block",
+            ruleId: GUARDRAIL_RULE_IDS.forcePush,
+            reason: "A forced Git push can overwrite shared remote history.",
+            saferAlternative: "Push without force, or use a bounded reviewed exception for the exact scope."
+        };
+    }
+    return { action: "allow" };
+}
+export function evaluateDestructiveCommand(input) {
+    const command = executableName(input.command);
+    if (command === "git") {
+        return gitDecision(input.args);
+    }
+    return removalDecision(command, input.args);
+}