rich-parallel-agents 0.1.0

package/dist/store.d.ts

@@ -0,0 +1,30 @@
+import { GateError } from "./errors.js";
+import type { EventType, RpaConfig, RunState } from "./types.js";
+export declare const CURRENT_FILE = "current";
+export declare const RPA_VERSION = "0.1.0";
+export type StoreErrorKind = "no-current" | "missing-state" | "unreadable-state" | "malformed-state" | "invalid-state";
+export declare class StoreError extends GateError {
+    readonly kind: StoreErrorKind;
+    constructor(kind: StoreErrorKind, message: string);
+}
+export declare function resolveStoreDir(store?: string, cwd?: string): string;
+export declare function runDir(storeDir: string, runId: string): string;
+export declare function createRun(storeDir: string, input: {
+    repo: string;
+    config: RpaConfig;
+    id?: string;
+    objective?: string;
+    planner?: string;
+}): Promise<RunState>;
+export declare function persist(storeDir: string, run: RunState, event?: {
+    type: EventType;
+    taskId?: string;
+    attemptId?: string;
+    payload?: Record<string, unknown>;
+}): Promise<void>;
+export declare function saveRun(storeDir: string, run: RunState): Promise<void>;
+export declare function loadRun(storeDir: string, runId?: string): Promise<RunState>;
+export declare function writeManifest(storeDir: string, run: RunState): Promise<void>;
+export declare function writePlanFile(storeDir: string, run: RunState): Promise<void>;
+export declare function readCurrent(storeDir: string): Promise<string>;
+export declare function listRunDirs(storeDir: string): Promise<string[]>;

package/dist/store.js

@@ -0,0 +1,368 @@
+import { lstat, mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { GateError } from "./errors.js";
+import { appendEvent } from "./journal.js";
+import { heartbeat } from "./resources.js";
+export const CURRENT_FILE = "current";
+export const RPA_VERSION = "0.1.0";
+export class StoreError extends GateError {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.kind = kind;
+        this.name = "StoreError";
+    }
+}
+export function resolveStoreDir(store, cwd = process.cwd()) {
+    if (store)
+        return path.resolve(cwd, store);
+    if (process.env.RPA_STORE)
+        return path.resolve(process.env.RPA_STORE);
+    return path.resolve(cwd, ".rpa");
+}
+export function runDir(storeDir, runId) {
+    return path.join(storeDir, "runs", runId);
+}
+export async function createRun(storeDir, input) {
+    const id = input.id ?? newRunId();
+    const repo = path.resolve(input.repo);
+    const run = {
+        id,
+        repo,
+        createdAt: new Date().toISOString(),
+        status: "running",
+        config: input.config,
+        tasks: {},
+        objective: input.objective,
+        planner: input.planner,
+        resources: [],
+    };
+    heartbeat(run);
+    await saveRun(storeDir, run);
+    await writeManifest(storeDir, run);
+    await writeFile(path.join(storeDir, CURRENT_FILE), `${id}\n`, "utf8");
+    await appendEvent(storeDir, {
+        runId: id,
+        type: "RUN_CREATED",
+        payload: { repo, objective: input.objective ?? null },
+    });
+    return run;
+}
+export async function persist(storeDir, run, event) {
+    heartbeat(run);
+    await saveRun(storeDir, run);
+    if (event) {
+        await appendEvent(storeDir, { runId: run.id, ...event });
+    }
+}
+export async function saveRun(storeDir, run) {
+    run.resources ??= [];
+    const dir = runDir(storeDir, run.id);
+    await mkdir(dir, { recursive: true });
+    const file = path.join(dir, "state.json");
+    const tmp = `${file}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(run, null, 2)}\n`, "utf8");
+    await rename(tmp, file);
+}
+export async function loadRun(storeDir, runId) {
+    const id = runId ?? (await readCurrent(storeDir));
+    const file = path.join(runDir(storeDir, id), "state.json");
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (err) {
+        if (isNotFound(err)) {
+            throw new StoreError("missing-state", `run state is missing for ${id}: ${file}; restore the state file or select a valid run with --run`);
+        }
+        throw new StoreError("unreadable-state", `run state is unreadable for ${id}: ${file}: ${errorMessage(err)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new StoreError("malformed-state", `run state contains malformed JSON for ${id}: ${file}: ${errorMessage(err)}`);
+    }
+    if (!isRunState(parsed, id)) {
+        throw new StoreError("invalid-state", `run state is corrupt for ${id}: ${file}; required run, config, task, attempt, or resource fields are structurally invalid`);
+    }
+    return parsed;
+}
+export async function writeManifest(storeDir, run) {
+    const manifest = {
+        runId: run.id,
+        repo: run.repo,
+        baseSha: run.baseSha,
+        planner: run.planner,
+        rpaVersion: RPA_VERSION,
+        createdAt: run.createdAt,
+        objective: run.objective,
+    };
+    await mkdir(runDir(storeDir, run.id), { recursive: true });
+    await writeFile(path.join(runDir(storeDir, run.id), "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+export async function writePlanFile(storeDir, run) {
+    if (!run.plan)
+        return;
+    await mkdir(runDir(storeDir, run.id), { recursive: true });
+    await writeFile(path.join(runDir(storeDir, run.id), "plan.json"), `${JSON.stringify(run.plan, null, 2)}\n`, "utf8");
+}
+export async function readCurrent(storeDir) {
+    const file = path.join(storeDir, CURRENT_FILE);
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (err) {
+        if (isNotFound(err) && !(await pathExists(file))) {
+            throw new StoreError("no-current", "no current run; pass --run or run rpa init");
+        }
+        throw new StoreError("unreadable-state", `current run pointer is unreadable: ${file}: ${errorMessage(err)}`);
+    }
+    const id = raw.trim();
+    if (!id) {
+        throw new StoreError("unreadable-state", `current run pointer is empty: ${file}; restore it or pass --run`);
+    }
+    return id;
+}
+export async function listRunDirs(storeDir) {
+    try {
+        const entries = await readdir(path.join(storeDir, "runs"), { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+function newRunId() {
+    const now = new Date();
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `run-${stamp}-${rand}`;
+}
+function isNotFound(err) {
+    return Boolean(err && typeof err === "object" && "code" in err && err.code === "ENOENT");
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function pathExists(file) {
+    try {
+        await lstat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const RUN_STATUSES = new Set([
+    "planned",
+    "running",
+    "partial",
+    "blocked",
+    "failed",
+    "success",
+    "cleaning",
+    "cleaned",
+]);
+const TASK_STATUSES = new Set([
+    "planned",
+    "dispatched",
+    "claimed",
+    "verifying",
+    "accepted",
+    "retrying",
+    "blocked",
+    "integrated",
+    "repairing",
+]);
+const WORKER_OUTCOMES = new Set(["pending", "succeeded", "failed"]);
+const DISPATCH_PHASES = new Set(["intent", "task-created", "worker-started", "failed"]);
+const RESOURCE_KINDS = new Set(["worktree", "terminal", "dispatch", "run"]);
+const INTEGRATION_STATUSES = new Set([
+    "pending",
+    "merging",
+    "verifying",
+    "passed",
+    "failed",
+    "conflict",
+    "repairing",
+]);
+const ERROR_CLASSES = new Set([
+    "assertion",
+    "typecheck",
+    "lint",
+    "timeout",
+    "crash",
+    "merge_conflict",
+    "ambiguous",
+    "environment",
+    "permission",
+    "credential",
+    "flaky",
+    "unknown",
+]);
+function isRunState(value, id) {
+    if (!isRecord(value))
+        return false;
+    if (value.id !== id ||
+        !isNonEmptyString(value.repo) ||
+        !isNonEmptyString(value.createdAt) ||
+        !isMember(value.status, RUN_STATUSES) ||
+        !isConfig(value.config) ||
+        !isRecord(value.tasks) ||
+        !Array.isArray(value.resources) ||
+        (value.integration !== undefined && !isIntegration(value.integration)) ||
+        (value.objective !== undefined && typeof value.objective !== "string") ||
+        (value.planner !== undefined && typeof value.planner !== "string") ||
+        (value.baseSha !== undefined && !isSha(value.baseSha)) ||
+        (value.lastHeartbeatAt !== undefined && !isNonEmptyString(value.lastHeartbeatAt))) {
+        return false;
+    }
+    for (const [taskId, task] of Object.entries(value.tasks)) {
+        if (!isTask(task, taskId))
+            return false;
+    }
+    return value.resources.every((resource) => isResource(resource, id));
+}
+function isTask(value, taskId) {
+    if (!isRecord(value))
+        return false;
+    if (value.id !== taskId ||
+        !isMember(value.status, TASK_STATUSES) ||
+        !isNonEmptyString(value.worktree) ||
+        !isMember(value.workerOutcome, WORKER_OUTCOMES) ||
+        !Array.isArray(value.attempts) ||
+        !value.attempts.every(isAttempt)) {
+        return false;
+    }
+    if (value.dispatchPhase !== undefined && !isMember(value.dispatchPhase, DISPATCH_PHASES)) {
+        return false;
+    }
+    if (value.status === "dispatched" && value.dispatchPhase === undefined)
+        return false;
+    if (value.dispatchPhase === "task-created" && !isNonEmptyString(value.orcaTaskId))
+        return false;
+    if (value.dispatchPhase === "worker-started" &&
+        (!isNonEmptyString(value.dispatchId) || !isNonEmptyString(value.orcaTaskId))) {
+        return false;
+    }
+    return ((value.dispatchId === undefined || isNonEmptyString(value.dispatchId)) &&
+        (value.agent === undefined || isNonEmptyString(value.agent)) &&
+        (value.headSha === undefined || isSha(value.headSha)) &&
+        (value.dirty === undefined || typeof value.dirty === "boolean") &&
+        (value.lastError === undefined || isNonEmptyString(value.lastError)) &&
+        (value.title === undefined || typeof value.title === "string") &&
+        (value.deliverable === undefined || typeof value.deliverable === "string") &&
+        (value.deps === undefined ||
+            (Array.isArray(value.deps) && value.deps.every(isNonEmptyString))) &&
+        (value.errorClass === undefined || isMember(value.errorClass, ERROR_CLASSES)) &&
+        (value.escalatedFrom === undefined ||
+            (Array.isArray(value.escalatedFrom) && value.escalatedFrom.every(isNonEmptyString))) &&
+        (value.orcaTaskId === undefined || isNonEmptyString(value.orcaTaskId)));
+}
+function isAttempt(value) {
+    if (!isRecord(value))
+        return false;
+    return (Number.isInteger(value.attemptNo) &&
+        value.attemptNo > 0 &&
+        isNonEmptyString(value.startedAt) &&
+        isNonEmptyString(value.finishedAt) &&
+        typeof value.verifyPass === "boolean" &&
+        Array.isArray(value.checks) &&
+        value.checks.every(isCheck) &&
+        (value.flaky === undefined || typeof value.flaky === "boolean") &&
+        (value.errorClass === undefined || isMember(value.errorClass, ERROR_CLASSES)) &&
+        (value.escalatedFrom === undefined || isNonEmptyString(value.escalatedFrom)));
+}
+function isCheck(value) {
+    if (!isRecord(value))
+        return false;
+    return (isNonEmptyString(value.name) &&
+        typeof value.command === "string" &&
+        typeof value.required === "boolean" &&
+        Number.isInteger(value.exitCode) &&
+        typeof value.passed === "boolean" &&
+        typeof value.timedOut === "boolean" &&
+        typeof value.durationMs === "number" &&
+        value.durationMs >= 0 &&
+        typeof value.stdout === "string" &&
+        typeof value.stderr === "string");
+}
+function isResource(value, runId) {
+    if (!isRecord(value))
+        return false;
+    return (isNonEmptyString(value.id) &&
+        isMember(value.kind, RESOURCE_KINDS) &&
+        isNonEmptyString(value.selector) &&
+        value.createdBy === "rpa" &&
+        isNonEmptyString(value.createdAt) &&
+        isNonEmptyString(value.leaseExpiresAt) &&
+        isNonEmptyString(value.lastHeartbeatAt) &&
+        value.runId === runId &&
+        (value.taskId === undefined || isNonEmptyString(value.taskId)) &&
+        (value.cleanedAt === undefined || isNonEmptyString(value.cleanedAt)));
+}
+function isIntegration(value) {
+    if (!isRecord(value))
+        return false;
+    return (isNonEmptyString(value.into) &&
+        isMember(value.status, INTEGRATION_STATUSES) &&
+        (value.baseSha === undefined || isSha(value.baseSha)) &&
+        (value.headSha === undefined || isSha(value.headSha)) &&
+        Array.isArray(value.mergedTaskIds) &&
+        value.mergedTaskIds.every(isNonEmptyString) &&
+        Array.isArray(value.checks) &&
+        value.checks.every(isCheck) &&
+        (value.error === undefined || isNonEmptyString(value.error)));
+}
+function isConfig(value) {
+    if (!isRecord(value))
+        return false;
+    if (!isRecord(value.verify) ||
+        !Array.isArray(value.verify.task) ||
+        !value.verify.task.every(isVerifyCheck) ||
+        !Array.isArray(value.verify.integration) ||
+        !value.verify.integration.every(isVerifyCheck) ||
+        !isRecord(value.retry) ||
+        !isNonNegativeInteger(value.retry.max) ||
+        !isRecord(value.flaky) ||
+        !isNonNegativeInteger(value.flaky.retries) ||
+        !Number.isInteger(value.flaky.requireConsecutivePasses) ||
+        value.flaky.requireConsecutivePasses < 1 ||
+        !isRecord(value.planner) ||
+        (value.planner.command !== undefined && typeof value.planner.command !== "string") ||
+        !isRecord(value.providers) ||
+        !isRecord(value.lease) ||
+        typeof value.lease.ttlMs !== "number" ||
+        value.lease.ttlMs <= 0) {
+        return false;
+    }
+    return Object.values(value.providers).every((provider) => isRecord(provider) && isNonEmptyString(provider.command));
+}
+function isVerifyCheck(value) {
+    if (!isRecord(value))
+        return false;
+    return (isNonEmptyString(value.name) &&
+        typeof value.command === "string" &&
+        typeof value.required === "boolean" &&
+        typeof value.timeoutMs === "number" &&
+        value.timeoutMs > 0 &&
+        (value.provider === undefined || isNonEmptyString(value.provider)));
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isSha(value) {
+    return typeof value === "string" && /^[0-9a-f]{40}$/.test(value);
+}
+function isMember(value, values) {
+    return typeof value === "string" && values.has(value);
+}
+function isNonNegativeInteger(value) {
+    return Number.isInteger(value) && value >= 0;
+}

package/dist/types.d.ts

@@ -0,0 +1,160 @@
+export type WorkerOutcome = "pending" | "succeeded" | "failed";
+export type DispatchPhase = "intent" | "task-created" | "worker-started" | "failed";
+export type TaskStatus = "planned" | "dispatched" | "claimed" | "verifying" | "accepted" | "retrying" | "blocked" | "integrated" | "repairing";
+export type RunStatus = "planned" | "running" | "partial" | "blocked" | "failed" | "success" | "cleaning" | "cleaned";
+export type IntegrationStatus = "pending" | "merging" | "verifying" | "passed" | "failed" | "conflict" | "repairing";
+export type ErrorClass = "assertion" | "typecheck" | "lint" | "timeout" | "crash" | "merge_conflict" | "ambiguous" | "environment" | "permission" | "credential" | "flaky" | "unknown";
+export type EventType = "RUN_CREATED" | "PLAN_CREATED" | "TASK_DISPATCHED" | "WORKER_STARTED" | "WORKER_DONE" | "TASK_CLAIMED" | "VERIFY_FAILED" | "TASK_ACCEPTED" | "RETRY_REQUESTED" | "INTEGRATION_STARTED" | "INTEGRATION_CONFLICT" | "INTEGRATION_FAILED" | "REPAIR_STARTED" | "RUN_FAILED" | "RUN_SUCCEEDED" | "RUN_RESUMED" | "RESOURCE_CLEANED" | "HEARTBEAT";
+export type VerifyCheck = {
+    name: string;
+    command: string;
+    required: boolean;
+    timeoutMs: number;
+    provider?: string;
+};
+export type FlakyConfig = {
+    retries: number;
+    requireConsecutivePasses: number;
+};
+export type PlannerConfig = {
+    command?: string;
+};
+export type ProviderConfig = {
+    command: string;
+};
+export type LeaseConfig = {
+    ttlMs: number;
+};
+export type RpaConfig = {
+    verify: {
+        task: VerifyCheck[];
+        integration: VerifyCheck[];
+    };
+    retry: {
+        max: number;
+    };
+    flaky: FlakyConfig;
+    planner: PlannerConfig;
+    providers: Record<string, ProviderConfig>;
+    lease: LeaseConfig;
+};
+export type CheckResult = {
+    name: string;
+    command: string;
+    required: boolean;
+    exitCode: number;
+    passed: boolean;
+    timedOut: boolean;
+    durationMs: number;
+    stdout: string;
+    stderr: string;
+    provider?: string;
+};
+export type Attempt = {
+    attemptNo: number;
+    startedAt: string;
+    finishedAt: string;
+    verifyPass: boolean;
+    checks: CheckResult[];
+    flaky?: boolean;
+    errorClass?: ErrorClass;
+    escalatedFrom?: string;
+};
+export type TaskState = {
+    id: string;
+    status: TaskStatus;
+    worktree: string;
+    dispatchPhase?: DispatchPhase;
+    dispatchId?: string;
+    agent?: string;
+    workerOutcome: WorkerOutcome;
+    headSha?: string;
+    dirty?: boolean;
+    attempts: Attempt[];
+    lastError?: string;
+    title?: string;
+    deliverable?: string;
+    deps?: string[];
+    errorClass?: ErrorClass;
+    escalatedFrom?: string[];
+    orcaTaskId?: string;
+};
+export type IntegrationState = {
+    into: string;
+    status: IntegrationStatus;
+    baseSha?: string;
+    headSha?: string;
+    mergedTaskIds: string[];
+    checks: CheckResult[];
+    error?: string;
+};
+export type ResourceRecord = {
+    id: string;
+    kind: "worktree" | "terminal" | "dispatch" | "run";
+    selector: string;
+    createdBy: "rpa";
+    createdAt: string;
+    leaseExpiresAt: string;
+    lastHeartbeatAt: string;
+    runId: string;
+    taskId?: string;
+    cleanedAt?: string;
+};
+export type PlanTask = {
+    id: string;
+    title: string;
+    agent?: string;
+    mode?: string;
+    scope?: {
+        paths?: string[];
+    };
+    deliverable?: string;
+    verify?: VerifyCheck[];
+    deps?: string[];
+    worktree?: string;
+};
+export type Plan = {
+    objective?: string;
+    planner?: string;
+    tasks: PlanTask[];
+};
+export type JournalEvent = {
+    id: number;
+    runId: string;
+    taskId?: string;
+    attemptId?: string;
+    type: EventType;
+    payload: Record<string, unknown>;
+    createdAt: string;
+};
+export type RunManifest = {
+    runId: string;
+    repo: string;
+    baseSha?: string;
+    planner?: string;
+    rpaVersion: string;
+    createdAt: string;
+    objective?: string;
+};
+export type RunState = {
+    id: string;
+    repo: string;
+    createdAt: string;
+    status: RunStatus;
+    config: RpaConfig;
+    tasks: Record<string, TaskState>;
+    integration?: IntegrationState;
+    objective?: string;
+    planner?: string;
+    plan?: Plan;
+    baseSha?: string;
+    resources: ResourceRecord[];
+    lastHeartbeatAt?: string;
+};
+export type ExecResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+};
+export type ExecFn = (command: string, cwd: string, timeoutMs: number) => Promise<ExecResult>;

package/dist/types.js

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

package/dist/verify.d.ts

@@ -0,0 +1,9 @@
+import type { CheckResult, ExecFn, RpaConfig, VerifyCheck } from "./types.js";
+export declare function runChecks(checks: VerifyCheck[], cwd: string, exec: ExecFn, opts?: {
+    config?: RpaConfig;
+    extra?: Record<string, string>;
+}): Promise<CheckResult[]>;
+export declare function resolveCheckCommand(check: VerifyCheck, config?: RpaConfig, extra?: Record<string, string>): string;
+export declare function interpolate(template: string, vars: Record<string, string>): string;
+export declare function requiredFailed(checks: CheckResult[]): CheckResult | undefined;
+export declare function verifyPassed(checks: CheckResult[]): boolean;

package/dist/verify.js

@@ -0,0 +1,42 @@
+export async function runChecks(checks, cwd, exec, opts = {}) {
+    const results = [];
+    for (const check of checks) {
+        const started = Date.now();
+        const command = resolveCheckCommand(check, opts.config, opts.extra);
+        const output = await exec(command, cwd, check.timeoutMs);
+        results.push({
+            name: check.name,
+            command,
+            required: check.required,
+            exitCode: output.exitCode,
+            passed: output.exitCode === 0 && !output.timedOut,
+            timedOut: output.timedOut,
+            durationMs: Date.now() - started,
+            stdout: output.stdout,
+            stderr: output.stderr,
+            provider: check.provider,
+        });
+    }
+    return results;
+}
+export function resolveCheckCommand(check, config, extra = {}) {
+    const fromProvider = check.provider && config?.providers[check.provider]?.command
+        ? config.providers[check.provider].command
+        : undefined;
+    const command = check.command || fromProvider;
+    if (!command) {
+        throw new Error(check.provider
+            ? `provider ${check.provider} has no command; set providers.${check.provider}.command`
+            : `check ${check.name} has no command`);
+    }
+    return interpolate(command, { cwd: extra.cwd ?? "", base: extra.base ?? "", head: extra.head ?? "", ...extra });
+}
+export function interpolate(template, vars) {
+    return template.replace(/\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g, (_, key) => vars[key] ?? "");
+}
+export function requiredFailed(checks) {
+    return checks.find((check) => check.required && !check.passed);
+}
+export function verifyPassed(checks) {
+    return requiredFailed(checks) === undefined;
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "rich-parallel-agents",
+  "version": "0.1.0",
+  "description": "Verification gate for orca workers. worker_done is a claim until verify passes.",
+  "keywords": [
+    "agents",
+    "orchestration",
+    "verification",
+    "orca"
+  ],
+  "homepage": "https://github.com/agent-infra-for-justn/rich-parallel-agents#readme",
+  "bugs": {
+    "url": "https://github.com/agent-infra-for-justn/rich-parallel-agents/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agent-infra-for-justn/rich-parallel-agents.git"
+  },
+  "type": "module",
+  "bin": {
+    "rpa": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "skills"],
+  "engines": { "node": ">=20" },
+  "packageManager": "pnpm@10.33.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && node --eval \"import('node:fs').then((fs) => fs.chmodSync('dist/cli.js', 0o755))\"",
+    "prepack": "pnpm build",
+    "rpa": "tsx src/cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "commander": "^14.0.0",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}