patchwarden 1.5.1 → 1.6.2

package/dist/test/unit/logging.test.js

@@ -1,397 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { mkdtempSync, rmSync, readFileSync, existsSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { Logger, logUnhandledError, installGlobalHandlers, computeArgumentsDigest, logToolInvocation, } from "../../logging.js";
-// ── Test helpers ──────────────────────────────────────────────────
-/**
- * Capture everything written to stderr during `fn` and return it as an
- * array of raw chunks (one per `process.stderr.write` call).
- */
-function captureStderr(fn) {
-    const chunks = [];
-    const original = process.stderr.write;
-    process.stderr.write = ((chunk) => {
-        chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8"));
-        return true;
-    });
-    try {
-        fn();
-    }
-    finally {
-        process.stderr.write = original;
-    }
-    return chunks;
-}
-/**
- * Capture stderr and return the parsed JSON objects (one per log line).
- */
-function captureJson(fn) {
-    const chunks = captureStderr(fn);
-    return chunks
-        .flatMap((chunk) => chunk.split("\n"))
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-        .map((line) => JSON.parse(line));
-}
-// ── Logger: stderr output ─────────────────────────────────────────
-describe("Logger — stderr output", () => {
-    it("writes JSON log entries to stderr (never stdout)", () => {
-        const log = new Logger();
-        const entries = captureJson(() => {
-            log.info("hello from test", { component: "unit-test" });
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        assert.equal(entry.level, "info");
-        assert.equal(entry.message, "hello from test");
-        assert.equal(entry.component, "unit-test");
-        assert.equal(typeof entry.timestamp, "string");
-        // timestamp must be a valid ISO date
-        assert.ok(!Number.isNaN(Date.parse(entry.timestamp)));
-    });
-    it("supports warn and error levels", () => {
-        const log = new Logger();
-        const entries = captureJson(() => {
-            log.warn("careful");
-            log.error("broken");
-        });
-        assert.equal(entries.length, 2);
-        assert.equal(entries[0].level, "warn");
-        assert.equal(entries[0].message, "careful");
-        assert.equal(entries[1].level, "error");
-        assert.equal(entries[1].message, "broken");
-    });
-    it("does not write anything to stdout", () => {
-        const originalStdout = process.stdout.write;
-        let stdoutWritten = false;
-        process.stdout.write = (() => {
-            stdoutWritten = true;
-            return true;
-        });
-        try {
-            const log = new Logger();
-            log.info("should not touch stdout");
-            log.warn("nor this");
-            log.error("nor this");
-        }
-        finally {
-            process.stdout.write = originalStdout;
-        }
-        assert.equal(stdoutWritten, false, "Logger must never write to stdout");
-    });
-});
-// ── Logger: audit ─────────────────────────────────────────────────
-describe("Logger.audit — format", () => {
-    it("produces an audit log entry with all required fields", () => {
-        const log = new Logger();
-        const entries = captureJson(() => {
-            log.audit("createTask", true, 150, undefined, "task-001");
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        // Required core fields
-        assert.equal(entry.level, "audit");
-        assert.equal(typeof entry.timestamp, "string");
-        assert.ok(!Number.isNaN(Date.parse(entry.timestamp)));
-        assert.equal(typeof entry.message, "string");
-        // Audit-specific fields
-        assert.equal(entry.tool, "createTask");
-        assert.equal(entry.ok, true);
-        assert.equal(entry.duration_ms, 150);
-        assert.equal(entry.task_id, "task-001");
-        // error_reason should be absent when not provided
-        assert.equal(entry.error_reason, undefined);
-    });
-    it("includes error_reason when the tool call failed", () => {
-        const log = new Logger();
-        const entries = captureJson(() => {
-            log.audit("applyPatch", false, 3000, "command_blocked", "task-002");
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        assert.equal(entry.ok, false);
-        assert.equal(entry.error_reason, "command_blocked");
-        assert.equal(entry.task_id, "task-002");
-    });
-    it("omits task_id when not provided", () => {
-        const log = new Logger();
-        const entries = captureJson(() => {
-            log.audit("healthCheck", true, 5);
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        assert.equal(entry.task_id, undefined);
-        assert.equal(entry.error_reason, undefined);
-    });
-});
-// ── Logger: verbose mode ──────────────────────────────────────────
-describe("Logger — verbose mode (PATCHWARDEN_VERBOSE_LOG)", () => {
-    let savedEnv;
-    beforeEach(() => {
-        savedEnv = process.env.PATCHWARDEN_VERBOSE_LOG;
-    });
-    afterEach(() => {
-        if (savedEnv === undefined) {
-            delete process.env.PATCHWARDEN_VERBOSE_LOG;
-        }
-        else {
-            process.env.PATCHWARDEN_VERBOSE_LOG = savedEnv;
-        }
-    });
-    it("does not log args by default (verbose mode off)", () => {
-        delete process.env.PATCHWARDEN_VERBOSE_LOG;
-        const log = new Logger();
-        const fakeToken = "sk_" + "FAKE_TOKEN_VALUE_123456";
-        const sensitiveArgs = {
-            prompt: "fix the bug",
-            token: fakeToken,
-        };
-        const entries = captureJson(() => {
-            log.audit("createTask", true, 100, undefined, "task-003", sensitiveArgs);
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        // args must NOT be present when verbose mode is off
-        assert.equal(entry.args, undefined);
-        // The raw token must not appear anywhere in the serialized entry
-        const raw = JSON.stringify(entry);
-        assert.ok(!raw.includes(fakeToken), "raw token must not leak into log output");
-    });
-    it("logs sanitized args when PATCHWARDEN_VERBOSE_LOG=true", () => {
-        process.env.PATCHWARDEN_VERBOSE_LOG = "true";
-        const log = new Logger();
-        const fakeToken = "sk_" + "FAKE_TOKEN_VALUE_123456";
-        const sensitiveArgs = {
-            prompt: "fix the bug",
-            token: fakeToken,
-        };
-        const entries = captureJson(() => {
-            log.audit("createTask", true, 100, undefined, "task-004", sensitiveArgs);
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        // args must be present and redacted
-        assert.ok(entry.args !== undefined, "args should be logged in verbose mode");
-        const argsStr = String(entry.args);
-        assert.ok(argsStr.includes("[REDACTED TOKEN]"), "sensitive token must be redacted");
-        assert.ok(!argsStr.includes(fakeToken), "raw token must not appear in args");
-        // non-sensitive content is preserved
-        assert.ok(argsStr.includes("fix the bug"), "non-sensitive args content is preserved");
-    });
-    it("does not log args when PATCHWARDEN_VERBOSE_LOG is set but not 'true'", () => {
-        process.env.PATCHWARDEN_VERBOSE_LOG = "false";
-        const log = new Logger();
-        const entries = captureJson(() => {
-            log.audit("createTask", true, 100, undefined, "task-005", { prompt: "hello" });
-        });
-        assert.equal(entries.length, 1);
-        assert.equal(entries[0].args, undefined);
-    });
-});
-// ── logUnhandledError ─────────────────────────────────────────────
-describe("logUnhandledError", () => {
-    it("produces structured JSON output for Error instances", () => {
-        const error = new Error("something went wrong");
-        error.name = "CustomError";
-        const entries = captureJson(() => {
-            logUnhandledError(error);
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        assert.equal(entry.level, "error");
-        assert.equal(entry.message, "unhandled_error");
-        assert.equal(entry.error, "something went wrong");
-        assert.equal(entry.error_name, "CustomError");
-        assert.equal(typeof entry.timestamp, "string");
-        assert.ok(!Number.isNaN(Date.parse(entry.timestamp)));
-        assert.equal(typeof entry.stack, "string");
-        assert.ok(entry.stack.includes("something went wrong"));
-    });
-    it("handles non-Error values (string)", () => {
-        const entries = captureJson(() => {
-            logUnhandledError("a plain string rejection");
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        assert.equal(entry.level, "error");
-        assert.equal(entry.error, "a plain string rejection");
-        assert.equal(entry.error_name, "string");
-        assert.equal(entry.stack, undefined);
-    });
-    it("handles non-Error values (object)", () => {
-        const entries = captureJson(() => {
-            logUnhandledError({ code: 42, detail: "weird" });
-        });
-        assert.equal(entries.length, 1);
-        const entry = entries[0];
-        assert.equal(entry.level, "error");
-        assert.ok(String(entry.error).includes("42"));
-        assert.equal(entry.error_name, "object");
-    });
-});
-// ── installGlobalHandlers ─────────────────────────────────────────
-describe("installGlobalHandlers", () => {
-    it("does not throw when called", () => {
-        // Save existing listeners so we can restore them afterwards and avoid
-        // the fatal `uncaughtException` handler interfering with the test
-        // runner.
-        const origUnhandled = process.listeners("unhandledRejection");
-        const origUncaught = process.listeners("uncaughtException");
-        process.removeAllListeners("unhandledRejection");
-        process.removeAllListeners("uncaughtException");
-        try {
-            assert.doesNotThrow(() => installGlobalHandlers());
-            // Verify the handlers were actually registered
-            assert.ok(process.listenerCount("unhandledRejection") >= 1);
-            assert.ok(process.listenerCount("uncaughtException") >= 1);
-        }
-        finally {
-            // Restore original listeners
-            process.removeAllListeners("unhandledRejection");
-            process.removeAllListeners("uncaughtException");
-            for (const fn of origUnhandled)
-                process.on("unhandledRejection", fn);
-            for (const fn of origUncaught)
-                process.on("uncaughtException", fn);
-        }
-    });
-    it("can be called multiple times without throwing", () => {
-        const origUnhandled = process.listeners("unhandledRejection");
-        const origUncaught = process.listeners("uncaughtException");
-        process.removeAllListeners("unhandledRejection");
-        process.removeAllListeners("uncaughtException");
-        try {
-            assert.doesNotThrow(() => {
-                installGlobalHandlers();
-                installGlobalHandlers();
-            });
-        }
-        finally {
-            process.removeAllListeners("unhandledRejection");
-            process.removeAllListeners("uncaughtException");
-            for (const fn of origUnhandled)
-                process.on("unhandledRejection", fn);
-            for (const fn of origUncaught)
-                process.on("uncaughtException", fn);
-        }
-    });
-});
-// ── computeArgumentsDigest ───────────────────────────────────────
-describe("computeArgumentsDigest", () => {
-    it("returns the same digest for identical arguments (stability)", () => {
-        const args = { b: 2, a: 1, nested: { y: "yes", x: [1, 2] } };
-        const d1 = computeArgumentsDigest(args);
-        const d2 = computeArgumentsDigest(args);
-        assert.equal(d1, d2);
-    });
-    it("returns the same digest regardless of key order (stable serialization)", () => {
-        const d1 = computeArgumentsDigest({ a: 1, b: 2 });
-        const d2 = computeArgumentsDigest({ b: 2, a: 1 });
-        assert.equal(d1, d2);
-    });
-    it("returns different digests for different arguments", () => {
-        const d1 = computeArgumentsDigest({ a: 1 });
-        const d2 = computeArgumentsDigest({ a: 2 });
-        assert.notEqual(d1, d2);
-    });
-    it("returns a 'sha256:' prefixed digest", () => {
-        const digest = computeArgumentsDigest({ foo: "bar" });
-        assert.ok(digest.startsWith("sha256:"), `digest should start with "sha256:", got: ${digest}`);
-        // full format: sha256: + 64 lowercase hex chars
-        assert.match(digest, /^sha256:[a-f0-9]{64}$/);
-    });
-    it("does not leak raw argument values into the digest string", () => {
-        const fakeToken = "tok-value";
-        const sensitiveArgs = { token: fakeToken, prompt: "hello-world" };
-        const digest = computeArgumentsDigest(sensitiveArgs);
-        assert.ok(!digest.includes(fakeToken), "digest must not leak raw token value");
-        assert.ok(!digest.includes("hello-world"), "digest must not leak raw prompt value");
-    });
-});
-// ── logToolInvocation ────────────────────────────────────────────
-describe("logToolInvocation", () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), "pw-invlog-"));
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    function sampleEntry(overrides = {}) {
-        return {
-            timestamp: new Date().toISOString(),
-            toolName: "read_workspace_file",
-            discoveryToken: "tok",
-            risk: "workspace_read_sensitive",
-            profile: "full",
-            arguments_digest: "sha256:" + "0".repeat(64),
-            result: "ok",
-            duration_ms: 42,
-            ...overrides,
-        };
-    }
-    it("writes an entry to invocation.log inside the provided logsDir", () => {
-        const logsDir = join(tempDir, ".patchwarden", "logs");
-        const entry = sampleEntry();
-        logToolInvocation(entry, { logsDir });
-        const logPath = join(logsDir, "invocation.log");
-        assert.ok(existsSync(logPath), "invocation.log should be created");
-        const content = readFileSync(logPath, "utf-8");
-        const lines = content.trim().split("\n");
-        assert.equal(lines.length, 1, "exactly one JSON line should be written");
-        const parsed = JSON.parse(lines[0]);
-        assert.equal(parsed.toolName, "read_workspace_file");
-        assert.equal(parsed.discoveryToken, "tok");
-        assert.equal(parsed.risk, "workspace_read_sensitive");
-        assert.equal(parsed.profile, "full");
-        assert.equal(parsed.result, "ok");
-        assert.equal(parsed.duration_ms, 42);
-        assert.match(parsed.arguments_digest, /^sha256:[a-f0-9]{64}$/);
-        assert.ok(!Number.isNaN(Date.parse(parsed.timestamp)));
-    });
-    it("appends multiple entries as JSON Lines", () => {
-        const logsDir = join(tempDir, "logs");
-        logToolInvocation(sampleEntry({ duration_ms: 1 }), { logsDir });
-        logToolInvocation(sampleEntry({ duration_ms: 2, result: "error", error_code: "blocked" }), { logsDir });
-        const content = readFileSync(join(logsDir, "invocation.log"), "utf-8");
-        const lines = content.trim().split("\n");
-        assert.equal(lines.length, 2);
-        const first = JSON.parse(lines[0]);
-        const second = JSON.parse(lines[1]);
-        assert.equal(first.duration_ms, 1);
-        assert.equal(first.result, "ok");
-        assert.equal(second.duration_ms, 2);
-        assert.equal(second.result, "error");
-        assert.equal(second.error_code, "blocked");
-    });
-    it("includes allowedScope and error_code when provided", () => {
-        const logsDir = join(tempDir, "logs");
-        logToolInvocation(sampleEntry({
-            allowedScope: ["src/", "docs/"],
-            result: "error",
-            error_code: "scope_violation",
-        }), { logsDir });
-        const parsed = JSON.parse(readFileSync(join(logsDir, "invocation.log"), "utf-8").trim());
-        assert.deepEqual(parsed.allowedScope, ["src/", "docs/"]);
-        assert.equal(parsed.error_code, "scope_violation");
-    });
-    it("omits error_code and allowedScope when not provided", () => {
-        const logsDir = join(tempDir, "logs");
-        logToolInvocation(sampleEntry(), { logsDir });
-        const parsed = JSON.parse(readFileSync(join(logsDir, "invocation.log"), "utf-8").trim());
-        assert.equal(parsed.error_code, undefined);
-        assert.equal(parsed.allowedScope, undefined);
-    });
-    it("does not throw when the log directory cannot be created", () => {
-        // Create a file, then attempt to use a path beneath it as logsDir.
-        // mkdirSync will fail with ENOTDIR because the parent is a file.
-        const blockingFile = join(tempDir, "blocker");
-        writeFileSync(blockingFile, "x", "utf-8");
-        const impossibleLogsDir = join(blockingFile, "subdir");
-        assert.doesNotThrow(() => {
-            logToolInvocation(sampleEntry(), { logsDir: impossibleLogsDir });
-        });
-    });
-});

package/dist/test/unit/path-guard.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/unit/path-guard.test.js

@@ -1,133 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, symlinkSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { tmpdir } from "node:os";
-import { guardPath, guardWorkspacePath } from "../../security/pathGuard.js";
-import { PatchWardenError } from "../../errors.js";
-describe("guardPath", () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), "pw-pathguard-"));
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    it("allows paths inside workspace", () => {
-        const result = guardPath("src/main.ts", tempDir);
-        assert.ok(result.startsWith(tempDir));
-        assert.ok(result.includes("src"));
-        assert.ok(result.includes("main.ts"));
-    });
-    it("allows root workspace path", () => {
-        const result = guardPath(".", tempDir);
-        assert.equal(result, resolve(tempDir));
-    });
-    it("allows empty path as workspace root", () => {
-        const result = guardPath("", tempDir);
-        assert.equal(result, resolve(tempDir));
-    });
-    it("rejects path traversal with ..", () => {
-        assert.throws(() => guardPath("../../../etc/passwd", tempDir), PatchWardenError);
-    });
-    it("rejects path traversal nested with ..", () => {
-        assert.throws(() => guardPath("src/../../../etc/passwd", tempDir), PatchWardenError);
-    });
-    it("rejects absolute path outside workspace", () => {
-        const outside = process.platform === "win32" ? "C:\\Windows\\System32" : "/etc";
-        assert.throws(() => guardPath(outside, tempDir), PatchWardenError);
-    });
-    it("allows absolute path inside workspace", () => {
-        const insidePath = join(tempDir, "src", "main.ts");
-        mkdirSync(join(tempDir, "src"), { recursive: true });
-        writeFileSync(insidePath, "test", "utf-8");
-        const result = guardPath(insidePath, tempDir);
-        assert.equal(result, resolve(insidePath));
-    });
-    it("enforces allowedPrefix", () => {
-        mkdirSync(join(tempDir, "allowed"), { recursive: true });
-        mkdirSync(join(tempDir, "forbidden"), { recursive: true });
-        // Path inside allowed prefix works
-        const okResult = guardPath("allowed/file.ts", tempDir, "allowed");
-        assert.ok(okResult.includes("allowed"));
-        // Path outside allowed prefix fails
-        assert.throws(() => guardPath("forbidden/file.ts", tempDir, "allowed"), PatchWardenError);
-    });
-    it("handles Windows mixed separators", () => {
-        const mixedPath = "src\\subdir/file.ts";
-        const result = guardPath(mixedPath, tempDir);
-        assert.ok(result.startsWith(tempDir));
-    });
-    it("rejects symlink escape", { skip: process.platform === "win32" ? "Windows symlink permissions unstable" : undefined }, () => {
-        const target = mkdtempSync(join(tmpdir(), "pw-symlink-target-"));
-        try {
-            const linkPath = join(tempDir, "escape-link");
-            symlinkSync(target, linkPath);
-            assert.throws(() => guardPath("escape-link/secret.txt", tempDir), PatchWardenError);
-        }
-        finally {
-            rmSync(target, { recursive: true, force: true });
-        }
-    });
-    it("rejects Windows junction escape", { skip: process.platform !== "win32" ? "Windows-only test" : undefined }, () => {
-        const target = mkdtempSync(join(tmpdir(), "pw-junction-target-"));
-        try {
-            const linkPath = join(tempDir, "escape-junction");
-            symlinkSync(target, linkPath, "junction");
-            assert.throws(() => guardPath("escape-junction/secret.txt", tempDir), PatchWardenError);
-        }
-        finally {
-            rmSync(target, { recursive: true, force: true });
-        }
-    });
-    it("rejects intermediate symlink escape (TOCTOU defense)", { skip: process.platform === "win32" ? "Windows symlink permissions unstable" : undefined }, () => {
-        const target = mkdtempSync(join(tmpdir(), "pw-toctou-target-"));
-        try {
-            const linkPath = join(tempDir, "escape-link");
-            symlinkSync(target, linkPath);
-            mkdirSync(join(target, "subdir"), { recursive: true });
-            writeFileSync(join(target, "subdir", "secret.txt"), "secret", "utf-8");
-            assert.throws(() => guardPath("escape-link/subdir/secret.txt", tempDir), PatchWardenError);
-        }
-        finally {
-            rmSync(target, { recursive: true, force: true });
-        }
-    });
-});
-describe("guardWorkspacePath", () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), "pw-wspath-"));
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    it("allows relative path inside workspace", () => {
-        const result = guardWorkspacePath("my-repo", tempDir);
-        assert.equal(result, resolve(tempDir, "my-repo"));
-    });
-    it("allows absolute path inside workspace", () => {
-        const absPath = join(tempDir, "my-repo");
-        const result = guardWorkspacePath(absPath, tempDir);
-        assert.equal(result, resolve(absPath));
-    });
-    it("rejects path outside workspace", () => {
-        assert.throws(() => guardWorkspacePath("../../../etc", tempDir), PatchWardenError);
-    });
-    it("rejects different drive letter on Windows", { skip: process.platform !== "win32" ? "Windows-only test" : undefined }, () => {
-        // If workspace is on C:, a D: path should be rejected
-        const wsDrive = tempDir.match(/^([A-Za-z]):/);
-        if (!wsDrive)
-            return;
-        const otherDrive = wsDrive[1].toLowerCase() === "c" ? "D" : "C";
-        assert.throws(() => guardWorkspacePath(`${otherDrive}:\\some\\repo`, tempDir), (err) => err instanceof PatchWardenError && err.reason === "workspace_path_escape");
-    });
-    it("defaults to workspace root for empty input", () => {
-        const result = guardWorkspacePath("", tempDir);
-        assert.equal(result, resolve(tempDir));
-    });
-    it("defaults to workspace root for dot input", () => {
-        const result = guardWorkspacePath(".", tempDir);
-        assert.equal(result, resolve(tempDir));
-    });
-});

package/dist/test/unit/post-task-cleanup.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/unit/post-task-cleanup.test.js

@@ -1,48 +0,0 @@
-import { describe, it } from "node:test";
-import { strict as assert } from "node:assert";
-import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { runPostTaskCleanup } from "../../runner/postTaskCleanup.js";
-describe("postTaskCleanup", () => {
-    it("removes untracked low-risk artifacts and skips tracked or excluded paths", () => {
-        const root = mkdtempSync(join(tmpdir(), "pw-cleanup-"));
-        try {
-            execFileSync("git", ["init"], { cwd: root, stdio: "ignore" });
-            execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: root, stdio: "ignore" });
-            execFileSync("git", ["config", "user.name", "PatchWarden Test"], { cwd: root, stdio: "ignore" });
-            mkdirSync(join(root, "tracked", "__pycache__"), { recursive: true });
-            writeFileSync(join(root, "tracked", "__pycache__", "keep.pyc"), "tracked", "utf-8");
-            execFileSync("git", ["add", "."], { cwd: root, stdio: "ignore" });
-            execFileSync("git", ["commit", "-m", "init"], { cwd: root, stdio: "ignore" });
-            mkdirSync(join(root, "backend", "__pycache__"), { recursive: true });
-            mkdirSync(join(root, ".venv", "__pycache__"), { recursive: true });
-            mkdirSync(join(root, ".patchwarden", "tasks", "old-task", "__pycache__"), { recursive: true });
-            mkdirSync(join(root, "node_modules", "pkg", "__pycache__"), { recursive: true });
-            mkdirSync(join(root, "docs", "__pycache__"), { recursive: true });
-            writeFileSync(join(root, "backend", "__pycache__", "drop.pyc"), "drop", "utf-8");
-            writeFileSync(join(root, ".venv", "__pycache__", "skip.pyc"), "skip", "utf-8");
-            writeFileSync(join(root, ".patchwarden", "tasks", "old-task", "__pycache__", "skip.pyc"), "skip", "utf-8");
-            writeFileSync(join(root, "node_modules", "pkg", "__pycache__", "skip.pyc"), "skip", "utf-8");
-            writeFileSync(join(root, "docs", "__pycache__", "skip.pyc"), "skip", "utf-8");
-            const taskDir = join(root, ".patchwarden", "tasks", "task-1");
-            mkdirSync(taskDir, { recursive: true });
-            const report = runPostTaskCleanup(root, taskDir);
-            assert.ok(report.removed.some((entry) => entry.path === "backend/__pycache__"));
-            assert.ok(report.skipped.some((entry) => entry.path === "tracked/__pycache__" && entry.skip_reason === "tracked_by_git"));
-            assert.equal(report.source_files_touched, 0);
-            assert.ok(!existsSync(join(root, "backend", "__pycache__")));
-            assert.ok(existsSync(join(root, "tracked", "__pycache__", "keep.pyc")));
-            assert.ok(existsSync(join(root, ".venv", "__pycache__", "skip.pyc")));
-            assert.ok(existsSync(join(root, ".patchwarden", "tasks", "old-task", "__pycache__", "skip.pyc")));
-            assert.ok(existsSync(join(root, "node_modules", "pkg", "__pycache__", "skip.pyc")));
-            assert.ok(existsSync(join(root, "docs", "__pycache__", "skip.pyc")));
-            const written = JSON.parse(readFileSync(join(taskDir, "post-task-cleanup.json"), "utf-8"));
-            assert.equal(written.enabled, true);
-        }
-        finally {
-            rmSync(root, { recursive: true, force: true });
-        }
-    });
-});

package/dist/test/unit/project-policy-release-mode.test.d.ts

@@ -1 +0,0 @@
-export {};