shrinker-ai 0.1.0

package/.copilot-instructions.md

@@ -0,0 +1,2 @@
+
+

package/CLAUDE.md

@@ -0,0 +1,2 @@
+
+

package/README.md

@@ -0,0 +1,295 @@
+# shrinker
+
+A small local CLI proof of concept that removes noise from command output before a coding agent or LLM reads it.
+
+this POC proves that a few conservative, deterministic filters can save useful context without requiring an API key, service, UI, database, or agent-specific integration.
+
+## What the POC demonstrates
+
+- Explicit cross-agent command wrapping: `shrinker exec -- <command>`.
+- Filters for Git status, Git diff, test output, and generic logs.
+- Failures, warnings, changed paths, and command exit codes are preserved.
+- Omitted raw output is saved locally for recovery.
+- Optional per-run metrics report bytes and approximate before/after tokens.
+- Local SQLite statistics accumulate savings across runs.
+- No command output leaves the machine.
+
+## Quick start
+
+Requires Node.js 22.13 or newer. This is the first Node 22 release where the built-in SQLite module no longer requires an experimental flag.
+
+### One-command install (Windows PowerShell)
+
+Quick one-liner:
+
+```powershell
+irm https://raw.githubusercontent.com/ivanduplenskikh/shrinker/main/integrations/install.ps1 | iex
+```
+
+### Package install from npm
+
+The installer downloads the published package from the public npm registry, then installs its local integration files.
+
+```powershell
+irm https://raw.githubusercontent.com/ivanduplenskikh/shrinker/main/integrations/install.ps1 | iex
+```
+
+This script installs `shrinker-ai` from `https://registry.npmjs.org` and installs Copilot/Claude rules by default.
+
+To enable automatic PowerShell routing (so `git log` routes through `shrinker`), download the script and pass the option:
+
+```powershell
+$tmp = Join-Path $env:TEMP "install-shrinker.ps1"
+Invoke-WebRequest "https://raw.githubusercontent.com/ivanduplenskikh/shrinker/main/integrations/install.ps1" -OutFile $tmp
+pwsh -ExecutionPolicy Bypass -File $tmp -EnableProfileRouting
+```
+
+For a local checkout, use the complete installer without profile routing:
+
+```powershell
+pwsh -ExecutionPolicy Bypass -File .\integrations\install-shrinker.ps1
+```
+
+This writes managed guidance blocks to:
+
+- `.copilot-instructions.md`
+- `CLAUDE.md`
+
+The shared guidance source is `templates/agent-rules.md`; the two files above are generated in the target project.
+
+The rules tell agents to prefer `shrinker <command>` for high-volume commands while leaving native commands untouched.
+
+### Remote package uninstall
+
+Quick one-liner:
+
+```powershell
+irm https://raw.githubusercontent.com/ivanduplenskikh/shrinker/main/integrations/uninstall.ps1 | iex
+```
+
+### Local repo install/uninstall (contributors)
+
+If you cloned this repository and want to run scripts directly from the local path:
+
+```powershell
+pwsh -ExecutionPolicy Bypass -File .\integrations\install-shrinker.ps1
+```
+
+To uninstall:
+
+```powershell
+pwsh -ExecutionPolicy Bypass -File .\integrations\uninstall-shrinker.ps1
+```
+
+Uninstall options:
+
+```powershell
+# Remove only profile routing, keep shrinker command installed
+pwsh -ExecutionPolicy Bypass -File .\integrations\uninstall-shrinker.ps1 -SkipUnlink
+
+# Remove managed Copilot/Claude rules block only
+pwsh -ExecutionPolicy Bypass -File .\integrations\uninstall-shrinker.ps1 -SkipUnlink
+```
+
+If your current terminal had already loaded `shrinker-profile.ps1`, restart terminal (or remove loaded wrapper functions) to fully return to native command behavior.
+
+```powershell
+npm install
+npm run build
+node dist\src\cli.js exec -- git status
+node dist\src\cli.js exec -- git diff
+node dist\src\cli.js exec -- git log -n 10
+node dist\src\cli.js exec -- npm test
+Get-Content .\tests\fixtures\generic-log.txt -Raw |
+  node dist\src\cli.js pipe --kind log
+```
+
+To install the `shrinker` command locally:
+
+```powershell
+npm link
+shrinker git status
+shrinker git log -n 10
+shrinker npm test
+```
+
+## CLI
+
+```text
+shrinker <command> [args...]
+shrinker exec [options] [--] <command> [args...]
+shrinker pipe [options]
+shrinker stats [--json]
+shrinker last [--path]
+shrinker raw <capture-id> [--path]
+shrinker help
+
+--kind <auto|git-status|git-diff|git-log|test|log>
+--max-lines <number>       default: 120
+--per-file-lines <number>  default: 40
+--raw                      bypass filtering
+--metrics                  print per-run savings and duration
+--no-save                  do not save omitted raw output
+--no-stats                 do not record this run
+```
+
+`help`, `stats`, `last`, `raw`, `pipe`, and `exec` are reserved shrinker commands. Every other top-level token starts a wrapped command, so `shrinker git log` is equivalent to `shrinker exec git log`. The `--` separator remains optional because npm's PowerShell shim may consume it. `pipe` reads existing text from stdin and defaults to the generic log filter unless `--kind` is specified.
+
+## Automatic PowerShell routing
+
+The optional profile integration routes allowlisted commands through `shrinker` and invokes the native executable for everything else. Install it after `npm link`:
+
+```powershell
+if (!(Test-Path $PROFILE)) {
+    New-Item -ItemType File -Path $PROFILE -Force | Out-Null
+}
+
+$integration = (Resolve-Path .\integrations\shrinker-profile.ps1).Path
+Add-Content $PROFILE "`n. `"$integration`""
+. $PROFILE
+```
+
+The default rules are:
+
+```text
+git status  -> shrinker git status
+git diff    -> shrinker git diff
+git log     -> shrinker git log
+npm test    -> shrinker npm test
+docker ps   -> shrinker docker ps
+kubectl get -> shrinker kubectl get
+gh pr list  -> shrinker gh pr list
+rg/find/tail/cat/ls/dir -> shrinker <command>
+
+git push, git fetch, and all other commands -> native executable
+```
+
+Edit `$global:ShrinkPowerShellRules` in `integrations\shrinker-profile.ps1` to change the allowlist. The router is now option-aware for common global flags, so forms like `git -C <path> log` and `kubectl --context prod get pods` are routed correctly.
+
+## Savings statistics
+
+Filtered runs are recorded locally in `~/.shrinker/stats.db`. The database stores only measurements, filter kind, executable basename, duration, omission state, and exit code. It does **not** store command arguments or command output.
+
+```powershell
+node dist\src\cli.js stats
+node dist\src\cli.js stats --json
+node dist\src\cli.js stats --chart
+node dist\src\cli.js stats --dashboard
+```
+
+The summary shows all-time and last-seven-day savings plus a breakdown by filter. Use `--no-stats` before `--` to opt out for an individual run:
+
+`stats --chart` shows daily runs, estimated tokens saved, reduction percentage, and an activity bar for the last 30 days.
+`stats --dashboard` writes a self-contained browser dashboard to `~/.shrinker/dashboard.html` with a line chart and filter breakdown.
+
+```powershell
+node dist\src\cli.js exec --no-stats -- git log -n 10
+```
+
+Detailed per-run measurements are hidden by default so agents do not spend tokens reading wrapper telemetry. Enable them for benchmarking or demos:
+
+```powershell
+shrinker --metrics git log -n 10
+```
+
+When meaningful content is omitted, the full capture is saved under `~/.shrinker/raw` and a compact exact-recovery hint such as `[full: shrinker raw ab12cd34]` is printed instead of an absolute path. Retrieve it only when needed:
+
+```powershell
+shrinker raw ab12cd34
+shrinker raw ab12cd34 --path
+shrinker last
+shrinker last --path
+```
+
+`raw` retrieves the exact capture referenced by a hint; `last` is a convenience for human use. The cache uses atomic publication and best-effort rotation to retain up to 20 recent files. File names contain only the executable name, not command arguments. Wrapped `git log` output never creates a recovery file or hint because the full history can be reproduced by rerunning Git; piped Git-log text still gets a recovery hint when meaningful content is omitted. Use `--no-save` for other output that should not be persisted.
+
+## Demo
+
+```powershell
+npm run demo
+```
+
+Current representative fixtures:
+
+| Output | Estimated token reduction |
+|---|---:|
+| Git status | 62% |
+| Git diff | 26% |
+| Git log with commit bodies | 39% |
+| Git log with one short commit | 69%, but only 27 estimated tokens |
+| Test failure | 51% |
+| Noisy log | 39% |
+| **Average** | **48%** |
+
+The token estimate uses `ceil(characters / 4)`. It is suitable for relative before/after comparisons, not billing claims. Byte counts and absolute estimated tokens saved are also reported; gains below 50 tokens are labeled as small.
+
+## Architecture
+
+```text
+command/stdin
+    |
+    v
+capture output + exit code
+    |
+    v
+select deterministic filter
+    |
+    +--> git status: group files by state
+    +--> git diff: retain changed lines, drop metadata/context
+    +--> git log: retain short hash, refs, subject, author, date,
+    |             and up to three useful body lines
+    +--> tests: collapse passes, retain failures and summaries
+    +--> logs: collapse progress and repeated lines
+    |
+    v
+compact output + optional metrics + meaningful-omission recovery hint
+```
+
+Filters are pure functions, so the same pipeline can later sit behind a GitHub Copilot hook or MCP server without rewriting the compression logic.
+
+## Safety and limitations
+
+- The tool does not execute through a shell. Compound shell expressions and interactive commands are out of scope.
+- Stdout and stderr are captured separately and presented as stdout followed by stderr; exact interleaving is not preserved.
+- Filtering is conservative, but any lossy transform can hide useful context. The recovery file and `--raw` are escape hatches.
+- Git log patch/stat/name-list flags and explicit custom formats are preserved rather than destructively reinterpreted.
+- Git log does not impose hidden commit limits or suppress merge commits.
+- This measures command-output reduction, not total Copilot usage, total conversation context, or billing.
+- Streaming, agent hooks, MCP, telemetry, dashboards, custom configuration, and a broad command registry are deliberately deferred.
+
+## Validation
+
+```powershell
+npm test
+```
+
+Tests cover information retention, reduction targets, ANSI cleanup, filter selection, command capture, and non-zero exit-code propagation.
+
+## Release to npm
+
+A GitHub Actions workflow publishes this CLI to npm:
+
+- Workflow file: `.github/workflows/publish-npm.yml`
+- Triggers:
+    - Tag push matching `v*` (for example `v0.2.0`)
+    - Manual run via workflow_dispatch
+- Pipeline steps:
+    - `npm ci`
+    - `npm test`
+    - `npm publish` to `https://registry.npmjs.org`
+
+How to publish:
+
+1. Push your changes to GitHub.
+2. Push a version tag (or run the workflow manually):
+    - `git tag v0.2.0`
+    - `git push origin v0.2.0`
+3. After the workflow succeeds, install from npm:
+    - `npm install -g shrinker-ai`
+
+## Suggested roadmap
+
+1. Validate the POC with real Copilot/Agency workflows and identify the highest-volume commands.
+2. Add a GitHub Copilot pre-tool hook for transparent rewriting.
+3. Expose the executor and filters through MCP for other agents.
+4. Add filters only when measured usage justifies them.

package/dist/src/cli.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import process from "node:process";
+import path from "node:path";
+import { applyFilter } from "./filters/select-filter.js";
+import { runCommand } from "./execution/run-command.js";
+import { getLatestRawOutput, getRawOutput, saveRawOutput } from "./execution/raw-output-store.js";
+import { cleanText } from "./formatting/ansi.js";
+import { formatMeasurements, measure } from "./metrics/measure.js";
+import { openStatsDashboard, writeStatsDashboard } from "./metrics/dashboard.js";
+import { defaultStatsPath, formatStats, formatStatsChart, getStats, recordRun } from "./metrics/stats-store.js";
+function usage() {
+    return `Usage:
+  shrinker <command> [args...]
+  shrinker exec [options] [--] <command> [args...]
+  shrinker pipe [options]
+  shrinker stats [--json] [--chart] [--dashboard]
+  shrinker last [--path]
+  shrinker raw <capture-id> [--path]
+  shrinker help
+
+Options:
+  --kind <auto|git-status|git-diff|git-log|git-list|npm|tail|find|rg|docker|kubectl|cat|gh|test|log>
+  --max-lines <number>       default: 120
+  --per-file-lines <number>  default: 40
+  --raw                      bypass filtering
+  --metrics                  print per-run savings and duration
+  --no-save                  do not save omitted raw output
+  --no-stats                 do not record this run
+  --dashboard                write a browser dashboard to ~/.shrinker/dashboard.html
+  --help`;
+}
+function parsePositiveInteger(value, option) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${option} requires a positive integer`);
+    }
+    return parsed;
+}
+function parseArgs(args) {
+    const first = args[0];
+    let mode;
+    if (!first || first === "help" || first === "--help" || first === "-h") {
+        if (first)
+            args.shift();
+        mode = "help";
+    }
+    else if (first === "exec" ||
+        first === "pipe" ||
+        first === "stats" ||
+        first === "last" ||
+        first === "raw") {
+        const reserved = args.shift();
+        mode = reserved === "raw" ? "raw-output" : reserved;
+    }
+    else {
+        mode = "exec";
+    }
+    let kind = "auto";
+    let raw = false;
+    let save = true;
+    let trackStats = true;
+    let showMetrics = false;
+    let json = false;
+    let chart = false;
+    let dashboard = false;
+    let showPath = false;
+    let captureId;
+    let maxLines = 120;
+    let perFileLines = 40;
+    while (args.length > 0 && args[0] !== "--") {
+        const option = args.shift();
+        if (option === "--help" || option === "-h") {
+            mode = "help";
+            break;
+        }
+        if (option === "--raw")
+            raw = true;
+        else if (option === "--metrics")
+            showMetrics = true;
+        else if (option === "--no-save")
+            save = false;
+        else if (option === "--no-stats")
+            trackStats = false;
+        else if (option === "--json" && mode === "stats")
+            json = true;
+        else if (option === "--chart" && mode === "stats")
+            chart = true;
+        else if (option === "--dashboard" && mode === "stats")
+            dashboard = true;
+        else if (option === "--path" && mode === "last")
+            showPath = true;
+        else if (option === "--path" && mode === "raw-output")
+            showPath = true;
+        else if (mode === "raw-output" && option && !option.startsWith("-") && !captureId) {
+            captureId = option;
+        }
+        else if (option === "--kind") {
+            const value = args.shift();
+            if (!value ||
+                ![
+                    "auto",
+                    "git-status",
+                    "git-diff",
+                    "git-log",
+                    "git-list",
+                    "npm",
+                    "tail",
+                    "find",
+                    "rg",
+                    "docker",
+                    "kubectl",
+                    "cat",
+                    "gh",
+                    "test",
+                    "log",
+                ].includes(value)) {
+                throw new Error("--kind must be auto, git-status, git-diff, git-log, git-list, npm, tail, find, rg, docker, kubectl, cat, gh, test, or log");
+            }
+            kind = value;
+        }
+        else if (option === "--max-lines") {
+            maxLines = parsePositiveInteger(args.shift(), "--max-lines");
+        }
+        else if (option === "--per-file-lines") {
+            perFileLines = parsePositiveInteger(args.shift(), "--per-file-lines");
+        }
+        else if (mode === "exec" && option && !option.startsWith("-")) {
+            args.unshift(option);
+            break;
+        }
+        else {
+            throw new Error(`Unknown option: ${option}\n\n${usage()}`);
+        }
+    }
+    if (args[0] === "--")
+        args.shift();
+    if (mode === "exec" && args.length === 0)
+        throw new Error("exec requires a command");
+    if (mode === "stats" && args.length > 0)
+        throw new Error("stats does not accept command arguments");
+    if (mode === "last" && args.length > 0)
+        throw new Error("last does not accept command arguments");
+    if (mode === "raw-output" && !captureId)
+        throw new Error("raw requires a capture ID");
+    return {
+        mode,
+        kind,
+        raw,
+        save,
+        trackStats,
+        showMetrics,
+        json,
+        chart,
+        dashboard,
+        showPath,
+        ...(captureId ? { captureId } : {}),
+        maxLines,
+        perFileLines,
+        command: args,
+    };
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function render(rawOutput, options, durationMs, exitCode) {
+    if (options.raw) {
+        process.stdout.write(rawOutput);
+        return;
+    }
+    let result;
+    try {
+        result = applyFilter(rawOutput, options.kind, options.command, { maxLines: options.maxLines, perFileLines: options.perFileLines });
+    }
+    catch (error) {
+        process.stderr.write(`[shrinker] filter failed; returning raw output: ${String(error)}\n`);
+        process.stdout.write(rawOutput);
+        return;
+    }
+    const output = cleanText(result.output);
+    const measurements = measure(rawOutput, output);
+    process.stdout.write(`${output}\n`);
+    if (options.showMetrics) {
+        process.stderr.write(`${formatMeasurements(measurements, durationMs)}\n`);
+    }
+    if (options.trackStats) {
+        try {
+            recordRun({
+                mode: options.mode === "pipe" ? "pipe" : "exec",
+                filterKind: result.kind,
+                commandName: options.mode === "pipe" ? "stdin" : path.basename(options.command[0] ?? "unknown"),
+                measurements,
+                ...(durationMs === undefined ? {} : { durationMs }),
+                omitted: result.omitted,
+                ...(exitCode === undefined ? {} : { exitCode }),
+            });
+        }
+        catch (error) {
+            process.stderr.write(`[shrinker] could not record stats: ${String(error)}\n`);
+        }
+    }
+    const isWrappedGitLog = options.mode === "exec" && result.kind === "git-log";
+    const shouldSave = result.recovery !== "threshold" && !isWrappedGitLog;
+    if (result.omitted && options.save && shouldSave) {
+        try {
+            const capture = await saveRawOutput(rawOutput, options.command);
+            process.stderr.write(`[full: shrinker raw ${capture.id}]\n`);
+        }
+        catch (error) {
+            process.stderr.write(`[shrinker] could not save full output: ${String(error)}\n`);
+        }
+    }
+}
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.mode === "help") {
+        process.stdout.write(`${usage()}\n`);
+        return;
+    }
+    if (options.mode === "stats") {
+        const summary = getStats(defaultStatsPath());
+        if (options.dashboard) {
+            const dashboardPath = writeStatsDashboard(summary);
+            process.stdout.write(`Dashboard written to: ${dashboardPath}\n`);
+            openStatsDashboard(dashboardPath);
+            return;
+        }
+        const output = options.json ? JSON.stringify(summary, null, 2) : options.chart ? formatStatsChart(summary) : formatStats(summary);
+        process.stdout.write(`${output}\n`);
+        return;
+    }
+    if (options.mode === "last") {
+        const latest = await getLatestRawOutput();
+        if (!latest)
+            throw new Error("No saved raw output");
+        process.stdout.write(options.showPath ? `${latest.path}\n` : latest.output);
+        return;
+    }
+    if (options.mode === "raw-output") {
+        const capture = await getRawOutput(options.captureId ?? "");
+        if (!capture)
+            throw new Error(`Raw capture not found: ${options.captureId}`);
+        process.stdout.write(options.showPath ? `${capture.path}\n` : capture.output);
+        return;
+    }
+    if (options.mode === "pipe") {
+        const input = await readStdin();
+        await render(input, options);
+        return;
+    }
+    const [command, ...args] = options.command;
+    if (!command)
+        throw new Error("Missing command");
+    const result = await runCommand(command, args);
+    await render(result.combined, options, result.durationMs, result.exitCode);
+    process.exitCode = result.exitCode;
+}
+main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 2;
+});
+//# sourceMappingURL=cli.js.map

package/dist/src/execution/raw-output-store.js

@@ -0,0 +1,132 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, stat, utimes, writeFile, } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const MAX_FILES = 20;
+const LOCK_STALE_MS = 30_000;
+export function defaultRawDirectory() {
+    return path.join(os.homedir(), ".shrinker", "raw");
+}
+function safeSlug(command) {
+    return path
+        .basename(command[0] ?? "output")
+        .replace(/[^a-zA-Z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 60) || "output";
+}
+export async function saveRawOutput(output, command, directory = defaultRawDirectory()) {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const id = randomUUID().slice(0, 8);
+    const fileName = `${Date.now()}_${id}_${safeSlug(command)}.log`;
+    const filePath = path.join(directory, fileName);
+    const temporaryPath = `${filePath}.${process.pid}.tmp`;
+    let published = false;
+    try {
+        await writeFile(temporaryPath, output, { encoding: "utf8", mode: 0o600 });
+        await rename(temporaryPath, filePath);
+        published = true;
+        const publishedAt = new Date();
+        await utimes(filePath, publishedAt, publishedAt);
+        await cleanStaleTemporaryFiles(directory);
+        const captures = await listCaptures(directory);
+        const excess = Math.max(0, captures.length - MAX_FILES);
+        const stale = captures.filter((capture) => capture.filePath !== filePath).slice(0, excess);
+        for (const capture of stale) {
+            await rm(capture.filePath, { force: true });
+        }
+    }
+    catch (error) {
+        if (!published)
+            await rm(temporaryPath, { force: true });
+        throw error;
+    }
+    return { id, path: filePath, output };
+}
+export async function getLatestRawOutput(directory = defaultRawDirectory()) {
+    const captures = await listCaptures(directory);
+    for (const capture of captures.reverse()) {
+        const result = await readCaptureIfPresent(capture.filePath);
+        if (result)
+            return result;
+    }
+    return undefined;
+}
+export async function getRawOutput(id, directory = defaultRawDirectory()) {
+    if (!/^[a-f0-9]{8}$/i.test(id))
+        return undefined;
+    const captures = await listCaptures(directory);
+    const normalizedId = id.toLowerCase();
+    const match = captures.find(({ filePath }) => path.basename(filePath).split("_")[1]?.toLowerCase() === normalizedId);
+    return match ? readCaptureIfPresent(match.filePath) : undefined;
+}
+async function readCapture(filePath) {
+    const id = path.basename(filePath).split("_")[1] ?? "";
+    return { id, path: filePath, output: await readFile(filePath, "utf8") };
+}
+async function readCaptureIfPresent(filePath) {
+    try {
+        return await readCapture(filePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function listCaptures(directory) {
+    let files;
+    try {
+        files = (await readdir(directory, { withFileTypes: true }))
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".log"))
+            .map((entry) => entry.name);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const captures = await Promise.all(files.map(async (file) => {
+        const filePath = path.join(directory, file);
+        try {
+            return { filePath, modifiedAt: (await stat(filePath)).mtimeMs };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }));
+    return captures.filter((capture) => capture !== undefined).sort((left, right) => left.modifiedAt - right.modifiedAt || left.filePath.localeCompare(right.filePath));
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        return code !== "ESRCH" && code !== "EINVAL";
+    }
+}
+async function cleanStaleTemporaryFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    await Promise.all(entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".tmp"))
+        .map(async (entry) => {
+        const temporaryPath = path.join(directory, entry.name);
+        try {
+            const metadata = await stat(temporaryPath);
+            const pidMatch = entry.name.match(/\.(\d+)\.tmp$/);
+            const ownerPid = pidMatch ? Number.parseInt(pidMatch[1] ?? "", 10) : undefined;
+            if (Date.now() - metadata.mtimeMs > LOCK_STALE_MS &&
+                (!ownerPid || !isProcessAlive(ownerPid))) {
+                await rm(temporaryPath, { force: true });
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }));
+}
+//# sourceMappingURL=raw-output-store.js.map