agentpack-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Agentpack contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# Agentpack
+
+Local task-state ledger for AI coding agents.
+
+> Coding agents forget. Agentpack gives them the task state they need to continue.
+
+Agentpack helps coding agents continue long-running repo work without rediscovering context, re-reading unchanged sources, or repeating dead ends.
+
+## Product Contract
+
+Agentpack is a local-first open-source tool for repo-scoped coding work. It is not a general AI memory, a knowledge graph, or a chat archive. Instead, it keeps a compact task ledger in `.agentpack/` and exposes that state through simple surfaces:
+
+- files in `.agentpack/`
+- CLI commands
+- a local MCP server
+- project instructions such as `AGENTS.md`, `CLAUDE.md`, and Cursor rules
+
+`.agentpack/` is local task state and is ignored by git by default. Agentpack is designed first for coding agents such as Codex, Claude Code, Cursor, and other MCP clients. Markdown export exists as a fallback for manual handoff, not as the primary workflow.
+
+## v0 Scope
+
+The first version is intentionally small:
+
+- initialize a local `.agentpack/`
+- record decisions, dead ends, evidence, and inspected sources
+- store file hashes so agents can avoid re-reading unchanged files
+- check whether recorded sources are unchanged, changed, or missing
+- create checkpoints with git status, git diff, and generated resume context
+- run a minimal local MCP server for coding-agent clients
+- export a budgeted markdown handoff for manual fallback workflows
+
+## Quick Start
+
+```bash
+npm install -g agentpack-cli
+agentpack init
+agentpack install codex --write
+# or: agentpack install claude --write
+# or: agentpack install cursor --write
+```
+
+Restart or reconnect the coding-agent client. The generated project instructions tell the agent to load Agentpack context at the start, record durable decisions/sources/evidence while working, and checkpoint meaningful progress.
+
+Use `agentpack doctor` to verify the local setup. Use `agentpack resume --preset agent --query "<topic>"` when you want to inspect the task state yourself.
+
+For local development in this repo:
+
+```bash
+fnm use 22
+npm ci --ignore-scripts
+npm test
+npm run mcp:smoke
+node dist/src/agentpack.js --help
+```
+
+If `npm` is not available yet, install Node through `fnm` first:
+
+```bash
+brew install fnm
+fnm install 22
+fnm default 22
+```
+
+Then add this to `~/.zshrc` and restart the terminal:
+
+```bash
+eval "$(fnm env --use-on-cd --shell zsh)"
+```
+
+See [docs/SETUP.md](docs/SETUP.md) for the full setup guide.
+
+This repo uses Agentpack itself through MCP. See [docs/DOGFOOD.md](docs/DOGFOOD.md) for the working protocol.
+
+To verify the local MCP server without configuring an agent client yet:
+
+```bash
+npm run mcp:smoke
+```
+
+The smoke runner creates a temporary Agentpack workspace, starts `agentpack mcp`, sends `initialize`, `tools/list`, and a short `resume` flow, then deletes the temporary workspace.
+
+See [docs/INTEGRATIONS.md](docs/INTEGRATIONS.md) for safe Codex, Claude Code, and Cursor setup.
+See [docs/agentpack-flow.md](docs/agentpack-flow.md) for a visual execution flow.
+
+## Coding-Agent Loop
+
+Agentpack's core loop is built for coding agents working in the same repo over long sessions, compaction, restarts, or handoffs:
+
+```bash
+agentpack resume --preset agent --query "MCP install"
+agentpack source status
+agentpack checkpoint -m "MCP install tested" --status "Ready for docs polish" --next "Update integration docs"
+```
+
+`resume --preset agent` gives the next coding agent the current goal, status, next actions, git state, durable decisions, dead ends, evidence, and source-cache guidance under a rough context budget. `source status` tells the agent which recorded source conclusions are still valid and which files need to be reopened. It compares the current file content to the hash recorded with the source conclusion; it is not a replacement for `git status`. Each recorded source shows hash status and git status separately, and git changes that were never recorded as sources are listed separately.
+
+For manual web-chat fallback, `export --to markdown --preset chat` writes a handoff file under `.agentpack/exports/`. For the normal coding-agent workflow, `resume --preset agent` prints a larger task state directly in the terminal or MCP response. Add `--query` when you want Source Cache to include full summaries for sources relevant to the next task, always include changed/missing source records in full, and keep compact path/status/topic stubs for the rest.
+
+In a new session, start by loading Agentpack MCP context, or by pasting a markdown handoff when MCP is not available. Then inspect only the files marked changed or missing. During work, record durable decisions, failed approaches, evidence, and source conclusions. End a coherent step with a checkpoint so the next agent inherits a compact state instead of a pile of chat history.
+
+## Security Posture
+
+Agentpack keeps the v0 supply chain deliberately small:
+
+- zero runtime dependencies
+- exact dev dependency versions
+- committed `package-lock.json`
+- `ignore-scripts=true`
+- no telemetry
+- no network calls during normal CLI or MCP operation
+- best-effort redaction for common secret-looking values in stored context and handoff outputs
+- npm provenance prepared for future public releases
+
+## Core Idea
+
+Agentpack stores:
+
+- goal and current status
+- next actions
+- decisions
+- dead ends and failed approaches
+- evidence and test outputs
+- relevant files and source conclusions
+- repo name, branch, commit hash, and git diff
+- compact resume context under a rough token budget
+
+The source cache is deliberately lightweight. Agentpack stores metadata, hashes, summaries, and optional snippets, not a full copy of the repository.
+
+## Context Budgets
+
+`--budget` is an approximate token target for generated handoff context. v0 uses a simple estimate, so the number is a practical target, not an exact API token count. Resume output includes estimated usage and a budget status line that says whether any sections were omitted or truncated.
+
+`--query` is an optional local filter for Source Cache. It uses deterministic lexical matching, not embeddings or network calls. Matching sources keep their summaries and snippets; changed or missing source records are always shown in full; non-matching unchanged sources stay visible as compact stubs with path, short topic, hash status, meaning, and guidance. If nothing matches, Agentpack keeps the full Source Cache to avoid false-negative filtering.
+
+Suggested defaults:
+
+- `1200`: quick status ping
+- `4000`: compact manual handoff
+- `8000`: deeper coding-agent handoff
+- `16000`: large debugging session or review
+
+When unsure, start with:
+
+```bash
+agentpack resume --preset quick --query "MCP install"
+agentpack resume --preset agent --query "MCP install"
+```
+
+## MCP
+
+`agentpack mcp` starts a stdio MCP server with tools for reading and writing task state:
+
+- `load_context`
+- `record_decision`
+- `record_dead_end`
+- `attach_evidence`
+- `record_source`
+- `source_status`
+- `checkpoint`
+- `resume`
+- `diff`
+- `replay`
+
+See [docs/MCP.md](docs/MCP.md) for the current MCP contract and smoke-test flow.
+
+## Roadmap
+
+```text
+v0: CLI + local source cache + markdown fallback export
+v1: local MCP server + coding-agent installers
+v2: stronger repo/file hashes, richer retrieval, and smarter budget packing
+v3: shareable .agentpack bundle
+v4: optional hosted sync/share
+```

package/SECURITY.md

@@ -0,0 +1,44 @@
+# Security Policy
+
+Agentpack is designed as a local-first developer tool. The default threat model assumes task state may contain source paths, command output, stack traces, and implementation notes that should stay on the developer machine.
+
+## v0 Security Commitments
+
+- No telemetry.
+- No network calls in normal CLI or MCP operation.
+- No dependency install or download during `agentpack install`.
+- No `postinstall` script.
+- No shell hooks installed silently.
+- No source upload or hosted sync.
+- No full repository copy in `.agentpack/` by default.
+- Runtime package has zero third-party dependencies in v0.
+
+## npm Supply Chain
+
+The project uses a conservative npm setup:
+
+- exact dependency versions
+- committed lockfile
+- `ignore-scripts=true` for installs
+- TypeScript compiler only for builds
+- npm provenance enabled for future public releases
+- trusted publishing preferred over long-lived npm tokens
+
+Before publishing, maintainers should run:
+
+```bash
+npm ci
+npm audit signatures
+npm test
+npm pack --dry-run
+```
+
+## Sensitive Data
+
+Agentpack redacts common secret-looking values and configured environment variable values from generated context and key local records such as source summaries, evidence, checkpoints, replay output, and MCP context responses.
+
+Redaction is best-effort, not a guarantee. Users should treat `.agentpack/` as project-sensitive data and review exported handoff files before sharing them.
+
+## Reporting
+
+Until a public repository security contact exists, report issues privately to the project maintainer.

package/dist/src/agentpack.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/agentpack.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { runCli } from "./cli/index.js";
+runCli(process.argv.slice(2), process.cwd()).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`agentpack: ${message}\n`);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=agentpack.js.map

package/dist/src/agentpack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentpack.js","sourceRoot":"","sources":["../../src/agentpack.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;IACpE,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACvE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,cAAc,OAAO,IAAI,CAAC,CAAC;IAChD,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;AACvB,CAAC,CAAC,CAAC"}

package/dist/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+export type ArgValue = string | boolean | string[];
+export declare function runCli(argv: string[], cwd: string): Promise<void>;
+export declare function resolveMcpStartDir(options: Record<string, ArgValue>, cwd: string): string;

package/dist/src/cli/index.js

@@ -0,0 +1,412 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { createCheckpoint, diffCheckpoints } from "../core/checkpoints.js";
+import { buildResume } from "../core/resume.js";
+import { formatBudgetPresets, resolveBudget } from "../core/presets.js";
+import { buildDoctorReport } from "../core/doctor.js";
+import { redactForRoot } from "../core/redaction.js";
+import { appendEvent, getPackPath, initPack, readState, requirePackRoot, withPackWriteLock, writeState } from "../core/store.js";
+import { addEvidence, addSourceRecord, formatSourceStatuses, getSourceStatuses, replayEvents } from "../operations.js";
+import { installIntegration } from "../integrations/install.js";
+import { startMcpServer } from "../mcp/server.js";
+export async function runCli(argv, cwd) {
+    const command = argv[0];
+    const rest = argv.slice(1);
+    if (!command || command === "--help" || command === "-h") {
+        printHelp();
+        return;
+    }
+    if (command === "--version" || command === "-v") {
+        process.stdout.write(`${readPackageVersion()}\n`);
+        return;
+    }
+    if (command === "init") {
+        const packPath = initPack(cwd);
+        process.stdout.write(`Initialized Agentpack at ${packPath}\n`);
+        return;
+    }
+    if (command === "mcp") {
+        const parsed = parseArgs(rest);
+        startMcpServer(resolveMcpStartDir(parsed.options, cwd));
+        return;
+    }
+    if (command === "doctor") {
+        const report = buildDoctorReport(cwd);
+        process.stdout.write(`${report.text}\n`);
+        process.exitCode = report.ok ? 0 : 1;
+        return;
+    }
+    const root = requirePackRoot(cwd);
+    if (command === "status") {
+        const state = readState(root);
+        process.stdout.write(`${JSON.stringify(state, null, 2)}\n`);
+        return;
+    }
+    if (command === "record") {
+        recordCommand(root, rest);
+        return;
+    }
+    if (command === "note") {
+        noteCommand(root, rest);
+        return;
+    }
+    if (command === "source") {
+        sourceCommand(root, rest);
+        return;
+    }
+    if (command === "evidence") {
+        evidenceCommand(root, rest);
+        return;
+    }
+    if (command === "run") {
+        runCommand(root, rest);
+        return;
+    }
+    if (command === "checkpoint") {
+        const parsed = parseArgs(rest);
+        const checkpoint = createCheckpoint(root, {
+            summary: stringOption(parsed.options.message) || stringOption(parsed.options.m) || stringOption(parsed.options.summary),
+            status: stringOption(parsed.options.status),
+            nextActions: toArray(parsed.options.next)
+        });
+        process.stdout.write(`Created checkpoint ${checkpoint.id}\n`);
+        return;
+    }
+    if (command === "resume") {
+        const parsed = parseArgs(rest);
+        const resume = buildResume(root, {
+            budget: budgetOption(parsed.options),
+            query: stringOption(parsed.options.query)
+        });
+        process.stdout.write(`${resume.markdown}\n`);
+        return;
+    }
+    if (command === "export") {
+        const parsed = parseArgs(rest);
+        const target = stringOption(parsed.options.to) || parsed.positionals[0] || "markdown";
+        const resume = buildResume(root, {
+            budget: budgetOption(parsed.options, 4000),
+            query: stringOption(parsed.options.query)
+        });
+        const filePath = exportPath(root, target);
+        writeFileSync(filePath, resume.markdown, "utf8");
+        process.stdout.write(`Exported ${target} handoff to ${filePath}\n`);
+        return;
+    }
+    if (command === "diff") {
+        const parsed = parseArgs(rest);
+        const diff = diffCheckpoints(root, parsed.positionals[0], parsed.positionals[1]);
+        process.stdout.write(`${redactForRoot(root, diff)}\n`);
+        return;
+    }
+    if (command === "replay") {
+        const parsed = parseArgs(rest);
+        const replay = replayEvents(root, numberOption(parsed.options.limit) || 50);
+        process.stdout.write(`${redactForRoot(root, replay)}\n`);
+        return;
+    }
+    if (command === "install") {
+        const target = rest[0];
+        if (!target) {
+            throw new Error("install requires target: codex, claude, claude-desktop, or cursor");
+        }
+        const parsed = parseArgs(rest.slice(1));
+        const dryRun = installDryRun(parsed.options);
+        const message = installIntegration(root, target, { dryRun });
+        process.stdout.write(`${message}\n`);
+        return;
+    }
+    if (command === "set") {
+        setCommand(root, rest);
+        return;
+    }
+    throw new Error(`Unknown command: ${command}`);
+}
+export function resolveMcpStartDir(options, cwd) {
+    return stringOption(options.root) || process.env.AGENTPACK_ROOT || cwd;
+}
+function printHelp() {
+    process.stdout.write(`Agentpack
+
+Local task-state ledger for AI coding agents.
+
+Usage:
+  agentpack init
+  agentpack set goal <text>
+  agentpack set status <text>
+  agentpack set next <item> [--next <item>]
+  agentpack source add <file> --summary <text>
+  agentpack source status [--json]
+  agentpack record decision <text>
+  agentpack record dead-end <text> --reason <text>
+  agentpack note <text>
+  agentpack evidence add --kind test-output --file test.log
+  agentpack run "npm test"
+  agentpack checkpoint -m <summary> --status <text> --next <item>
+  agentpack resume --preset agent [--query <text>]
+  agentpack export --to markdown --preset chat [--query <text>]
+  agentpack diff [from] [to]
+  agentpack replay
+  agentpack doctor
+  agentpack mcp [--root <path>]
+  agentpack install codex|claude|claude-desktop|cursor [--dry-run|--write]
+  agentpack --version
+  agentpack --help
+
+MCP root resolution: --root, then AGENTPACK_ROOT, then current working directory.
+Budget presets: ${formatBudgetPresets()}
+`);
+}
+function recordCommand(root, rest) {
+    const type = rest[0];
+    const args = rest.slice(1);
+    const parsed = parseArgs(args);
+    const text = stringOption(parsed.options.text) || parsed.positionals.join(" ");
+    if (!isRecordType(type)) {
+        throw new Error("record type must be decision, dead-end, or note");
+    }
+    if (!text) {
+        throw new Error("record requires text");
+    }
+    const event = appendEvent(root, type, {
+        text: redactForRoot(root, text),
+        reason: redactForRoot(root, stringOption(parsed.options.reason) || ""),
+        files: toArray(parsed.options.file),
+        evidence: toArray(parsed.options.evidence)
+    });
+    process.stdout.write(`Recorded ${type} ${event.id}\n`);
+}
+function noteCommand(root, rest) {
+    const parsed = parseArgs(rest);
+    const text = stringOption(parsed.options.text) || parsed.positionals.join(" ");
+    if (!text) {
+        throw new Error("note requires text");
+    }
+    const event = appendEvent(root, "note", { text: redactForRoot(root, text) });
+    process.stdout.write(`Recorded note ${event.id}\n`);
+}
+function sourceCommand(root, rest) {
+    const subcommand = rest[0];
+    const args = rest.slice(1);
+    if (subcommand === "status") {
+        const parsed = parseArgs(args);
+        if (parsed.options.json) {
+            const statuses = JSON.stringify(getSourceStatuses(root), null, 2);
+            process.stdout.write(`${redactForRoot(root, statuses)}\n`);
+        }
+        else {
+            process.stdout.write(`${formatSourceStatuses(root)}\n`);
+        }
+        return;
+    }
+    if (subcommand !== "add") {
+        throw new Error("source command supports `add` and `status`");
+    }
+    const parsed = parseArgs(args);
+    const filePath = parsed.positionals[0];
+    if (!filePath) {
+        throw new Error("source add requires a file path");
+    }
+    const source = addSourceRecord(root, filePath, {
+        summary: stringOption(parsed.options.summary) || stringOption(parsed.options.s) || parsed.positionals.slice(1).join(" "),
+        snippet: stringOption(parsed.options.snippet) || ""
+    });
+    process.stdout.write(`Recorded source ${source.path} (${source.hash.slice(0, 12)})\n`);
+}
+function evidenceCommand(root, rest) {
+    const subcommand = rest[0];
+    const args = rest.slice(1);
+    if (subcommand !== "add") {
+        throw new Error("evidence command supports only `add` in v0");
+    }
+    const parsed = parseArgs(args);
+    const event = addEvidence(root, {
+        kind: stringOption(parsed.options.kind) || "note",
+        file: stringOption(parsed.options.file),
+        content: stringOption(parsed.options.content) || parsed.positionals.join(" "),
+        command: stringOption(parsed.options.command),
+        exitCode: stringOption(parsed.options.exitCode)
+    });
+    process.stdout.write(`Attached evidence ${event.id}\n`);
+}
+function runCommand(root, rest) {
+    const command = rest.join(" ").trim();
+    if (!command) {
+        throw new Error("run requires a command");
+    }
+    const startedAt = new Date().toISOString();
+    const result = spawnSync(command, {
+        cwd: root,
+        shell: true,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024
+    });
+    const stdout = result.stdout || "";
+    const stderr = result.stderr || "";
+    if (stdout) {
+        process.stdout.write(stdout);
+    }
+    if (stderr) {
+        process.stderr.write(stderr);
+    }
+    const exitCode = typeof result.status === "number" ? result.status : 1;
+    const content = [
+        `Command: ${command}`,
+        `Started: ${startedAt}`,
+        `Exit code: ${exitCode}`,
+        "",
+        "## stdout",
+        stdout || "(empty)",
+        "",
+        "## stderr",
+        stderr || "(empty)"
+    ].join("\n");
+    const event = addEvidence(root, {
+        kind: "command-output",
+        content,
+        command,
+        exitCode
+    });
+    process.stdout.write(`\nAttached command evidence ${event.id}\n`);
+    process.exitCode = exitCode;
+}
+function setCommand(root, rest) {
+    const field = rest[0];
+    const args = rest.slice(1);
+    const parsed = parseArgs(args);
+    const text = parsed.positionals.join(" ");
+    withPackWriteLock(root, () => {
+        const state = readState(root);
+        if (field === "goal") {
+            state.goal = redactForRoot(root, text);
+        }
+        else if (field === "status") {
+            state.currentStatus = redactForRoot(root, text);
+        }
+        else if (field === "next") {
+            state.nextActions = [text, ...toArray(parsed.options.next)]
+                .filter(Boolean)
+                .map((item) => redactForRoot(root, item));
+        }
+        else {
+            throw new Error("set supports goal, status, or next");
+        }
+        writeState(root, state);
+    });
+    process.stdout.write(`Updated ${field}\n`);
+}
+function exportPath(root, target) {
+    const normalized = String(target).toLowerCase();
+    const fileName = normalized === "chatgpt" ? "chatgpt-handoff.md" : `${normalized}-handoff.md`;
+    const filePath = getPackPath(root, "exports", fileName);
+    if (!existsSync(path.dirname(filePath))) {
+        throw new Error("Agentpack exports directory is missing. Run `agentpack init` again.");
+    }
+    return filePath;
+}
+function parseArgs(args) {
+    const options = {};
+    const positionals = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const item = args[index];
+        if (!item) {
+            continue;
+        }
+        if (item.startsWith("--")) {
+            const [rawKey, inlineValue] = item.slice(2).split("=", 2);
+            if (!rawKey) {
+                continue;
+            }
+            const value = inlineValue !== undefined ? inlineValue : args[index + 1];
+            if (inlineValue === undefined && value && !value.startsWith("-")) {
+                index += 1;
+                addOption(options, rawKey, value);
+            }
+            else {
+                addOption(options, rawKey, true);
+            }
+            continue;
+        }
+        if (item.startsWith("-") && item.length > 1) {
+            const key = item.slice(1);
+            const value = args[index + 1];
+            if (value && !value.startsWith("-")) {
+                index += 1;
+                addOption(options, key, value);
+            }
+            else {
+                addOption(options, key, true);
+            }
+            continue;
+        }
+        positionals.push(item);
+    }
+    return { options, positionals };
+}
+function addOption(options, key, value) {
+    if (options[key] === undefined) {
+        options[key] = value;
+        return;
+    }
+    if (Array.isArray(options[key])) {
+        const textValue = stringOption(value);
+        if (textValue) {
+            options[key].push(textValue);
+        }
+        return;
+    }
+    options[key] = [...toArray(options[key]), ...toArray(value)];
+}
+function toArray(value) {
+    if (value === undefined || value === true || value === false) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+function stringOption(value) {
+    if (value === undefined || value === true || value === false) {
+        return "";
+    }
+    return Array.isArray(value) ? value[0] || "" : value;
+}
+function numberOption(value) {
+    if (value === undefined || value === true || value === false) {
+        return 0;
+    }
+    const number = Number(value);
+    return Number.isFinite(number) ? number : 0;
+}
+function installDryRun(options) {
+    const dryRun = options["dry-run"] === true;
+    const write = options.write === true;
+    if (dryRun && write) {
+        throw new Error("install accepts either --dry-run or --write, not both");
+    }
+    return !write;
+}
+function budgetOption(options, fallback = 0) {
+    return resolveBudget({
+        budget: numberOption(options.budget),
+        preset: stringOption(options.preset)
+    }, fallback);
+}
+function isRecordType(value) {
+    return value === "decision" || value === "dead-end" || value === "note";
+}
+function readPackageVersion() {
+    // Resolve package.json relative to the compiled CLI file (dist/src/cli/index.js).
+    // Works both in the source tree and after `npm install -g`, because the package
+    // root is always three levels above this file.
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.resolve(here, "..", "..", "..", "package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+//# sourceMappingURL=index.js.map