@jv-k/claude-gauge 0.0.1 → 1.1.0

package/README.md

@@ -1,5 +1,193 @@
-# @jv-k/claude-gauge
+<h1 align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/jv-k/claude-gauge/main/docs/media/wordmark-dark.png">
+    <img src="https://raw.githubusercontent.com/jv-k/claude-gauge/main/docs/media/wordmark-light.png" alt="claude-gauge" width="360">
+  </picture>
+</h1>
 
-This version is a placeholder. It holds the package name so that releases can publish from GitHub Actions through npm trusted publishing. It contains no code.
+<div align="center">
+  <img src="https://raw.githubusercontent.com/jv-k/claude-gauge/main/docs/media/hero.png" alt="The bottom of a Claude Code session: the prompt, and under it the claude-gauge status line with context, 5-hour and weekly usage bars, then the time, session length, repository, branch, model and effort.">
+  <p>
+    <a href="https://www.npmjs.com/package/@jv-k/claude-gauge"><img src="https://img.shields.io/npm/v/%40jv-k%2Fclaude-gauge" alt="npm version"></a>
+    <a href="https://github.com/jv-k/claude-gauge/actions/workflows/test.yml"><img src="https://github.com/jv-k/claude-gauge/actions/workflows/test.yml/badge.svg" alt="Test status"></a>
+    <a href="LICENSE"><img src="https://img.shields.io/badge/licence-MIT-blue.svg" alt="MIT licence"></a>
+  </p>
+  <p>
+    <a href="#how-it-looks"><b>How it looks</b></a> &nbsp;◦&nbsp;
+    <a href="#getting-started"><b>Getting started</b></a> &nbsp;◦&nbsp;
+    <a href="https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md"><b>Full reference</b></a> &nbsp;◦&nbsp;
+    <a href="#upgrading-from-claude-hud"><b>Upgrading from claude-hud</b></a>
+  </p>
+</div>
 
-Source, docs and releases: https://github.com/jv-k/claude-gauge
+**claude-gauge** is a compact status line and token line for [Claude Code](https://code.claude.com), in the terminal, the VS Code extension and the desktop app.
+
+## How it looks
+
+In the terminal, the status line sits under the prompt:
+
+```text
+ctx 43% ▓▓░░░ 86.0k │ 5h 9% ░░┃░░ → 14:10 │ 7d 41% ▓▓░┃░ → 3d
+11:10 │ 1h12m │ jv-k/claude-gauge │ ⎇ main* ↑1 │ Opus 5.5 │ effort high
+```
+
+The token line shows at the end of each turn:
+
+```text
+11:10 │ 4 req │ out 3.4k (1.2k think) │ cache w6.5k r1.69M │ ctx 43% ▓▓░░░ 427k
+```
+
+In VS Code and the desktop app, Claude ends each reply with the same bars:
+
+```text
+ctx 43% ▓▓░░░ 86.0k │ 5h 9% ░░┃░░ → 14:10 │ 7d 41% ▓▓░┃░ → 3d
+11:10 │ 1h12m │ jv-k/claude-gauge │ ⎇ main* ↑1 │ Opus 5.5 │ effort high
+4 req │ out 3.4k (1.2k think) │ cache w6.5k r1.69M │ ctx 43% ▓▓░░░ 427k
+```
+
+## Getting started
+
+You need Claude Code and Node.js 18 or later.
+
+### Install the plugin
+
+In Claude Code, run these three commands:
+
+```text
+/plugin marketplace add jv-k/claude-gauge
+/plugin install claude-gauge@claude-gauge
+/claude-gauge:setup
+```
+
+If Claude Code does not find `/claude-gauge:setup`, run `/reload-plugins` first. Setup asks which bars you want. Then it backs up `~/.claude/settings.json` and adds the bars to it. Start a new session to see them.
+
+### Or install from npm
+
+In a terminal, run:
+
+```sh
+npx @jv-k/claude-gauge setup
+```
+
+Setup shows the status line and asks which parts you want. It draws the status line again after each answer:
+
+![claude-gauge setup in a terminal: it shows the default rows, then draws them again as the answers change the second row, the bar size and the theme.](https://raw.githubusercontent.com/jv-k/claude-gauge/main/docs/media/demo.gif)
+
+### VS Code and the desktop app
+
+The VS Code extension and the desktop app show no custom status line and no token line. To see the bars there, add one SessionStart hook for each bar. In those two apps, the hook tells Claude to end each reply with the bars. In the terminal, it does nothing. First install claude-gauge with the plugin or with npm, as above. Then add the hooks in one of two ways.
+
+#### Ask Claude
+
+Paste this prompt into a Claude Code session:
+
+```text
+Set up claude-gauge for the VS Code extension and the desktop app.
+Read ~/.claude/settings.json, or $CLAUDE_CONFIG_DIR/settings.json when that variable is set.
+Make a backup copy of the file first.
+Find the statusLine command that runs claude-gauge's statusline.js, and the Stop hook that runs its tokenline.js.
+Add two entries to hooks.SessionStart and keep every entry that is there already:
+one runs the same statusline.js with --instruct, and one runs the same tokenline.js with --instruct.
+Put each bar's existing switches after --instruct.
+The status line already shows the time, so give the token line hook a --show without time, such as --show req,out,cache,ctx.
+Test each new command with CLAUDE_CODE_ENTRYPOINT=claude-vscode. It must print an instruction.
+Then tell me to start a new session.
+```
+
+#### Add the hooks by hand
+
+1. Open `~/.claude/settings.json` and find the `statusLine` command that setup wrote. Its folder is `~/.claude/claude-gauge/runtime/` after an npm install, or `~/.claude/claude-gauge/launcher/` after a plugin install.
+2. Add these two entries to the `SessionStart` array under `hooks`, with the folder from step 1. Keep the entries that are there already.
+
+   ```json
+   { "hooks": [ { "type": "command", "command": "node ~/.claude/claude-gauge/runtime/statusline.js --instruct" } ] },
+   { "hooks": [ { "type": "command", "command": "node ~/.claude/claude-gauge/runtime/tokenline.js --instruct --show req,out,cache,ctx" } ] }
+   ```
+
+3. Start a new session.
+
+#### The result
+
+Each reply then ends with the bars, as in [How it looks](#how-it-looks). The token line leaves out its time there, because the status line shows it. To change a bar in the replies, put its switches after `--instruct`, for example `--show 5h,7d`. On a 1M-context model, add `--window 1m` to both hooks. Each reply needs one or two more short tool calls. Uninstall also removes these hooks.
+
+### Change, update or remove the bars
+
+| Plugin | npm | Effect |
+| --- | --- | --- |
+| `/claude-gauge:configure` | `npx @jv-k/claude-gauge configure` | Changes the parts and switches of the bars. |
+| `/plugin`, then **Marketplaces** | `npx @jv-k/claude-gauge@latest update` | Updates claude-gauge and keeps your switches. |
+| `/claude-gauge:uninstall` | `npx @jv-k/claude-gauge uninstall` | Removes claude-gauge and puts back the status line it replaced. |
+
+## Upgrading from claude-hud
+
+If you use [claude-hud](https://github.com/jarrodwatts/claude-hud), run setup as in [Getting started](#getting-started). Setup finds claude-hud's status line, shows it, and asks before it replaces it. It saves claude-hud's command, so uninstall puts claude-hud back. Keep the claude-hud plugin installed until you are sure, because that command needs it.
+
+claude-gauge has no configuration file. Each claude-hud option becomes a part or a switch in the bar's command. The reference [maps each option](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#upgrading-from-claude-hud) to claude-gauge.
+
+## What the bars show
+
+The status line shows these parts by default:
+
+| Part | Example | Shows |
+| --- | --- | --- |
+| `ctx` | `ctx 43% ▓▓░░░ 86.0k` | How much of the context window is in use. |
+| `5h` | `5h 9% ░░┃░░ → 14:10` | Your 5-hour usage, and the time the window resets. |
+| `7d` | `7d 41% ▓▓░┃░ → 3d` | Your weekly usage, and the days until it resets. |
+| `time` | `11:10` | The local time. |
+| `duration` | `1h12m` | How long the session has run. |
+| `repo` | `jv-k/claude-gauge` | The repository, or the folder name. |
+| `branch` | `⎇ main* ↑1` | The git branch. `*` means changes, and `↑1` means one commit ahead of the remote. |
+| `model` | `Opus 5.5` | The model. |
+| `effort` | `effort high` | The reasoning effort. |
+
+The pace marker `┃` shows how much of the window has passed. Its colour shows where your usage goes at the current pace. Green stays well under the limit. Red and purple go over it.
+
+Other parts show the tools and subagents in use, todos, git changes, pull requests, the cost per day and week, memory use and more.
+
+> [!TIP]
+> The reference describes [all 40 parts](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#what-the-bars-show), with what each one shows and when.
+
+## Customise
+
+Each bar takes switches in its `command` in your settings. `configure` writes them for you. Two examples:
+
+```text
+--show 5h,7d
+
+5h 9% ░░┃░░ → 14:10 │ 7d 41% ▓▓░┃░ → 3d
+```
+
+```text
+--show ctx,5h,7d --show repo,branch,pr,lines --show model,effort,cost,cache
+
+ctx 43% ▓▓░░░ 86.0k │ 5h 9% ░░┃░░ → 14:10 │ 7d 41% ▓▓░┃░ → 3d
+jv-k/claude-gauge │ ⎇ main │ #12 approved │ +156 −23
+Opus 5.5 │ effort high │ $1.23 │ cache 91% warm
+```
+
+Each `--show` is one row.
+
+> [!TIP]
+> The reference lists [every switch](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#options), the four [themes](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#themes) and [more examples](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#examples).
+
+## Full reference
+
+[docs/reference.md](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md) has everything this page leaves out:
+
+- [Every status line part](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#what-the-bars-show), and the [token line's parts](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#token-line)
+- [Every switch](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#options), the [themes](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#themes), [colours and bar characters](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#colours-and-bar-characters), and [examples](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#examples)
+- [Other ways to install](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#install): with a Claude prompt, or by hand from a clone
+- [Update](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#update) and [uninstall](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#uninstall) for each install route
+- [The claude-hud option map](https://github.com/jv-k/claude-gauge/blob/main/docs/reference.md#upgrading-from-claude-hud)
+
+## Contributing
+
+[CONTRIBUTING.md](CONTRIBUTING.md) gives the setup, the tests and the rules for a change. [RELEASING.md](RELEASING.md) gives the release steps.
+
+## Star history
+
+[![Star history of jv-k/claude-gauge](https://api.star-history.com/svg?repos=jv-k/claude-gauge&type=Date)](https://star-history.com/#jv-k/claude-gauge&Date)
+
+## License
+
+[MIT](LICENSE)

package/dist/cli.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+"use strict";
+// The claude-gauge command: sets the bars up in Claude Code's settings,
+// changes their switches, takes them out again, and updates the copy of the
+// scripts that the settings run.
+//
+//   claude-gauge setup
+//   claude-gauge setup --yes
+//   claude-gauge setup --status-line "--show ctx,5h,7d --segments 10" --token-line "--window 1m"
+//   claude-gauge configure --no-token-line
+//   claude-gauge uninstall
+//   claude-gauge update
+//
+// setup and configure with no bar switches ask the questions themselves,
+// with a preview of the status line after each answer (wizard.ts). With
+// switches they ask nothing: the form the plugin's slash commands run once
+// Claude has asked the questions.
+//
+// Everything it keeps lives in the state folder, claude-gauge/ in the Claude
+// config folder ($CLAUDE_CONFIG_DIR, else ~/.claude): the copy of the
+// scripts in runtime/, or, when it runs from the plugin, the launcher in
+// launcher/, and the status line it replaced in .state/.
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const readline = require("node:readline");
+const node_child_process_1 = require("node:child_process");
+const settings_1 = require("./settings");
+const settings_file_1 = require("./settings-file");
+const wizard_1 = require("./wizard");
+const statusline_1 = require("./statusline");
+const wordmark_1 = require("./wordmark");
+const USAGE = `Usage: claude-gauge <setup | configure | uninstall | update> [switches]
+
+  setup        add the status line and the token line to Claude Code's settings
+  configure    change the switches of a bar that setup added, or take it out
+  uninstall    take claude-gauge out, and put back the status line it replaced
+  update       refresh the copy of claude-gauge that the settings run
+
+Switches for setup and configure:
+  --status-line <switches>   add the status line, run with these switches ("" for none)
+  --no-status-line           leave the status line out
+  --token-line <switches>    add the token line, run with these switches ("" for none)
+  --no-token-line            leave the token line out
+  --replace                  replace a status line that is not claude-gauge's
+  --yes                      setup only: add each bar not chosen above, with no switches
+
+With none of the bar switches above, setup and configure ask which bars and
+parts you want, and show the status line after each answer.
+
+The bars' switches are in README.md, under Options. The settings file is
+$CLAUDE_CONFIG_DIR/settings.json, else ~/.claude/settings.json.
+`;
+// The wordmark and a blank line, in colour when `stream` takes colour. The
+// usage and the questions start with it. Scripts and the plugin's slash
+// commands run the commands with switches, and those print no wordmark.
+const banner = (stream) => `${(0, wordmark_1.wordmark)((0, wordmark_1.colorEnabled)(stream))}\n`;
+// The usage, under the wordmark, for `stream`.
+const usage = (stream) => banner(stream) + USAGE;
+// A mistake in the command line: exit 2, with the usage.
+class UsageError extends Error {
+}
+const COMMANDS = ['setup', 'configure', 'uninstall', 'update'];
+// Every switch: its names, the commands that take it, and what it sets.
+// --help goes with any command.
+const SWITCHES = [
+    { names: ['--status-line'], commands: ['setup', 'configure'], apply: (args, value) => { args.statusLine = value(); } },
+    { names: ['--no-status-line'], commands: ['setup', 'configure'], apply: (args) => { args.statusLine = null; } },
+    { names: ['--token-line'], commands: ['setup', 'configure'], apply: (args, value) => { args.tokenLine = value(); } },
+    { names: ['--no-token-line'], commands: ['setup', 'configure'], apply: (args) => { args.tokenLine = null; } },
+    { names: ['--replace'], commands: ['setup', 'configure'], apply: (args) => { args.replace = true; } },
+    { names: ['--yes', '-y'], commands: ['setup'], apply: (args) => { args.yes = true; } },
+    { names: ['--help', '-h'], commands: [...COMMANDS], apply: (args) => { args.help = true; } },
+];
+// Unlike the two bars, which ignore what they do not know so that a typo
+// never blanks the status line, the command refuses an unknown word: it
+// writes the user's settings, and a typo there should stop it.
+function parseArgs(argv) {
+    const args = { help: false, replace: false, yes: false };
+    const seen = [];
+    for (let i = 0; i < argv.length; i++) {
+        const [name, inline] = argv[i].split(/=(.*)/s);
+        if (!name.startsWith('-')) {
+            if (args.command)
+                throw new UsageError(`Unexpected word: ${name}`);
+            if (name === 'help')
+                args.help = true;
+            else if (COMMANDS.includes(name))
+                args.command = name;
+            else
+                throw new UsageError(`Unknown command: ${name}`);
+            continue;
+        }
+        const known = SWITCHES.find((s) => s.names.includes(name));
+        if (!known)
+            throw new UsageError(`Unknown switch: ${name}`);
+        // A value is the next word whatever it holds, since switches start with --.
+        known.apply(args, () => {
+            const v = inline ?? argv[++i];
+            if (v === undefined)
+                throw new UsageError(`${name} needs a value: the switches for that bar, or "" for none.`);
+            return v;
+        });
+        seen.push(known);
+    }
+    const { command } = args;
+    const stray = command && seen.find((s) => !s.commands.includes(command));
+    if (stray)
+        throw new UsageError(`${args.command} takes no ${stray.names[0]}`);
+    return args;
+}
+// The folders and files it works with.
+const configDir = () => process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+const settingsFile = () => path.join(configDir(), 'settings.json');
+const stateDir = () => path.join(configDir(), 'claude-gauge');
+const savedStatusLineFile = () => path.join(stateDir(), '.state', 'previous-statusline.json');
+// The package this command runs from: dist/.. of this file.
+const packageRoot = path.resolve(__dirname, '..');
+const RUNTIME = ['statusline.js', 'tokenline.js'];
+// The native realpath also expands a Windows short name, such as RUNNER~1,
+// which Bun has already expanded in __dirname and the JavaScript one keeps.
+function sameFolder(a, b) {
+    try {
+        const [x, y] = [fs.realpathSync.native(a), fs.realpathSync.native(b)];
+        return process.platform === 'win32' ? x.toLowerCase() === y.toLowerCase() : x === y;
+    }
+    catch {
+        return false;
+    }
+}
+// The folder that holds the plugin's installed versions, when this command
+// runs from one of them: Claude Code installs a plugin into
+// <plugins>/cache/<marketplace>/<plugin>/<version>/, with its manifest.
+function pluginVersions() {
+    const versions = path.dirname(packageRoot);
+    const cache = path.dirname(path.dirname(versions));
+    if (path.basename(cache) !== 'cache')
+        return undefined;
+    if (!fs.existsSync(path.join(packageRoot, '.claude-plugin', 'plugin.json')))
+        return undefined;
+    return versions;
+}
+function scripts() {
+    if (sameFolder(packageRoot, stateDir()))
+        return { route: 'clone', dir: path.join(stateDir(), 'dist') };
+    const versions = pluginVersions();
+    if (versions)
+        return { route: 'launcher', dir: path.join(stateDir(), 'launcher'), versions };
+    return { route: 'copy', dir: path.join(stateDir(), 'runtime') };
+}
+const version = () => {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8')).version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+};
+// Copies the two scripts into `dir`, each replaced whole, so a status line
+// that runs during the copy reads the old script or the new one. The
+// package.json beside them keeps Node reading them as CommonJS, whatever a
+// package.json further up says.
+function copyRuntime(dir) {
+    for (const file of RUNTIME)
+        (0, settings_file_1.writeAtomic)(path.join(dir, file), fs.readFileSync(path.join(packageRoot, 'dist', file)));
+    writePackageJson(dir, 'claude-gauge-runtime');
+}
+function writePackageJson(dir, name) {
+    const pkg = { name, version: version(), private: true, type: 'commonjs' };
+    (0, settings_file_1.writeAtomic)(path.join(dir, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
+}
+// Writes the launcher into `dir`: launch.js, and one entry file per script
+// that runs it from the newest version in `versions`. The entry files keep
+// the scripts' names, so the settings name statusline.js and tokenline.js
+// as on every other route, and claude-gauge knows them as its own.
+function writeLauncher(dir, versions) {
+    (0, settings_file_1.writeAtomic)(path.join(dir, 'launch.js'), fs.readFileSync(path.join(packageRoot, 'dist', 'launcher.js')));
+    for (const file of RUNTIME) {
+        const entry = [
+            '#!/usr/bin/env node',
+            `// Written by claude-gauge setup: runs ${file} from the newest installed`,
+            '// claude-gauge plugin, so a plugin update needs no setup.',
+            `require('./launch.js').launch(${JSON.stringify(versions)}, ${JSON.stringify(file)});`,
+            '',
+        ].join('\n');
+        (0, settings_file_1.writeAtomic)(path.join(dir, file), entry);
+    }
+    writePackageJson(dir, 'claude-gauge-launcher');
+}
+// The status line claude-gauge replaced: undefined when none is saved, null
+// when there was none to replace. Only a missing file means none is saved: a
+// file it cannot read or parse stops the command, because going on would
+// drop the only record of the status line to put back.
+function savedStatusLine() {
+    const file = savedStatusLineFile();
+    let text;
+    try {
+        text = fs.readFileSync(file, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return undefined;
+        throw new Error(`Cannot read ${file}: ${err.message}. Fix or delete it by hand.`);
+    }
+    let saved;
+    try {
+        saved = JSON.parse(text);
+    }
+    catch {
+        saved = undefined;
+    }
+    const statusLine = saved?.statusLine;
+    if (typeof saved !== 'object' || saved === null || !(statusLine === null || (typeof statusLine === 'object' && !Array.isArray(statusLine)))) {
+        throw new Error(`${file} does not hold a saved status line, so claude-gauge cannot tell what to put back. Fix or delete it by hand.`);
+    }
+    return statusLine;
+}
+const say = (...lines) => process.stdout.write(lines.join('\n') + '\n');
+// setup and configure: turns the bars' switches into commands, plans the
+// settings, and writes them.
+function apply({ statusLine, tokenLine }, replace) {
+    const file = settingsFile();
+    const { settings, text } = (0, settings_file_1.readSettings)(file);
+    const where = scripts();
+    const { dir } = where;
+    const command = (script, switches) => switches === null || switches === undefined ? switches : (0, settings_1.commandFor)(path.join(dir, script), switches);
+    const choices = {
+        statusLine: command('statusline.js', statusLine),
+        tokenLine: command('tokenline.js', tokenLine),
+        replace,
+        previous: savedStatusLine() ?? null,
+    };
+    const next = (0, settings_1.plan)(settings, choices);
+    if (next.blocked) {
+        const current = settings.statusLine.command ?? JSON.stringify(settings.statusLine);
+        const whose = next.found === 'claude-hud' ? "claude-hud's status line" : 'another status line';
+        throw new Error([
+            `${file} already runs ${whose}:`,
+            `  ${current}`,
+            'Run again with --replace to replace it. claude-gauge saves it, and claude-gauge uninstall puts it back.',
+        ].join('\n'));
+    }
+    // The scripts go in first, so the settings never name a missing file.
+    if (typeof choices.statusLine === 'string' || typeof choices.tokenLine === 'string') {
+        if (where.route === 'copy')
+            copyRuntime(dir);
+        if (where.route === 'launcher')
+            writeLauncher(dir, where.versions);
+    }
+    // The status line to put back is saved before the settings change, so a
+    // failed save leaves nothing to restore wrongly.
+    if (next.backup)
+        (0, settings_file_1.writeAtomic)(savedStatusLineFile(), JSON.stringify(next.backup, null, 2) + '\n');
+    const settingsBackup = next.changed ? (0, settings_file_1.writeSettings)(file, next.settings, text) : null;
+    if (next.dropBackup)
+        fs.rmSync(savedStatusLineFile(), { force: true });
+    if (!next.changed) {
+        say(`${file} already holds these choices. Nothing to change.`);
+        return;
+    }
+    const ours = (0, settings_1.installed)(next.settings);
+    say(`Status line: ${ours.statusLine ?? 'not set up'}`, `Token line:  ${ours.tokenLine ?? 'not set up'}`, ...(settingsBackup ? [`Backup of the previous settings: ${settingsBackup}`] : []), 'Start a new Claude Code session to pick up the changes.');
+}
+// The questions, asked on the terminal: each prompt on stdout, each answer a
+// line of stdin. Lines are queued as they arrive, so answers piped in all at
+// once each reach their question.
+function terminalIo() {
+    const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+    const lines = rl[Symbol.asyncIterator]();
+    return {
+        ask: async (question) => {
+            process.stdout.write(question);
+            const next = await lines.next();
+            return next.done ? undefined : next.value;
+        },
+        write: (text) => process.stdout.write(text),
+        close: () => rl.close(),
+    };
+}
+// Whether gh runs here, and the call that stars the repo with it.
+const hasGh = () => (0, node_child_process_1.spawnSync)('gh', ['--version'], { stdio: 'ignore' }).status === 0;
+const starWithGh = () => (0, node_child_process_1.spawnSync)('gh', ['api', '--method', 'PUT', 'user/starred/jv-k/claude-gauge'], { stdio: ['ignore', 'ignore', 'inherit'] }).status === 0;
+// setup or configure with no bar switches: asks before it replaces another
+// status line, then asks for the bars, and writes them. configure starts the
+// questions from the bars set up, setup from the defaults. setup ends with
+// the star offer.
+async function interactive(command, replace) {
+    const io = terminalIo();
+    try {
+        io.write(banner(process.stdout));
+        const file = settingsFile();
+        const { settings } = (0, settings_file_1.readSettings)(file);
+        const current = settings.statusLine;
+        const owner = (0, settings_1.ownerOf)(current);
+        if (!replace && (0, settings_1.isForeign)(owner)) {
+            io.write(`${file} already runs ${owner === 'claude-hud' ? "claude-hud's status line" : 'another status line'}:\n  ${current?.command ?? JSON.stringify(current)}\n`);
+            if (!(await (0, wizard_1.confirm)(io, 'Replace it? claude-gauge saves it, and claude-gauge uninstall puts it back.', false))) {
+                say('Nothing changed.');
+                return;
+            }
+            replace = true;
+        }
+        const preview = (0, wizard_1.previewer)((0, wizard_1.loadPayload)((0, statusline_1.payloadFile)()));
+        const choices = await (0, wizard_1.runWizard)(io, { preview, installed: command === 'configure' ? (0, settings_1.installedSwitches)(settings) : undefined });
+        if (!choices) {
+            say('Nothing changed.');
+            return;
+        }
+        apply(choices, replace);
+        if (command === 'setup')
+            await (0, wizard_1.offerStar)(io, { hasGh, star: starWithGh });
+    }
+    finally {
+        io.close();
+    }
+}
+async function setup(args) {
+    const chosen = args.statusLine !== undefined || args.tokenLine !== undefined;
+    if (!chosen && !args.yes)
+        return interactive('setup', args.replace);
+    const orDefault = (v) => (v === undefined && args.yes ? '' : v);
+    apply({ statusLine: orDefault(args.statusLine), tokenLine: orDefault(args.tokenLine) }, args.replace);
+}
+async function configure(args) {
+    const file = settingsFile();
+    if (!(0, settings_1.installed)((0, settings_file_1.readSettings)(file).settings).any) {
+        throw new Error(`claude-gauge is not set up in ${file}. Run claude-gauge setup first.`);
+    }
+    if (args.statusLine === undefined && args.tokenLine === undefined)
+        return interactive('configure', args.replace);
+    apply(args, args.replace);
+}
+function uninstall() {
+    const file = settingsFile();
+    const { settings, text } = (0, settings_file_1.readSettings)(file);
+    const saved = savedStatusLine();
+    const next = (0, settings_1.plan)(settings, { uninstall: true, previous: saved ?? null });
+    // The saved status line goes only once the settings no longer need it, so
+    // a failed write leaves it for the next try.
+    const settingsBackup = next.changed ? (0, settings_file_1.writeSettings)(file, next.settings, text) : null;
+    fs.rmSync(savedStatusLineFile(), { force: true });
+    if (!next.changed) {
+        say(`claude-gauge is not in ${file}. Nothing to change.`);
+        return;
+    }
+    const restored = next.found === 'claude-gauge' && saved ? `Put back the previous status line: ${saved.command ?? JSON.stringify(saved)}` : undefined;
+    say(`Took claude-gauge out of ${file}.`, ...(restored ? [restored] : []), ...(settingsBackup ? [`Backup of the previous settings: ${settingsBackup}`] : []), `The scripts stay in ${stateDir()}. Delete that folder to remove them too.`, 'Start a new Claude Code session to pick up the changes.');
+}
+function update() {
+    const where = scripts();
+    const { dir } = where;
+    if (where.route === 'clone') {
+        say(`This claude-gauge is a git clone in ${stateDir()}. Update it with:`, `  git -C ${stateDir()} pull`);
+        return;
+    }
+    if (where.route === 'launcher') {
+        say('This claude-gauge is the Claude Code plugin. Update it with /plugin in Claude Code.', `The settings run ${dir}, which runs the newest installed version, so an update needs no setup.`);
+        return;
+    }
+    if (!fs.existsSync(path.join(dir, 'statusline.js'))) {
+        throw new Error(`There is no copy of claude-gauge in ${dir} to update. Run claude-gauge setup first.`);
+    }
+    copyRuntime(dir);
+    say(`Updated claude-gauge in ${dir} to ${version()}.`);
+}
+async function main(argv) {
+    try {
+        // A bare claude-gauge gets the usage alone, as a mistake: exit 2.
+        if (!argv.length) {
+            process.stderr.write(usage(process.stderr));
+            return 2;
+        }
+        const args = parseArgs(argv);
+        if (args.help) {
+            process.stdout.write(usage(process.stdout));
+            return 0;
+        }
+        if (!args.command)
+            throw new UsageError('Name a command.');
+        switch (args.command) {
+            case 'setup':
+                await setup(args);
+                break;
+            case 'configure':
+                await configure(args);
+                break;
+            case 'uninstall':
+                uninstall();
+                break;
+            case 'update':
+                update();
+                break;
+        }
+        return 0;
+    }
+    catch (err) {
+        if (err instanceof UsageError) {
+            process.stderr.write(`claude-gauge: ${err.message}\n\n${usage(process.stderr)}`);
+            return 2;
+        }
+        process.stderr.write(`claude-gauge: ${err.message}\n`);
+        return 1;
+    }
+}
+main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+});