nilometer 0.0.0-stage → 0.2.0

package/dist/viewer/report.js

@@ -0,0 +1,120 @@
+/**
+ * @file Opening the database and assembling the report's input (docs/development.md P7.1).
+ */
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { openDatabase } from "../core/db/database.js";
+import { DATABASE_FILE } from "../core/ingest/command.js";
+import { resolveDataDir } from "../core/install/locations.js";
+import { securePrivateDataDir } from "../core/install/private-files.js";
+import { checkHook } from "../core/settings/statusline.js";
+import { lastIngestAt, loadObserved, loadProjected } from "./queries.js";
+/** There is no database to report on yet. */
+export class NoDatabaseError extends Error {
+    /**
+     * Creates the error.
+     * @param databasePath - The path that doesn't exist.
+     */
+    constructor(databasePath) {
+        super(`No database at ${databasePath}; run init or ingest first`);
+        this.name = "NoDatabaseError";
+    }
+}
+/**
+ * Opens the data directory's existing database, runs an operation on it, and closes it.
+ * @param options - Where the database lives.
+ * @param use - The operation.
+ * @param onTightened - Called with any data paths made owner-only before reading (D-043).
+ * @returns The operation's result.
+ * @throws {NoDatabaseError} If the data directory has no database yet. Nothing is created.
+ */
+export function withReportDatabase(options, use, onTightened = () => undefined) {
+    const databasePath = join(resolveDataDir({ home: options.home, env: options.env, override: options.dataDirOverride }), DATABASE_FILE);
+    // Reading must not create an empty database and then describe it as "no data yet".
+    if (!existsSync(databasePath)) {
+        throw new NoDatabaseError(databasePath);
+    }
+    // Even a read tightens: an install from before D-043 may still be readable by other accounts.
+    const tightened = securePrivateDataDir(dirname(databasePath));
+    if (tightened.length > 0) {
+        onTightened(tightened);
+    }
+    const db = openDatabase(databasePath, join(options.packageRoot, "core", "schema"));
+    try {
+        return use(db, databasePath);
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Reads everything the report shows from a database that's already open, so a caller can read more
+ * from the same connection (the HTML page, D-070) inside one transaction.
+ * @param db - The open, migrated database.
+ * @param databasePath - Where it lives, carried into the input for the saved copies.
+ * @param options - Display zone and home directory.
+ * @returns The report input.
+ */
+export function readReport(db, databasePath, options) {
+    return {
+        observed: loadObserved(db, options.reportedAt),
+        projected: loadProjected(db, options.reportedAt),
+        timeZone: options.timeZone,
+        lastIngestAt: lastIngestAt(db),
+        databasePath,
+        home: options.home,
+        // Read only: settings are never written here (D-081).
+        missingHookPath: missingHook(options.settingsPath),
+    };
+}
+/**
+ * Checks the status line hook, when there's a settings file to check (D-081).
+ * @param settingsPath - The settings file, or undefined to skip the check.
+ * @returns The missing hook's path; null when present or not ours; undefined when unchecked.
+ */
+function missingHook(settingsPath) {
+    if (settingsPath === undefined) {
+        return undefined;
+    }
+    const check = checkHook(settingsPath);
+    return check.kind === "missing" ? check.hookPath : null;
+}
+/**
+ * Reads everything the report shows.
+ * @param options - Data directory and display zone.
+ * @param onTightened - Called with any data paths made owner-only before reading (D-043).
+ * @returns The report input.
+ * @throws {NoDatabaseError} If the data directory has no database yet. Nothing is created.
+ */
+export function loadReport(options, onTightened = () => undefined) {
+    return withReportDatabase(options, (db, databasePath) => readReport(db, databasePath, options), onTightened);
+}
+/**
+ * Summarizes what is recorded, so a command that deletes it can say what it removed.
+ *
+ * The same sources `ingest` counts from, so the two agree. Deleting this data is not reversible:
+ * it holds copies of session logs Claude Code removes after 30 days, which is the whole reason
+ * ingestion copies them (R2.5).
+ * @param options - Home, environment, package root, and any `--data-dir` override.
+ * @returns The summary, or null when there is no database to read.
+ * @throws {unknown} Whatever opening or reading the database throws, other than a missing one.
+ */
+export function summarizeStoredData(options) {
+    try {
+        return withReportDatabase(options, (db) => db
+            .prepare(`SELECT
+               (SELECT COUNT(*) FROM requests_dedup) AS requests,
+               (SELECT COUNT(*) FROM status_readings WHERE status = 'ok') AS readings,
+               (SELECT MIN(timestamp_utc) FROM requests_dedup) AS firstRequestUtc,
+               (SELECT MAX(timestamp_utc) FROM requests_dedup) AS lastRequestUtc`)
+            .get());
+    }
+    catch (error) {
+        // Nothing recorded yet is not a failure: there is simply nothing to describe.
+        if (error instanceof NoDatabaseError) {
+            return null;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=report.js.map

package/dist/viewer/save.js

@@ -0,0 +1,110 @@
+/**
+ * @file Saving a dated copy of the report (D-030), and with `--html` its HTML page (D-070).
+ *
+ * A report is recomputed from the database on every run, so a saved copy is the only record of what
+ * the screen said at a given time, before later price rows, view changes, or repository re-resolution
+ * (D-020, D-028) change the numbers. Copies hold personal usage and spend figures, so they go to the
+ * data directory with owner-only permissions, never to the working directory (D-043). The HTML page
+ * also embeds the events behind every drawn element, session IDs included, so it gets the same
+ * treatment.
+ *
+ * Implements README "Commands" (`nilometer report --save`) and step G1.4.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { renderReport, reportJson } from "./render.js";
+/** Folder inside the data directory that holds saved reports. */
+export const REPORTS_DIR = "reports";
+/** Most name variants tried for one second before giving up. */
+export const MAX_NAME_ATTEMPTS = 100;
+/**
+ * Builds a saved report's file name stem in the display zone.
+ * @param at - When the report was produced.
+ * @param timeZone - IANA zone the report shows times in.
+ * @returns `report_YYYY-MM-DD_HHMMSS`, which sorts chronologically within one zone.
+ * @example
+ * reportStem(new Date("2026-09-14T00:30:05Z"), "America/Chicago"); // "report_2026-09-13_193005"
+ */
+export function reportStem(at, timeZone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+        hourCycle: "h23",
+    }).formatToParts(at);
+    /**
+     * Finds one part's value.
+     * @param type - Part type.
+     * @returns The value.
+     */
+    const part = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    return `report_${part("year")}-${part("month")}-${part("day")}_${part("hour")}${part("minute")}${part("second")}`;
+}
+/**
+ * Writes one file, failing instead of replacing an existing one.
+ * @param path - Target path.
+ * @param content - File content.
+ * @returns True when written; false when the path already exists.
+ * @throws {Error} For any failure other than the file already existing.
+ */
+function writeNew(path, content) {
+    try {
+        // "wx" fails on an existing file, so two saves in the same second can't overwrite each other.
+        writeFileSync(path, content, { flag: "wx", mode: 0o600 });
+        return true;
+    }
+    catch (error) {
+        if (error.code === "EEXIST") {
+            return false;
+        }
+        throw error;
+    }
+}
+/**
+ * Saves the report as text and JSON under the data directory, and optionally as an HTML page.
+ *
+ * All the files of one save share one stem, so a save's files can be picked out by name alone:
+ * the text file claims the stem, and its twins are written under it.
+ * @param dataDir - The data directory holding the database.
+ * @param input - The report input, as rendered.
+ * @param at - When the report was produced.
+ * @param html - The rendered HTML page (D-070), written as given; no `.html` file is written when
+ *   it's omitted.
+ * @returns The paths written.
+ * @throws {Error} If {@link MAX_NAME_ATTEMPTS} names for this second are all taken, if a twin of a
+ *   newly claimed text file already exists, or if writing fails.
+ */
+export function saveReport(dataDir, input, at, html) {
+    const dir = join(dataDir, REPORTS_DIR);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const stem = reportStem(at, input.timeZone);
+    const text = `${renderReport(input)}\n`;
+    const json = `${JSON.stringify(reportJson(input), null, 2)}\n`;
+    for (let attempt = 1; attempt <= MAX_NAME_ATTEMPTS; attempt += 1) {
+        const name = attempt === 1 ? stem : `${stem}-${attempt}`;
+        const textPath = join(dir, `${name}.txt`);
+        const jsonPath = join(dir, `${name}.json`);
+        if (writeNew(textPath, text)) {
+            // The text file claimed the name; its twins can't exist unless someone made them by hand.
+            if (!writeNew(jsonPath, json)) {
+                throw new Error(`${jsonPath} already exists though ${textPath} didn't`);
+            }
+            if (html === undefined) {
+                return { textPath, jsonPath };
+            }
+            const htmlPath = join(dir, `${name}.html`);
+            // Same rule as the JSON twin: a page found under a claimed stem is never replaced, since it
+            // would then sit beside text it wasn't drawn from.
+            if (!writeNew(htmlPath, html)) {
+                throw new Error(`${htmlPath} already exists though ${textPath} didn't`);
+            }
+            return { textPath, jsonPath, htmlPath };
+        }
+    }
+    throw new Error(`${MAX_NAME_ATTEMPTS} report names for ${stem} are already taken in ${dir}`);
+}
+//# sourceMappingURL=save.js.map

package/docs/requirements.md

@@ -0,0 +1,113 @@
+# Requirements
+
+What Nilometer needs on your computer before you install it, how to check whether you already
+have it, and how to get it if you don't. When everything below checks out, continue with
+[Install and use](../README.md#install-and-use) in the README.
+
+| You need | Why | Check with |
+|---|---|---|
+| **Claude Code**, signed in with a Pro or Max subscription | Nilometer reads what Claude Code records | `claude --version` |
+| **Node.js 24 or 26** (npm comes with it) | Nilometer is built and run with it | `node --version` prints `v24.` or `v26.` followed by more numbers |
+| **git**, only to install from a clone | To download Nilometer's source; `npm install -g nilometer` doesn't need it | `git --version` |
+| **Windows only: Git for Windows** | It provides Git Bash, which the status line hook and every Nilometer command run in | Git Bash is in the Start menu |
+
+## First, open a terminal
+
+- **macOS:** open **Terminal** (in Applications, then Utilities).
+- **Windows:** open **Git Bash** from the Start menu, once Git for Windows is installed (see
+  [git](#git) below). Use Git Bash for every command in this guide and in the README, not
+  PowerShell or Command Prompt.
+- **Linux:** open your terminal.
+
+Run the checks from the table. If one prints `command not found` (or, on Windows, "is not
+recognized"), follow that section below. After installing anything, close the terminal and open a
+new one, so it sees the new program.
+
+## Node.js 24 or 26
+
+Nilometer needs **Node.js 24 or 26**, the long-term support releases it's tested on. If you
+already have one of them, skip this section. If you're installing Node.js now, either works; the
+steps below use 24.
+
+- **Older versions don't work.** Nilometer uses the SQLite built into Node.js, which older
+  versions lack or have only as an experiment, so `nilometer` checks first and stops with a
+  message instead:
+  `Nilometer needs Node.js 24 or newer, and this is Node.js 22.11.0. ...`
+- **Other versions aren't tested.** Nilometer runs on them (25, or anything newer than 26) and
+  prints a one-line warning each time. If anything fails, switch to 24 or 26.
+- **"The latest Node.js" may not be one of them.** nodejs.org also offers newer releases, and
+  `brew install node` installs the newest one. Choose 24 or 26 on purpose, using one of the two
+  ways below.
+
+### The simple way: the official installer (macOS, Windows)
+
+1. Open <https://nodejs.org/dist/latest-v24.x/>. This page always lists the newest release of
+   Node.js 24.
+2. Download the installer for your computer:
+   - **macOS:** the file ending in `.pkg`, for example `node-v24.21.0.pkg`.
+   - **Windows:** the file ending in `-x64.msi`, for example `node-v24.21.0-x64.msi`. On a
+     Windows computer with an ARM processor, use the one ending in `-arm64.msi`.
+3. Open it and accept the defaults.
+4. Open a new terminal and run `node --version`. It should start with `v24.`
+
+If it still shows another version, an earlier Node.js install comes first on your computer.
+Either remove that one, or use a version manager instead.
+
+### The flexible way: a version manager (macOS, Linux, Windows)
+
+A version manager keeps several Node.js versions side by side and switches between them. Use this
+if you already have a different Node.js that other projects need, or if you're on Linux. These
+steps use [fnm](https://github.com/Schniz/fnm).
+
+1. **Install fnm:**
+   - **macOS:** `brew install fnm`, or `curl -fsSL https://fnm.vercel.app/install | bash`
+   - **Linux:** `curl -fsSL https://fnm.vercel.app/install | bash`
+   - **Windows:** in PowerShell, `winget install Schniz.fnm`
+2. **Let your terminal find it.** Add one line to your shell's settings file, unless the install
+   already did (look in the file first):
+   - **zsh** (the macOS default), in `~/.zshrc`: `eval "$(fnm env --use-on-cd --shell zsh)"`
+   - **bash** (Linux, and Git Bash on Windows), in `~/.bashrc`:
+     `eval "$(fnm env --use-on-cd --shell bash)"`
+3. **Install Node.js 24** in a new terminal:
+   ```sh
+   fnm install 24
+   fnm default 24
+   ```
+4. Run `node --version`. It should start with `v24.`
+
+Nilometer's folder contains a `.nvmrc` file that names version 24, so with the line from step 2,
+fnm switches to it whenever you're in that folder.
+
+## git
+
+- **macOS:** run `git --version`. If git isn't installed, macOS offers to install the "command
+  line developer tools", which include it. Accept, then run `git --version` again.
+- **Windows:** install **Git for Windows** from <https://git-scm.com/downloads/win>. The default
+  options are fine. It installs both git and **Git Bash**.
+- **Linux:** use your package manager, for example `sudo apt install git` on Debian or Ubuntu,
+  or `sudo dnf install git` on Fedora.
+
+## Claude Code
+
+Install Claude Code by following Anthropic's guide at <https://code.claude.com/docs/en/setup>.
+Then run `claude` once and sign in with a Pro or Max subscription. `claude --version` should print
+a version number.
+
+- **Use it in a terminal for full results.** Nilometer's usage-window numbers (headroom, peak,
+  burn rate) come from Claude Code's status line, which only runs when Claude Code runs in a
+  terminal. The VS Code extension doesn't run it. Its tokens and limit hits are still read from
+  Claude Code's logs.
+- **Windows:** with Git for Windows installed, Claude Code runs the status line through Git Bash,
+  which Nilometer's hook needs. Without Git for Windows, it uses PowerShell, and the hook can't
+  run.
+
+## When something goes wrong
+
+| What you see | What it means |
+|---|---|
+| `node: command not found`, or `npm: command not found` | Node.js isn't installed, or the terminal was open before you installed it. Open a new terminal. |
+| `Nilometer needs Node.js 24 or newer, and this is Node.js ...` | Your Node.js is older than 24. Install 24 as above. Nothing was changed. |
+| `Nilometer is tested on Node.js 24 or 26, and this is Node.js ...` | Your Node.js is neither. The command still runs. If it fails, switch to 24 or 26. |
+| `EBADENGINE` warnings during `npm ci`, on a Node.js 24 older than 24.15 | Harmless: three development tools ask for a newer 24. The install still succeeds. |
+| `spawn sh ENOENT`, or `sh` not found, on Windows | The command ran in PowerShell or Command Prompt. Run it in Git Bash. |
+| `git: command not found` | Install git as above, then open a new terminal. |

package/hooks/statusline.sh

@@ -0,0 +1,104 @@
+#!/bin/sh
+# nilometer status line hook.
+#
+# Claude Code runs the configured statusLine command after every assistant turn and passes a JSON
+# payload on stdin. This script is a passive tap on that hook (README § How it works, D-008, D-018):
+#
+#   1. Copy stdin to a temp file, so the exact bytes survive both uses below.
+#   2. Run the user's original status line command, if `init` recorded one, on those bytes.
+#      Its stdout, stderr, and exit code pass through unchanged. With no original command,
+#      print a minimal default.
+#   3. Append one spool line:
+#        {"captured_at_s":<epoch seconds>,"hook_version":1,"payload_b64":"<base64 of stdin>"}
+#
+# Never parse or validate the payload (that happens at ingest), never touch SQLite, never use
+# the network, and never let a failure of this script change what the status bar shows.
+#
+# Usage: statusline.sh <data-dir>
+#   <data-dir>/wrapped-command          optional: the original statusLine command, written by `init`
+#   <data-dir>/statusline.spool.jsonl   one line appended per run
+#   <data-dir>/hook-errors.log          one line per failed or refused append (error kind only, no payload)
+#
+# Everything this script creates is owner-only (umask 077): the spool holds status line payloads,
+# and Claude Code keeps its own transcripts owner-only too (D-043). It refuses to append through a
+# symbolic link, so a link planted at the spool path can't redirect payloads elsewhere.
+#
+# POSIX sh only, plus mktemp, cat, date, base64, tr, sed, head (D-018, portability).
+
+# Version of the spool line format. Bump it when the line shape changes, so ingest can tell.
+HOOK_VERSION=1
+
+# Files and directories created below (temp file, data dir, spool, error log) are owner-only (D-043).
+umask 077
+
+# The data directory is the only argument. Without it there is nowhere to record; still pass through.
+data_dir=${1:-}
+
+# Read the original command before touching stdin. $(cat) strips trailing newlines, harmless for a
+# shell command string (unlike the payload).
+#
+# A symlink here is refused (D-050): this file's contents are executed, so following a link would run
+# a command from a file Nilometer doesn't own. `init` only ever writes a regular file.
+wrapped=""
+if [ -n "$data_dir" ] && [ -L "$data_dir/wrapped-command" ]; then
+  if [ ! -L "$data_dir/hook-errors.log" ]; then
+    { printf '%s wrapped-command-symlink-refused\n' "$(date +%s)" >>"$data_dir/hook-errors.log"; } 2>/dev/null
+  fi
+elif [ -n "$data_dir" ] && [ -f "$data_dir/wrapped-command" ]; then
+  wrapped=$(cat "$data_dir/wrapped-command" 2>/dev/null) || wrapped=""
+fi
+
+# The temp file lets one stdin feed both the wrapped command and the spool, byte-exact.
+# Command substitution would strip trailing newlines from the payload (P0.3a spike).
+tmp=$(mktemp "${TMPDIR:-/tmp}/nilometer-hook.XXXXXX" 2>/dev/null) || tmp=""
+if [ -z "$tmp" ]; then
+  # No temp file means no way to both pass the payload on and record it. The status bar wins.
+  if [ -n "$wrapped" ]; then
+    exec /bin/sh -c "$wrapped"
+  fi
+  exit 0
+fi
+# Remove the temp file however the script ends; a signal exits non-zero after cleanup.
+trap 'rm -f "$tmp"' EXIT
+trap 'rm -f "$tmp"; exit 1' HUP INT TERM
+
+cat >"$tmp"
+
+status=0
+if [ -n "$wrapped" ]; then
+  # statusLine.command is a shell string, so it runs under /bin/sh -c, as a shell-spawned command
+  # would. Its output streams straight through; nothing here reads or alters it.
+  /bin/sh -c "$wrapped" <"$tmp"
+  status=$?
+else
+  # Minimal default: the model's display name, if present. Best-effort text extraction; printing
+  # nothing is an acceptable result, and parsing JSON properly is ingest's job, not the hook's.
+  sed -n 's/.*"display_name"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "$tmp" 2>/dev/null | head -n 1
+fi
+
+if [ -n "$data_dir" ] && [ -L "$data_dir/statusline.spool.jsonl" ]; then
+  # A symlinked spool could send payloads to a file Nilometer doesn't own: record the refusal, skip
+  # the append, and leave the status bar untouched. Never log through a symlinked error log either.
+  if [ ! -L "$data_dir/hook-errors.log" ]; then
+    { printf '%s spool-symlink-refused\n' "$(date +%s)" >>"$data_dir/hook-errors.log"; } 2>/dev/null
+  fi
+elif [ -n "$data_dir" ]; then
+  # Build the whole line first so it reaches the spool as one write: concurrent sessions append
+  # to the same file, and a line written in pieces can interleave with another hook's line (D-069).
+  line="{\"captured_at_s\":$(date +%s),\"hook_version\":$HOOK_VERSION,\"payload_b64\":\"$(base64 <"$tmp" | tr -d '\n')\"}"
+  # printf writes a long line in 2048-byte pieces (bash 3.2 as /bin/sh on macOS, observed), and real
+  # lines run 2.5 to 3.5 KB. cat copies a small file with one write, so the line goes into the temp
+  # file first and cat appends it. The temp file is reused: the wrapped command has finished with
+  # the payload and $line holds its base64, so there's no second temp file to create or clean up.
+  # The outer 2>/dev/null must wrap the redirections: a failing `>>` reports its error before any
+  # redirection written after it takes effect (P0.3a spike). mkdir runs only when the dir is missing.
+  if ! { { [ -d "$data_dir" ] || mkdir -p "$data_dir"; } && printf '%s\n' "$line" >"$tmp" && cat "$tmp" >>"$data_dir/statusline.spool.jsonl"; } 2>/dev/null; then
+    # Record the failure where the audit can count it. If even this fails, stay silent.
+    if [ ! -L "$data_dir/hook-errors.log" ]; then
+      { printf '%s append-failed\n' "$(date +%s)" >>"$data_dir/hook-errors.log"; } 2>/dev/null
+    fi
+  fi
+fi
+
+# The wrapped command's exit code is the hook's exit code; appending never changes it.
+exit "$status"

package/package.json

@@ -1,6 +1,63 @@
 {
   "name": "nilometer",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Reports the observed cost of a Claude subscription: interruptions when the plan is too small, unused headroom when it is too big.",
+  "license": "MIT",
+  "author": "Mark Fariñas",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MVFarinas/Nilometer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MVFarinas/Nilometer/issues"
+  },
+  "homepage": "https://github.com/MVFarinas/Nilometer#readme",
+  "type": "module",
+  "bin": {
+    "nilometer": "dist/cli/main.cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "core/schema/*.sql",
+    "core/pricing/prices.json",
+    "hooks/statusline.sh",
+    "docs/requirements.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "start": "tsc -p tsconfig.build.json && node dist/cli/main.cli.js",
+    "dev": "tsx cli/main.cli.ts",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "scan:personal": "tsx scripts/audit/scan-personal.cli.ts",
+    "audit": "tsx scripts/audit/run.cli.ts",
+    "fixtures": "tsx scripts/fixtures/generate.cli.ts",
+    "compare:ccusage": "tsx scripts/compare/ccusage.cli.ts",
+    "fidelity": "python3 scripts/fidelity/reference.py --check fixtures",
+    "fidelity:loader": "tsx scripts/fidelity/loader-check.cli.ts"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^24.13.4",
+    "@vitest/coverage-v8": "^5.0.5",
+    "@vitest/eslint-plugin": "^1.6.27",
+    "eslint": "^10.10.0",
+    "eslint-plugin-jsdoc": "^64.3.10",
+    "prettier": "^3.9.6",
+    "tsx": "^4.23.13",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.70.0",
+    "vitest": "^5.0.5"
+  },
+  "dependencies": {
+    "commander": "^15.0.0"
+  }
+}