@lucascouts/claude-agent-tui 0.1.0

package/dist/usage-env.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Story 042 (R1.1) — the USAGE_UPDATE entrypoint flag parse. Defaults ON: only the explicit
+ * opt-out values "0"/"false" disable it (unset/empty/any other value → ON). Pure + testable;
+ * index.ts calls this so the truth table is unit-checkable without running the entrypoint.
+ */
+export declare function usageUpdateEnabled(env?: Record<string, string | undefined>): boolean;
+//# sourceMappingURL=usage-env.d.ts.map

package/dist/usage-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-env.d.ts","sourceRoot":"","sources":["../src/usage-env.ts"],"names":[],"mappings":"AASA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAe,GAAG,OAAO,CAEjG"}

package/dist/usage-env.js

@@ -0,0 +1,16 @@
+// Story 042 / Task 1.1 (R1.1) — the USAGE_UPDATE entrypoint flag parse. Defaults ON: the optional
+// UNSTABLE `usage_update` notification (src/usage.ts) is emitted by default, and only the explicit
+// opt-out values "0"/"false" disable it (unset / empty / any other value → ON). This FLIPS the
+// story-038 default-OFF posture now that story 039 confirmed the user's Zed ACCEPTS+RENDERS
+// usage_update by code (the ZED-CLIENT-STUDY verdict); the per-session R8 reject latch still guards a
+// client that rejects it. Kept a self-contained, PURE module (cf. usage.ts) so the truth table is
+// unit-checkable without booting the entrypoint; index.ts calls it and threads the result through
+// runAcp → AgentDeps → the agent. It does NOT go through lib.ts (the frozen upstream export surface).
+/**
+ * Story 042 (R1.1) — the USAGE_UPDATE entrypoint flag parse. Defaults ON: only the explicit
+ * opt-out values "0"/"false" disable it (unset/empty/any other value → ON). Pure + testable;
+ * index.ts calls this so the truth table is unit-checkable without running the entrypoint.
+ */
+export function usageUpdateEnabled(env = process.env) {
+    return env.USAGE_UPDATE !== "0" && env.USAGE_UPDATE !== "false";
+}

package/dist/usage.d.ts

@@ -0,0 +1,54 @@
+import type { SessionUpdate } from "@agentclientprotocol/sdk";
+/** The UNSTABLE `usage_update` variant of the SDK 0.22.1 SessionUpdate union. */
+export type UsageUpdateNotification = Extract<SessionUpdate, {
+    sessionUpdate: "usage_update";
+}>;
+/** Defensive view of a JSONL message-event's `usage` block (§7). All fields optional. */
+export interface UsageCarrier {
+    usage?: {
+        input_tokens?: number | null;
+        output_tokens?: number | null;
+    } | null;
+}
+export interface UsageOptions {
+    /**
+     * Total context-window size for the notification's `size` field. The pump supplies
+     * SessionState.contextWindowSize; absent it, `size` best-effort falls back to `used`
+     * (never an invented number — §1 "never fabricate counts").
+     */
+    contextWindowSize?: number;
+}
+/**
+ * Task 3.2 (R3.2) — map a message-event `usage.{input,output}_tokens` into the UNSTABLE
+ * `usage_update` notification. PURE and TOTAL: returns `undefined` (best-effort skip, §1)
+ * when neither token count is present; never throws on a partial/absent usage block.
+ *
+ * Story 042 — the EMITTED SHAPE is pinned to the Zed v1 `UsageUpdate` struct (story 039):
+ * EXACTLY `{ sessionUpdate: "usage_update", size, used }`, camelCase, and nothing more.
+ *   • R2.2 — `used = input_tokens + output_tokens`; `size = contextWindowSize` (the inferred
+ *     window). The `?? used` here is ONLY a library fallback for a caller that omits the window;
+ *     the live pump (acp-agent.ts) ALWAYS supplies `contextWindowSize`, so the live path never
+ *     takes it (the degenerate `size === used` cannot occur over the wire).
+ *   • R3.1 — the optional `cost` field is INTENTIONALLY OMITTED and must NEVER be fabricated:
+ *     the JSONL usage block carries only token counts, and `cost` is optional in the Zed v1 struct,
+ *     so omitting it is contract-correct (an invented cost would violate §1 "never fabricate").
+ */
+export declare function toUsageUpdate(message: UsageCarrier, options?: UsageOptions): UsageUpdateNotification | undefined;
+export interface UsageFlagOptions extends UsageOptions {
+    /** Feature flag (Task 3.1, R3.1) — defaults OFF. When false, NOTHING is constructed. */
+    usageUpdate?: boolean;
+}
+/**
+ * Task 3.1 (R3.1) — the feature-flag gate. Returns the `usage_update` notifications to append
+ * to a turn's session/update stream: an EMPTY array when the flag is OFF, so the stream is
+ * byte-for-byte unaffected by the flag's presence; a single notification when the flag is ON and
+ * the message carries usage tokens. A no-op when OFF — `toUsageUpdate` is not even called — not a
+ * suppressed-after-build.
+ *
+ * Story 042 — the flag DEFAULT is decided by the caller: the entrypoint (src/usage-env.ts,
+ * `usageUpdateEnabled`) now defaults it ON, while a directly-constructed/test agent stays opt-in
+ * (acp-agent.ts `?? false`). Each emitted object is EXACTLY the pinned `{ sessionUpdate, size, used }`
+ * shape (see {@link toUsageUpdate}): no `cost`, and `size` is the inferred window on the live path.
+ */
+export declare function usageUpdatesFor(message: UsageCarrier, options?: UsageFlagOptions): UsageUpdateNotification[];
+//# sourceMappingURL=usage.d.ts.map

package/dist/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../src/usage.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,iFAAiF;AACjF,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC,aAAa,EAAE;IAAE,aAAa,EAAE,cAAc,CAAA;CAAE,CAAC,CAAC;AAEhG,yFAAyF;AACzF,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CAChF;AAED,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE,YAAiB,GACzB,uBAAuB,GAAG,SAAS,CAUrC;AAED,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,wFAAwF;IACxF,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,YAAY,EACrB,OAAO,GAAE,gBAAqB,GAC7B,uBAAuB,EAAE,CAI3B"}

package/dist/usage.js

@@ -0,0 +1,53 @@
+// Story 025 / Group 3 (R3.1, R3.2) — the optional, default-OFF UNSTABLE `usage_update`
+// mapping. `usage_update` exists ONLY in the @agentclientprotocol/sdk 0.22.1 schema and is
+// best-effort per §1; it maps the JSONL message-event `usage.{input,output}_tokens` into the
+// SDK's { sessionUpdate:"usage_update", size, used } shape. The feature defaults OFF and stays
+// OFF in production until the live-Zed acceptance probe (Task 3.3, R8) confirms the user's Zed
+// tolerates it. A rejected emission is suppressed by the pump's per-session latch (Task 5.1).
+//
+// Kept a self-contained module (cf. diff-source.ts) imported by the acp-agent pump; it does
+// NOT go through lib.ts (the frozen upstream export surface).
+/**
+ * Task 3.2 (R3.2) — map a message-event `usage.{input,output}_tokens` into the UNSTABLE
+ * `usage_update` notification. PURE and TOTAL: returns `undefined` (best-effort skip, §1)
+ * when neither token count is present; never throws on a partial/absent usage block.
+ *
+ * Story 042 — the EMITTED SHAPE is pinned to the Zed v1 `UsageUpdate` struct (story 039):
+ * EXACTLY `{ sessionUpdate: "usage_update", size, used }`, camelCase, and nothing more.
+ *   • R2.2 — `used = input_tokens + output_tokens`; `size = contextWindowSize` (the inferred
+ *     window). The `?? used` here is ONLY a library fallback for a caller that omits the window;
+ *     the live pump (acp-agent.ts) ALWAYS supplies `contextWindowSize`, so the live path never
+ *     takes it (the degenerate `size === used` cannot occur over the wire).
+ *   • R3.1 — the optional `cost` field is INTENTIONALLY OMITTED and must NEVER be fabricated:
+ *     the JSONL usage block carries only token counts, and `cost` is optional in the Zed v1 struct,
+ *     so omitting it is contract-correct (an invented cost would violate §1 "never fabricate").
+ */
+export function toUsageUpdate(message, options = {}) {
+    const input = message.usage?.input_tokens;
+    const output = message.usage?.output_tokens;
+    // best-effort: no usage tokens at all -> emit nothing, never fabricate.
+    if ((input === undefined || input === null) && (output === undefined || output === null)) {
+        return undefined;
+    }
+    const used = (input ?? 0) + (output ?? 0);
+    const size = options.contextWindowSize ?? used;
+    return { sessionUpdate: "usage_update", size, used };
+}
+/**
+ * Task 3.1 (R3.1) — the feature-flag gate. Returns the `usage_update` notifications to append
+ * to a turn's session/update stream: an EMPTY array when the flag is OFF, so the stream is
+ * byte-for-byte unaffected by the flag's presence; a single notification when the flag is ON and
+ * the message carries usage tokens. A no-op when OFF — `toUsageUpdate` is not even called — not a
+ * suppressed-after-build.
+ *
+ * Story 042 — the flag DEFAULT is decided by the caller: the entrypoint (src/usage-env.ts,
+ * `usageUpdateEnabled`) now defaults it ON, while a directly-constructed/test agent stays opt-in
+ * (acp-agent.ts `?? false`). Each emitted object is EXACTLY the pinned `{ sessionUpdate, size, used }`
+ * shape (see {@link toUsageUpdate}): no `cost`, and `size` is the inferred window on the live path.
+ */
+export function usageUpdatesFor(message, options = {}) {
+    if (!options.usageUpdate)
+        return []; // flag OFF (default) -> construct nothing
+    const update = toUsageUpdate(message, options);
+    return update ? [update] : [];
+}

package/dist/utils.d.ts

@@ -0,0 +1,16 @@
+import { Readable, Writable } from "node:stream";
+import { WritableStream, ReadableStream } from "node:stream/web";
+import { Logger } from "./acp-agent.js";
+export declare class Pushable<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private done;
+    push(item: T): void;
+    end(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+export declare function nodeToWebWritable(nodeStream: Writable): WritableStream<Uint8Array>;
+export declare function nodeToWebReadable(nodeStream: Readable): ReadableStream<Uint8Array>;
+export declare function unreachable(value: never, logger?: Logger): void;
+export declare function sleep(time: number): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,qBAAa,QAAQ,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IAClD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,SAAS,CAA8C;IAC/D,OAAO,CAAC,IAAI,CAAS;IAErB,IAAI,CAAC,IAAI,EAAE,CAAC;IASZ,GAAG;IAQH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAgB3C;AAGD,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAclF;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC,CAUlF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,MAAgB,QAQjE;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEjD"}

package/dist/utils.js

@@ -0,0 +1,83 @@
+// A pushable async iterable: allows you to push items and consume them with for-await.
+import { WritableStream, ReadableStream } from "node:stream/web";
+// Useful for bridging push-based and async-iterator-based code.
+export class Pushable {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.done = false;
+    }
+    push(item) {
+        if (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve({ value: item, done: false });
+        }
+        else {
+            this.queue.push(item);
+        }
+    }
+    end() {
+        this.done = true;
+        while (this.resolvers.length > 0) {
+            const resolve = this.resolvers.shift();
+            resolve({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    const value = this.queue.shift();
+                    return Promise.resolve({ value, done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+// Helper to convert Node.js streams to Web Streams
+export function nodeToWebWritable(nodeStream) {
+    return new WritableStream({
+        write(chunk) {
+            return new Promise((resolve, reject) => {
+                nodeStream.write(Buffer.from(chunk), (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        },
+    });
+}
+export function nodeToWebReadable(nodeStream) {
+    return new ReadableStream({
+        start(controller) {
+            nodeStream.on("data", (chunk) => {
+                controller.enqueue(new Uint8Array(chunk));
+            });
+            nodeStream.on("end", () => controller.close());
+            nodeStream.on("error", (err) => controller.error(err));
+        },
+    });
+}
+export function unreachable(value, logger = console) {
+    let valueAsString;
+    try {
+        valueAsString = JSON.stringify(value);
+    }
+    catch {
+        valueAsString = value;
+    }
+    logger.error(`Unexpected case: ${valueAsString}`);
+}
+export function sleep(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+}

package/dist/zed-register.d.ts

@@ -0,0 +1,26 @@
+export interface ZedAgentEntry {
+    type: "custom";
+    command: "node";
+    args: [string];
+    env: Record<string, string>;
+}
+/**
+ * Build the single §15 `agent_servers` entry: a custom node spawn of the built
+ * dist/index.js with an EMPTY env (R6.2). Rejects a non-absolute path or a target that
+ * is not the built dist/index.js — a wrong `args[0]` makes the agent un-launchable.
+ */
+export declare function buildZedAgentEntry(absDistPath: string): ZedAgentEntry;
+/**
+ * Tolerant JSONC parse: strip // line comments and block comments that are NOT inside a
+ * string, drop trailing commas, then JSON.parse. String-aware so a `//` or `,` inside a
+ * value is never mangled.
+ */
+export declare function parseJsonc(text: string): any;
+/**
+ * Merge a single `agent_servers[name] = entry` into JSONC settings text, preserving
+ * every other key. Returns canonical JSON text. Idempotent: re-merging the same entry
+ * is a fixed point. (The user's real comment-bearing file is edited surgically instead;
+ * this is the programmatic merge used in tests and tooling.)
+ */
+export declare function mergeAgentServer(settingsText: string, name: string, entry: ZedAgentEntry): string;
+//# sourceMappingURL=zed-register.d.ts.map

package/dist/zed-register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zed-register.d.ts","sourceRoot":"","sources":["../src/zed-register.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAQrE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAmD5C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,MAAM,CAWjG"}

package/dist/zed-register.js

@@ -0,0 +1,106 @@
+// Story 027 / Task 1.2 — Zed `agent_servers` registration helpers (§15, R1.2, R6.2).
+//
+// The fork is registered in Zed by merging ONE `agent_servers` entry into the user's
+// settings.json. Two invariants:
+//   - NON-DESTRUCTIVE: every pre-existing key is preserved (read-modify-write a parsed
+//     copy, never overwrite wholesale).
+//   - env LEFT EMPTY (R6.2): the §15 entry's `env` is `{}` because billing sanitization
+//     is internal to the PTY spawn (story 013) — a single authoritative scrub point.
+//
+// NOTE on JSONC: Zed settings.json is JSONC (// comments + trailing commas). parseJsonc
+// tolerates both for programmatic reads/merges. For the USER'S real file (which also
+// carries header comments worth keeping), registration is applied as a surgical edit
+// that preserves comments; this module is the tested programmatic merge over parsed
+// JSON. No new dependency is added (the frozen base forbids one) — parseJsonc is a
+// minimal, string-aware scrubber, not a full JSONC editor.
+import { isAbsolute } from "node:path";
+/**
+ * Build the single §15 `agent_servers` entry: a custom node spawn of the built
+ * dist/index.js with an EMPTY env (R6.2). Rejects a non-absolute path or a target that
+ * is not the built dist/index.js — a wrong `args[0]` makes the agent un-launchable.
+ */
+export function buildZedAgentEntry(absDistPath) {
+    if (!isAbsolute(absDistPath)) {
+        throw new Error(`Zed agent_servers args[0] must be an ABSOLUTE path, got: ${absDistPath}`);
+    }
+    if (!absDistPath.endsWith("dist/index.js")) {
+        throw new Error(`Zed agent_servers args[0] must point at the built dist/index.js, got: ${absDistPath}`);
+    }
+    return { type: "custom", command: "node", args: [absDistPath], env: {} };
+}
+/**
+ * Tolerant JSONC parse: strip // line comments and block comments that are NOT inside a
+ * string, drop trailing commas, then JSON.parse. String-aware so a `//` or `,` inside a
+ * value is never mangled.
+ */
+export function parseJsonc(text) {
+    let out = "";
+    let inString = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        const next = text[i + 1];
+        if (inLineComment) {
+            if (c === "\n") {
+                inLineComment = false;
+                out += c;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (c === "*" && next === "/") {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            out += c;
+            if (c === "\\") {
+                out += next ?? "";
+                i++;
+            }
+            else if (c === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            out += c;
+            continue;
+        }
+        if (c === "/" && next === "/") {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (c === "/" && next === "*") {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        out += c;
+    }
+    out = out.replace(/,(\s*[}\]])/g, "$1"); // drop trailing commas
+    return JSON.parse(out);
+}
+/**
+ * Merge a single `agent_servers[name] = entry` into JSONC settings text, preserving
+ * every other key. Returns canonical JSON text. Idempotent: re-merging the same entry
+ * is a fixed point. (The user's real comment-bearing file is edited surgically instead;
+ * this is the programmatic merge used in tests and tooling.)
+ */
+export function mergeAgentServer(settingsText, name, entry) {
+    const settings = parseJsonc(settingsText);
+    if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
+        throw new Error("Zed settings root must be a JSON object");
+    }
+    const merged = structuredClone(settings);
+    if (typeof merged.agent_servers !== "object" || merged.agent_servers === null) {
+        merged.agent_servers = {};
+    }
+    merged.agent_servers[name] = entry;
+    return JSON.stringify(merged, null, 2);
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@lucascouts/claude-agent-tui",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.1.0",
+  "description": "ACP agent that drives the Claude Code subscription TUI over a PTY, rendering Claude Code threads in Zed and other ACP-compatible clients.",
+  "main": "dist/lib.js",
+  "types": "dist/lib.d.ts",
+  "bin": {
+    "claude-agent-tui": "dist/index.js"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/lib.d.ts",
+      "import": "./dist/lib.js"
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "dist/",
+    "!dist/tests/",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "package.json"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "acp",
+    "agent",
+    "anthropic",
+    "zed",
+    "tui",
+    "typescript"
+  ],
+  "homepage": "https://github.com/lucascouts/claude-agent-tui#readme",
+  "bugs": {
+    "url": "https://github.com/lucascouts/claude-agent-tui/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lucascouts/claude-agent-tui.git"
+  },
+  "author": "lucascouts",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@agentclientprotocol/sdk": "0.22.1",
+    "@anthropic-ai/claude-agent-sdk": "0.3.156",
+    "node-pty": "1.0.0",
+    "zod": "^3.25.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "0.100.0",
+    "@eslint/js": "10.0.1",
+    "@types/node": "25.9.1",
+    "@typescript-eslint/eslint-plugin": "8.60.0",
+    "@typescript-eslint/parser": "8.60.0",
+    "eslint": "10.4.0",
+    "eslint-config-prettier": "10.1.8",
+    "globals": "17.6.0",
+    "prettier": "3.8.3",
+    "ts-node": "10.9.2",
+    "typescript": "6.0.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "npm run build && npm run start",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check": "npm run lint && npm run format:check",
+    "test": "npm run build && node --experimental-strip-types --test test/*.test.ts"
+  }
+}