getownit 0.1.0 → 0.1.2

package/README.md

@@ -11,9 +11,9 @@ ownit key set     # pick Nebius or NVIDIA, then paste your key; stored only in ~
 ownit init        # in a repo: installs the pre-push hook
 ```
 
-On each push: `Debrief now? [Y/n/s=skip]`. Ownit never blocks a push. Pending debriefs can be
-finished any time with `ownit interview`.
+On each push: `Debrief now? [Y/n]`. Ownit never blocks a push. Pending debriefs can be
+finished any time with `ownit interview`, which lets you pick the push.
 
-Your code and answers are never stored, and your key is never stored or logged by the server.
+Your code is never stored, your answers only if the repo's admins choose to show them on its page, and your key is never stored or logged by the server.
 
 Full documentation: [github.com/Yoosseph/ownit](https://github.com/Yoosseph/ownit).

package/dist/api.js

@@ -1,4 +1,5 @@
-import { modelKey, readConfig, serverUrl } from './config.js';
+import { readConfig, serverUrl } from './config.js';
+import { modelKey } from './providers.js';
 export class ApiError extends Error {
     status;
     code;

package/dist/commands/hook.js

@@ -6,7 +6,7 @@ import { RESUME_HINT, runDebrief } from '../debrief.js';
 import { buildDiff } from '../diff.js';
 import { githubRepo } from '../git.js';
 import { computePush, parseRefs } from '../pushRange.js';
-import { createPrompter, paint, sentence } from '../ui.js';
+import { createPrompter, errorMessage, paint, plural, sentence } from '../ui.js';
 const PROMPT_TIMEOUT_MS = 120_000;
 const QUICK_TIMEOUT_MS = 8_000;
 // Coding agents and CI run git without a person at the keyboard.
@@ -38,19 +38,58 @@ async function readStdin() {
         text += chunk;
     return text;
 }
+/** Yes (or Enter) debriefs now; anything else, including the old "s", leaves it for later. */
 export function interpretChoice(answer) {
-    if (answer === null)
-        return 'later';
-    const value = answer.trim().toLowerCase();
-    if (value === '' || value === 'y' || value === 'yes')
-        return 'debrief';
-    if (value === 's' || value === 'skip')
-        return 'skip';
-    return 'later';
+    const value = answer?.trim().toLowerCase();
+    return value === '' || value === 'y' || value === 'yes' ? 'debrief' : 'later';
 }
-async function record(api, repo, push, status) {
-    const res = await api.request('POST', '/api/pushes', { repo, base_sha: push.base, head_sha: push.head, commits: push.commits.map((c) => ({ sha: c.sha })), status }, { timeoutMs: QUICK_TIMEOUT_MS });
-    return res.status;
+async function recordPending(api, repo, push, out) {
+    await api.request('POST', '/api/pushes', { repo, base_sha: push.base, head_sha: push.head, commits: push.commits.map((c) => ({ sha: c.sha })), status: 'pending' }, { timeoutMs: QUICK_TIMEOUT_MS });
+    out.write(`Ownit: push recorded as pending. ${RESUME_HINT}\n`);
+    return 0;
+}
+/**
+ * What the server already recorded for these commits, so a verified push is not
+ * asked again. Only an unreachable server is an error; anything else means unknown.
+ */
+async function knownStatus(api, repo, push) {
+    const known = await api
+        .request('POST', '/api/pushes/lookup', { repo, head_sha: push.head, shas: push.commits.map((x) => x.sha) }, { timeoutMs: QUICK_TIMEOUT_MS })
+        .catch((error) => {
+        if (error instanceof ApiError && error.code === 'network')
+            throw error;
+        return { status: null };
+    });
+    return known.status;
+}
+/** Asks whether to debrief now, then debriefs or leaves the push pending for `ownit interview`. */
+async function askAndDebrief(api, terminal, repo, push, out) {
+    const c = paint(out);
+    const prompter = createPrompter(terminal, out);
+    try {
+        const n = push.commits.length;
+        const answer = await prompter.ask(`${c.bold('Ownit')} ${c.dim(`(${n} ${plural(n, 'commit')} to ${repo})`)} Debrief now? [Y/n] `, PROMPT_TIMEOUT_MS);
+        if (interpretChoice(answer) === 'later')
+            return await recordPending(api, repo, push, out);
+        await runDebrief(api, prompter, {
+            repo,
+            baseSha: push.base,
+            headSha: push.head,
+            commits: push.commits,
+            diff: buildDiff(push.ranges),
+        });
+        return 0;
+    }
+    finally {
+        prompter.close();
+        if (terminal !== process.stdin)
+            terminal.destroy();
+    }
+}
+function continueReason(error) {
+    return error instanceof ApiError && error.code === 'network'
+        ? `${sentence(error.message)} The push continues and will show as pending.`
+        : `${sentence(errorMessage(error))} The push continues.`;
 }
 /** `ownit hook pre-push <remote> <url>`. Always exits 0: the debrief never blocks a push. */
 export async function hookCommand(argv, env = process.env) {
@@ -73,58 +112,19 @@ export async function hookCommand(argv, env = process.env) {
             return 0;
         }
         const api = createApi(config, env);
-        const known = await api
-            .request('POST', '/api/pushes/lookup', { repo, head_sha: push.head, shas: push.commits.map((x) => x.sha) }, { timeoutMs: QUICK_TIMEOUT_MS })
-            .catch((error) => {
-            if (error instanceof ApiError && error.code === 'network')
-                throw error;
-            return { status: null };
-        });
-        if (known.status === 'verified' || known.status === 'skipped') {
-            out.write(c.dim(`Ownit: this push is already ${known.status}.\n`));
+        const known = await knownStatus(api, repo, push);
+        // Skipped pushes are asked again: they stay unverified until debriefed.
+        if (known === 'verified') {
+            out.write(c.dim(`Ownit: this push is already ${known}.\n`));
             return 0;
         }
         const terminal = openTerminal(env);
-        if (!terminal) {
-            await record(api, repo, push, 'pending');
-            out.write(`Ownit: push recorded as pending. ${RESUME_HINT}\n`);
-            return 0;
-        }
-        const prompter = createPrompter(terminal, out);
-        try {
-            const n = push.commits.length;
-            const answer = await prompter.ask(`${c.bold('Ownit')} ${c.dim(`(${n} ${n === 1 ? 'commit' : 'commits'} to ${repo})`)} Debrief now? [Y/n/s=skip] `, PROMPT_TIMEOUT_MS);
-            const choice = interpretChoice(answer);
-            if (choice === 'skip') {
-                await record(api, repo, push, 'skipped');
-                out.write(c.dim('Ownit: skipped. Push continues.\n'));
-                return 0;
-            }
-            if (choice === 'later') {
-                await record(api, repo, push, 'pending');
-                out.write(`Ownit: push recorded as pending. ${RESUME_HINT}\n`);
-                return 0;
-            }
-            await runDebrief(api, prompter, {
-                repo,
-                baseSha: push.base,
-                headSha: push.head,
-                commits: push.commits,
-                diff: buildDiff(push.ranges),
-            });
-            return 0;
-        }
-        finally {
-            prompter.close();
-            if (terminal !== process.stdin)
-                terminal.destroy();
-        }
+        if (!terminal)
+            return await recordPending(api, repo, push, out);
+        return await askAndDebrief(api, terminal, repo, push, out);
     }
     catch (error) {
-        const reason = error instanceof ApiError && error.code === 'network'
-            ? `${sentence(error.message)} The push continues and will show as pending.`
-            : `${sentence(error instanceof Error ? error.message : String(error))} The push continues.`;
-        out.write(`${c.yellow('Ownit:')} ${reason} ${RESUME_HINT}\n`);
+        out.write(`${c.yellow('Ownit:')} ${continueReason(error)} ${RESUME_HINT}\n`);
         return 0;
     }
 }

package/dist/commands/init.js

@@ -2,31 +2,26 @@ import { parseArgs } from 'node:util';
 import { createApi } from '../api.js';
 import { git, githubRepo } from '../git.js';
 import { hookLocation, installHook, MANAGED_SNIPPET, uninstallHook } from '../hooks.js';
-import { paint, sentence } from '../ui.js';
+import { errorMessage, paint, sentence } from '../ui.js';
 import { badgeMarkdown } from './badge.js';
-export async function initCommand(argv) {
-    const { values } = parseArgs({ args: argv, options: { repo: { type: 'string' } } });
-    const out = process.stderr;
+/** Installs the pre-push hook where git looks for it, or explains how to add it to a hook manager. */
+function installHookHere(out) {
     const c = paint(out);
-    if (values.repo)
-        git(['config', 'ownit.repo', values.repo]);
-    const repo = githubRepo();
-    if (!repo) {
-        out.write('Ownit: no GitHub remote found. Add one, or run "ownit init --repo owner/name".\n');
-        return 1;
-    }
     const location = hookLocation();
     if (location.kind === 'manual') {
         out.write(`Ownit: ${location.reason}, so add these lines to the end of .husky/pre-push (create the file if needed):\n\n`);
         out.write(`${MANAGED_SNIPPET}\n\n`);
+        return;
     }
-    else {
-        const result = installHook(location.dir);
-        out.write(`${c.green('✓')} ${result.updated ? 'Updated' : 'Installed'} the pre-push hook in ${location.dir}`);
-        out.write(location.via === 'core.hooksPath' ? ' (from core.hooksPath).\n' : '.\n');
-        if (result.chained)
-            out.write(`  Your existing hook is now pre-push.local and still runs first.\n`);
-    }
+    const result = installHook(location.dir);
+    out.write(`${c.green('✓')} ${result.updated ? 'Updated' : 'Installed'} the pre-push hook in ${location.dir}`);
+    out.write(location.via === 'core.hooksPath' ? ' (from core.hooksPath).\n' : '.\n');
+    if (result.chained)
+        out.write(`  Your existing hook is now pre-push.local and still runs first.\n`);
+}
+/** Registers the repo with the Ownit server and shows what to do next. */
+async function registerRepo(repo, out) {
+    const c = paint(out);
     try {
         const api = createApi();
         const registered = await api.request('POST', '/api/repos', { repo }, { timeoutMs: 15_000 });
@@ -42,12 +37,26 @@ export async function initCommand(argv) {
         out.write(`\nAdd the badge to your README (run "ownit badge" to see this again):\n  ${badgeMarkdown(origin, registered.repo)}\n`);
     }
     catch (error) {
-        out.write(`${c.yellow('Ownit:')} the hook is installed, but registering ${repo} failed: ${sentence(error instanceof Error ? error.message : String(error))}\n`);
+        out.write(`${c.yellow('Ownit:')} the hook is installed, but registering ${repo} failed: ${sentence(errorMessage(error))}\n`);
         out.write('Run "ownit init" again once that is fixed.\n');
         return 1;
     }
     return 0;
 }
+/** `ownit init [--repo owner/name]` */
+export async function initCommand(argv) {
+    const { values } = parseArgs({ args: argv, options: { repo: { type: 'string' } } });
+    const out = process.stderr;
+    if (values.repo)
+        git(['config', 'ownit.repo', values.repo]);
+    const repo = githubRepo();
+    if (!repo) {
+        out.write('Ownit: no GitHub remote found. Add one, or run "ownit init --repo owner/name".\n');
+        return 1;
+    }
+    installHookHere(out);
+    return registerRepo(repo, out);
+}
 export async function uninstallCommand() {
     const out = process.stderr;
     const location = hookLocation();

package/dist/commands/interview.js

@@ -1,14 +1,14 @@
 import { parseArgs } from 'node:util';
 import { createApi } from '../api.js';
 import { buildDiff } from '../diff.js';
-import { runDebrief } from '../debrief.js';
-import { githubRepo, listCommits, objectExists, resolveCommit } from '../git.js';
+import { LATER, runDebrief } from '../debrief.js';
+import { githubRepo, listCommits, objectExists, resolveCommit, tryGit } from '../git.js';
 import { rangeForRecordedPush } from '../pushRange.js';
-import { createPrompter, paint } from '../ui.js';
+import { createPrompter, paint, plural } from '../ui.js';
 export async function interviewCommand(argv) {
     const { values } = parseArgs({
         args: argv,
-        options: { range: { type: 'string' }, repo: { type: 'string' } },
+        options: { range: { type: 'string' }, repo: { type: 'string' }, all: { type: 'boolean' } },
         allowPositionals: false,
     });
     const out = process.stderr;
@@ -22,32 +22,83 @@ export async function interviewCommand(argv) {
     try {
         if (values.range)
             return exitCode(await debriefRange(api, prompter, repo, values.range));
-        return await debriefOpenPushes(api, prompter, repo);
+        return await debriefOpenPushes(api, prompter, repo, Boolean(values.all));
     }
     finally {
         prompter.close();
     }
 }
 function exitCode(outcome) {
-    return outcome && (outcome.status === 'verified' || outcome.status === 'skipped') ? 0 : 1;
+    return outcome && (outcome.status === 'verified' || outcome.reason === LATER) ? 0 : 1;
 }
-async function debriefRange(api, prompter, repo, range) {
+/** A range "A..B", or a single commit, which means just that commit. */
+function parseRange(range) {
     const match = range.match(/^(.+?)\.\.(.+)$/);
-    if (!match) {
-        prompter.out.write('Ownit: --range must look like A..B.\n');
-        return null;
-    }
-    const base = resolveCommit(match[1]);
-    const head = resolveCommit(match[2]);
-    const commits = listCommits([`${base}..${head}`]);
+    if (match)
+        return { base: resolveCommit(match[1]), head: resolveCommit(match[2]) };
+    const head = resolveCommit(range);
+    return { base: tryGit(['rev-parse', '--verify', '--quiet', `${head}^`])?.trim() || null, head };
+}
+async function debriefRange(api, prompter, repo, range) {
+    const { base, head } = parseRange(range);
+    const commits = base ? listCommits([`${base}..${head}`]) : listCommits(['-1', head]);
     if (!commits.length) {
         prompter.out.write(`Ownit: no commits in ${range}.\n`);
         return null;
     }
     return runDebrief(api, prompter, { repo, baseSha: base, headSha: head, commits, diff: buildDiff([{ base, head }]) });
 }
-/** Resolves pending and provider_error pushes, newest first. */
-async function debriefOpenPushes(api, prompter, repo) {
+function toChoice(push) {
+    if (![push.head_sha, ...push.commits].every((sha) => objectExists(sha)))
+        return { push, commits: [] };
+    const range = rangeForRecordedPush(push.base_sha, push.head_sha, push.commits);
+    const known = new Set(push.commits);
+    const commits = listCommits([range.base ? `${range.base}..${range.head}` : range.head]).filter((x) => known.has(x.sha));
+    return { push, commits: commits.length ? commits : listCommits(['-1', range.head]) };
+}
+const shortDate = (iso) => new Date(iso).toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+/** One line per push: number, status, head commit, date and what the commits say. */
+function printChoices(out, choices) {
+    const c = paint(out);
+    const width = Math.min(process.stderr.columns || 80, 100);
+    choices.forEach(({ push, commits }, i) => {
+        const status = push.status === 'provider_error' ? 'error' : push.status;
+        const head = `${String(i + 1).padStart(3)}  ${status.padEnd(7)}  ${push.head_sha.slice(0, 7)}  ${shortDate(push.created_at).padEnd(6)}  `;
+        let title;
+        if (!commits.length)
+            title = c.yellow('not in this clone, run "git fetch"');
+        else {
+            const subject = commits.at(-1).message.split('\n')[0];
+            const more = commits.length > 1 ? ` (+${commits.length - 1} more)` : '';
+            const room = Math.max(20, width - head.length - more.length);
+            title = (subject.length > room ? `${subject.slice(0, room - 1)}…` : subject) + c.dim(more);
+        }
+        out.write(`${c.dim(head)}${title}\n`);
+    });
+}
+/** What the developer picked: a list index, every push, quit (also on end of input), or null when unclear. */
+export function parsePick(answer, count) {
+    const text = answer?.trim().toLowerCase() ?? 'q';
+    if (text === '')
+        return 0;
+    if (text === 'q' || text === 'quit')
+        return 'quit';
+    if (text === 'a' || text === 'all')
+        return 'all';
+    const n = Number(text);
+    return Number.isInteger(n) && n >= 1 && n <= count ? n - 1 : null;
+}
+async function debriefChoice(api, prompter, repo, { push, commits }) {
+    const range = rangeForRecordedPush(push.base_sha, push.head_sha, push.commits);
+    return runDebrief(api, prompter, { repo, baseSha: range.base, headSha: range.head, commits, diff: buildDiff([range]), pushId: push.id });
+}
+/** The debrief was cut off or failed, so stop. "s" (later) is not a stop: it moves on to the next push. */
+const stopped = (outcome) => outcome.reason !== LATER && (outcome.status === 'pending' || outcome.status === 'provider_error');
+/**
+ * Lists the pushes still waiting for a debrief, newest first, and debriefs the
+ * ones the developer picks, one at a time. `all` keeps going without asking.
+ */
+async function debriefOpenPushes(api, prompter, repo, all) {
     const out = prompter.out;
     const c = paint(out);
     const { pushes } = await api.request('GET', `/api/pushes/open?repo=${encodeURIComponent(repo)}`);
@@ -55,28 +106,46 @@ async function debriefOpenPushes(api, prompter, repo) {
         out.write(`${c.green('✓')} Nothing to debrief for ${repo}.\n`);
         return 0;
     }
-    out.write(`${pushes.length} push${pushes.length === 1 ? '' : 'es'} waiting for a debrief in ${repo}.\n`);
-    let code = 0;
-    for (const push of pushes) {
-        const missing = [push.head_sha, ...push.commits].find((sha) => !objectExists(sha));
-        if (missing) {
-            out.write(c.yellow(`Ownit: commit ${missing.slice(0, 7)} is not in this clone. Run "git fetch" and try again.\n`));
-            code = 1;
+    let choices = pushes.map(toChoice);
+    if (all)
+        return debriefInOrder(api, prompter, repo, choices);
+    while (choices.length) {
+        out.write(`\n${choices.length} ${plural(choices.length, 'push', 'pushes')} waiting for a debrief in ${repo}:\n\n`);
+        printChoices(out, choices);
+        const pick = parsePick(await prompter.ask(`\nDebrief which one? ${c.dim('[number, Enter for 1, a = all, q = quit]')} `), choices.length);
+        if (pick === 'quit') {
+            out.write(c.dim('Run "ownit interview" any time to come back.\n'));
+            return 0;
+        }
+        if (pick === null) {
+            out.write(c.yellow(`Pick a number from 1 to ${choices.length}, a or q.\n`));
+            continue;
+        }
+        if (pick === 'all')
+            return debriefInOrder(api, prompter, repo, choices);
+        const choice = choices[pick];
+        if (!choice.commits.length) {
+            out.write(c.yellow(`Commit ${choice.push.head_sha.slice(0, 7)} is not in this clone. Run "git fetch" and try again.\n`));
             continue;
         }
-        const range = rangeForRecordedPush(push.base_sha, push.head_sha, push.commits);
-        const known = new Set(push.commits);
-        const commits = listCommits([range.base ? `${range.base}..${range.head}` : range.head]).filter((x) => known.has(x.sha));
-        const outcome = await runDebrief(api, prompter, {
-            repo,
-            baseSha: range.base,
-            headSha: range.head,
-            commits: commits.length ? commits : listCommits(['-1', range.head]),
-            diff: buildDiff([range]),
-            pushId: push.id,
-        });
-        if (outcome.status === 'pending' || outcome.status === 'provider_error')
+        const outcome = await debriefChoice(api, prompter, repo, choice);
+        if (stopped(outcome))
             return 1;
+        if (outcome.reason !== LATER)
+            choices = choices.filter((x) => x !== choice);
+    }
+    out.write(`\n${c.green('✓')} Nothing left to debrief for ${repo}.\n`);
+    return 0;
+}
+/** Debriefs every push in the list, newest first, until one is paused or fails. */
+async function debriefInOrder(api, prompter, repo, choices) {
+    for (const choice of choices.filter((x) => x.commits.length)) {
+        if (stopped(await debriefChoice(api, prompter, repo, choice)))
+            return 1;
+    }
+    const missing = choices.filter((x) => !x.commits.length).length;
+    if (missing) {
+        prompter.out.write(paint(prompter.out).yellow(`Ownit: ${missing} ${plural(missing, 'push', 'pushes')} not in this clone. Run "git fetch" and try again.\n`));
     }
-    return code;
+    return missing ? 1 : 0;
 }

package/dist/commands/key.js

@@ -1,4 +1,5 @@
-import { describeKey, isProvider, modelKey, PROVIDER_IDS, PROVIDERS, providerByPrefix, readConfig, updateConfig } from '../config.js';
+import { readConfig, updateConfig } from '../config.js';
+import { describeKey, isProvider, modelKey, PROVIDER_IDS, PROVIDERS, providerByPrefix } from '../providers.js';
 import { readSecret } from '../secret.js';
 import { createPrompter } from '../ui.js';
 const CHOICES = PROVIDER_IDS.join('|');
@@ -30,39 +31,49 @@ async function chooseProvider(arg) {
         out.write(`Ownit: "${answer}" is not one of the choices; nothing changed.\n`);
     return picked;
 }
-export async function keyCommand(argv) {
+async function setKey(providerArg) {
     const out = process.stderr;
-    const [action = 'status', providerArg] = argv;
-    if (action === 'set') {
-        const provider = await chooseProvider(providerArg);
-        if (!provider)
-            return 1;
-        const { name } = PROVIDERS[provider];
-        // Read from a prompt or stdin, never argv, so the key stays out of shell history.
-        const key = (await readSecret(`${name} API key (input hidden): `)).trim();
-        if (!key) {
-            out.write('Ownit: no key entered; nothing changed.\n');
-            return 1;
-        }
-        const looksLike = providerByPrefix(key);
-        if (looksLike && looksLike !== provider) {
-            out.write(`Ownit: that key looks like it is for ${PROVIDERS[looksLike].name}. Run "ownit key set ${looksLike}" instead; nothing changed.\n`);
-            return 1;
-        }
-        updateConfig({ provider, apiKey: key, nebiusKey: undefined });
-        out.write(`Saved your ${name} key to ~/.ownit/config.json. It is sent only with debrief requests and never stored by Ownit.\n`);
-        return 0;
+    const provider = await chooseProvider(providerArg);
+    if (!provider)
+        return 1;
+    const { name } = PROVIDERS[provider];
+    // Read from a prompt or stdin, never argv, so the key stays out of shell history.
+    const key = (await readSecret(`${name} API key (input hidden): `)).trim();
+    if (!key) {
+        out.write('Ownit: no key entered; nothing changed.\n');
+        return 1;
     }
-    if (action === 'clear') {
-        updateConfig({ provider: undefined, apiKey: undefined, nebiusKey: undefined });
-        out.write('Removed your API key.\n');
-        return 0;
+    const looksLike = providerByPrefix(key);
+    if (looksLike && looksLike !== provider) {
+        out.write(`Ownit: that key looks like it is for ${PROVIDERS[looksLike].name}. Run "ownit key set ${looksLike}" instead; nothing changed.\n`);
+        return 1;
     }
-    if (action === 'status') {
-        const model = modelKey(readConfig());
-        out.write(model ? `API key set (${describeKey(model)}).\n` : 'No API key set. Run "ownit key set" with a Nebius or NVIDIA key.\n');
-        return 0;
+    updateConfig({ provider, apiKey: key, nebiusKey: undefined });
+    out.write(`Saved your ${name} key to ~/.ownit/config.json. It is sent only with debrief requests and never stored by Ownit.\n`);
+    return 0;
+}
+function clearKey() {
+    updateConfig({ provider: undefined, apiKey: undefined, nebiusKey: undefined });
+    process.stderr.write('Removed your API key.\n');
+    return 0;
+}
+function showKey() {
+    const model = modelKey(readConfig());
+    process.stderr.write(model ? `API key set (${describeKey(model)}).\n` : 'No API key set. Run "ownit key set" with a Nebius or NVIDIA key.\n');
+    return 0;
+}
+/** `ownit key set [provider] | clear | status` */
+export async function keyCommand(argv) {
+    const [action = 'status', providerArg] = argv;
+    switch (action) {
+        case 'set':
+            return setKey(providerArg);
+        case 'clear':
+            return clearKey();
+        case 'status':
+            return showKey();
+        default:
+            process.stderr.write(`Usage: ownit key set [${CHOICES}] | clear | status\n`);
+            return 1;
     }
-    out.write(`Usage: ownit key set [${CHOICES}] | clear | status\n`);
-    return 1;
 }

package/dist/commands/login.js

@@ -1,6 +1,7 @@
 import { parseArgs } from 'node:util';
 import { ApiError, createApi } from '../api.js';
-import { describeKey, modelKey, readConfig, serverUrl, updateConfig } from '../config.js';
+import { readConfig, serverUrl, updateConfig } from '../config.js';
+import { describeKey, modelKey } from '../providers.js';
 import { readSecret } from '../secret.js';
 import { paint } from '../ui.js';
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -24,33 +25,10 @@ async function githubOAuth(path, form) {
     return (await response.json());
 }
 /**
- * `ownit login`: the GitHub device flow runs here, from the user's own IP
- * (GitHub rate-limits its login endpoints per IP, which shared server IPs
- * hit). The server then verifies the identity, drops the GitHub token, and
- * issues an Ownit session token.
+ * Polls GitHub until the user authorizes the device code. Returns the GitHub
+ * token, or the reason the login ended without one.
  */
-export async function loginCommand(argv) {
-    const { values } = parseArgs({ args: argv, options: { server: { type: 'string' }, 'with-token': { type: 'boolean' } } });
-    const out = process.stderr;
-    const c = paint(out);
-    if (values.server)
-        updateConfig({ server: values.server.replace(/\/+$/, '') });
-    if (values['with-token']) {
-        // For self-hosted or local servers: read a session token from stdin.
-        const token = (await readSecret('Ownit session token: ')).trim();
-        if (!/^ownit_[\w-]{20,}$/.test(token)) {
-            out.write('Ownit: that does not look like an Ownit session token.\n');
-            return 1;
-        }
-        updateConfig({ token, login: undefined });
-        out.write(`${c.green('✓')} Saved the session token.\n`);
-        return 0;
-    }
-    const api = createApi({ ...readConfig(), token: undefined });
-    const { github_client_id: clientId } = await api.request('GET', '/auth/config');
-    const start = await githubOAuth('/login/device/code', { client_id: clientId });
-    out.write(`\nOpen ${c.bold(start.verification_uri)} and enter the code ${c.bold(c.cyan(start.user_code))}\n`);
-    out.write(c.dim('Waiting for you to authorize Ownit on GitHub…\n'));
+async function pollForAccessToken(clientId, start) {
     let interval = Math.max(start.interval, 0) * 1000;
     const deadline = Date.now() + start.expires_in * 1000;
     while (Date.now() < deadline) {
@@ -60,24 +38,60 @@ export async function loginCommand(argv) {
             device_code: start.device_code,
             grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
         });
-        if (reply.access_token) {
-            // The GitHub token goes to the Ownit server once, to prove who you are, and is not kept anywhere.
-            const session = await api.request('POST', '/auth/github', { access_token: reply.access_token });
-            updateConfig({ token: session.token, login: session.login });
-            out.write(`${c.green('✓')} Logged in as ${c.bold(session.login)} on ${serverUrl(readConfig())}.\n`);
-            return 0;
-        }
+        if (reply.access_token)
+            return { token: reply.access_token };
         if (reply.error === 'authorization_pending')
             continue;
         if (reply.error === 'slow_down') {
             interval = Math.max(interval + 5000, (reply.interval ?? 0) * 1000);
             continue;
         }
-        out.write(`Ownit: login ${reply.error === 'access_denied' ? 'was cancelled' : `failed (${reply.error ?? 'unknown error'})`}. Run "ownit login" to try again.\n`);
+        return { failure: `login ${reply.error === 'access_denied' ? 'was cancelled' : `failed (${reply.error ?? 'unknown error'})`}.` };
+    }
+    return { failure: 'the login code expired.' };
+}
+/** For self-hosted or local servers: reads a session token from stdin. */
+async function loginWithToken() {
+    const out = process.stderr;
+    const token = (await readSecret('Ownit session token: ')).trim();
+    if (!/^ownit_[\w-]{20,}$/.test(token)) {
+        out.write('Ownit: that does not look like an Ownit session token.\n');
+        return 1;
+    }
+    updateConfig({ token, login: undefined });
+    out.write(`${paint(out).green('✓')} Saved the session token.\n`);
+    return 0;
+}
+/**
+ * The GitHub device flow runs here, from the user's own IP (GitHub rate-limits
+ * its login endpoints per IP, which shared server IPs hit). The server then
+ * verifies the identity, drops the GitHub token, and issues an Ownit session token.
+ */
+async function deviceFlowLogin() {
+    const out = process.stderr;
+    const c = paint(out);
+    const api = createApi({ ...readConfig(), token: undefined });
+    const { github_client_id: clientId } = await api.request('GET', '/auth/config');
+    const start = await githubOAuth('/login/device/code', { client_id: clientId });
+    out.write(`\nOpen ${c.bold(start.verification_uri)} and enter the code ${c.bold(c.cyan(start.user_code))}\n`);
+    out.write(c.dim('Waiting for you to authorize Ownit on GitHub…\n'));
+    const result = await pollForAccessToken(clientId, start);
+    if ('failure' in result) {
+        out.write(`Ownit: ${result.failure} Run "ownit login" to try again.\n`);
         return 1;
     }
-    out.write('Ownit: the login code expired. Run "ownit login" to try again.\n');
-    return 1;
+    // The GitHub token goes to the Ownit server once, to prove who you are, and is not kept anywhere.
+    const session = await api.request('POST', '/auth/github', { access_token: result.token });
+    updateConfig({ token: session.token, login: session.login });
+    out.write(`${c.green('✓')} Logged in as ${c.bold(session.login)} on ${serverUrl(readConfig())}.\n`);
+    return 0;
+}
+/** `ownit login [--server URL] [--with-token]` */
+export async function loginCommand(argv) {
+    const { values } = parseArgs({ args: argv, options: { server: { type: 'string' }, 'with-token': { type: 'boolean' } } });
+    if (values.server)
+        updateConfig({ server: values.server.replace(/\/+$/, '') });
+    return values['with-token'] ? loginWithToken() : deviceFlowLogin();
 }
 export async function logoutCommand() {
     const config = readConfig();

package/dist/commands/settings.js

@@ -0,0 +1,54 @@
+import { createApi } from '../api.js';
+import { githubRepo } from '../git.js';
+import { paint } from '../ui.js';
+const USAGE = 'Usage: ownit settings [questions|answers|earlier] [on|off]\n';
+/** The setting each name changes on the server. */
+const SETTING = { questions: 'show_questions', answers: 'show_answers', earlier: 'allow_backfill' };
+function describe(s) {
+    const page = s.private
+        ? 'Questions and answers: hidden (private repo)'
+        : `Questions:       ${s.show_questions ? 'shown' : 'hidden'}\nAnswers:         ${s.show_answers ? 'shown' : 'hidden'}`;
+    return `${page}\nEarlier commits: ${s.allow_backfill ? 'count once debriefed' : 'not counted'}`;
+}
+/** A line about what just changed, or how to change things. */
+function note(s, changed, on) {
+    if (changed === 'answers' && on)
+        return 'From now on, passing answers are saved and shown. Developers see a note before they answer.';
+    if (changed === 'earlier' && on)
+        return 'Debrief older commits with "ownit interview --range A..B" (or a single commit SHA). They count once verified, never as unverified.';
+    if (changed === 'earlier')
+        return 'New debriefs of older commits no longer count. Ones already verified stay.';
+    if (changed && !s.show_answers)
+        return 'Saved answers, if any, are deleted.';
+    if (changed)
+        return '';
+    return 'Change with "ownit settings questions|answers|earlier on|off" (repo admins and maintainers).';
+}
+/**
+ * `ownit settings`: shows this repo's Ownit settings and page link.
+ * `ownit settings questions|answers|earlier on|off` changes one (admins and maintainers).
+ */
+export async function settingsCommand(args) {
+    const out = process.stderr;
+    const [what, value, ...rest] = args;
+    const changed = what;
+    if (changed !== undefined && (!Object.hasOwn(SETTING, changed) || (value !== 'on' && value !== 'off') || rest.length)) {
+        out.write(USAGE);
+        return 1;
+    }
+    const repo = githubRepo();
+    if (!repo) {
+        out.write('Ownit: no GitHub remote found. Run this in a repo set up with "ownit init".\n');
+        return 1;
+    }
+    const api = createApi();
+    const settings = changed
+        ? await api.request('PUT', '/api/repos/settings', { repo, [SETTING[changed]]: value === 'on' })
+        : await api.request('GET', `/api/repos/settings?repo=${encodeURIComponent(repo)}`);
+    const c = paint(out);
+    out.write(`${c.bold(settings.page_url)}\n${describe(settings)}\n`);
+    const line = note(settings, changed, value === 'on');
+    if (line)
+        out.write(`${c.dim(line)}\n`);
+    return 0;
+}

package/dist/config.js

@@ -1,18 +1,6 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-/**
- * Model providers the worker accepts, in the order `ownit key set` lists them.
- * Add a provider here and in the worker's PROVIDERS.
- */
-export const PROVIDERS = {
-    nebius: { name: 'Nebius', envVar: 'NEBIUS_API_KEY', keyUrl: 'https://tokenfactory.nebius.com/', keyPrefix: undefined },
-    nvidia: { name: 'NVIDIA', envVar: 'NVIDIA_API_KEY', keyUrl: 'https://build.nvidia.com/', keyPrefix: 'nvapi-' },
-};
-export const PROVIDER_IDS = Object.keys(PROVIDERS);
-export function isProvider(value) {
-    return Object.hasOwn(PROVIDERS, value);
-}
 // The hosted Ownit server. Self-hosters point the CLI elsewhere with `ownit login --server`.
 export const DEFAULT_SERVER = 'https://ownit.ownit-worker.workers.dev';
 export function configDir(env = process.env) {
@@ -53,30 +41,6 @@ export function updateConfig(patch, env = process.env) {
     writeConfig(next, env);
     return next;
 }
-/** The key to send with debriefs and its provider. A provider's env var wins over the saved key. */
-export function modelKey(config, env = process.env) {
-    for (const provider of PROVIDER_IDS) {
-        const key = env[PROVIDERS[provider].envVar];
-        if (key)
-            return { provider, key };
-    }
-    if (config.apiKey)
-        return { provider: config.provider ?? 'nebius', key: config.apiKey };
-    if (config.nebiusKey)
-        return { provider: 'nebius', key: config.nebiusKey };
-    return undefined;
-}
-/** The provider whose keys have this key's prefix, if any. */
-export function providerByPrefix(key) {
-    return PROVIDER_IDS.find((id) => {
-        const prefix = PROVIDERS[id].keyPrefix;
-        return prefix !== undefined && key.startsWith(prefix);
-    });
-}
-/** e.g. "NVIDIA, …1a2b" */
-export function describeKey({ provider, key }) {
-    return `${PROVIDERS[provider]?.name ?? provider}, …${key.slice(-4)}`;
-}
 export function serverUrl(config, env = process.env) {
     return (env.OWNIT_SERVER || config.server || DEFAULT_SERVER).replace(/\/+$/, '');
 }

package/dist/debrief.js

@@ -1,105 +1,135 @@
 import { ApiError } from './api.js';
-import { paint, sentence, spinner, wrap } from './ui.js';
+import { errorMessage, paint, plural, sentence, spinner, wrap } from './ui.js';
 const MAX_ANSWER_CHARS = 2000;
 export const RESUME_HINT = 'Run "ownit interview" when you\'re ready.';
 const KIND_LABEL = { why: 'why', how: 'how', next: "what's next" };
-function isSkip(answer) {
+/** "s" (or the older "skip") stops the debrief for now. */
+function isLater(answer) {
     return /^(s|skip|:skip)$/i.test(answer.trim());
 }
+/** The reason on a debrief the developer stopped with "s", as opposed to one that was cut off. */
+export const LATER = 'later';
+/** Shows a spinner while `work` runs. */
+async function withSpinner(out, text, work) {
+    const spin = spinner(out, text);
+    try {
+        return await work();
+    }
+    finally {
+        spin.stop();
+    }
+}
+function printQuestion(out, question, total, followUp) {
+    const c = paint(out);
+    const label = `Question ${question.idx + 1}/${total}`;
+    out.write(`\n${c.bold(c.cyan(label))} ${c.dim(`(${KIND_LABEL[question.kind]}${followUp ? ', follow-up' : ''})`)}\n`);
+    out.write(`${wrap(question.text)}\n`);
+}
+/** The next non-blank answer, or null when the input ends. */
+async function readAnswer(prompter) {
+    const c = paint(prompter.out);
+    let answer;
+    do
+        answer = await prompter.ask(c.bold('> '));
+    while (answer !== null && !answer.trim());
+    return answer;
+}
+/**
+ * Asks a question, and follow-ups after a miss, until an answer passes (null)
+ * or the debrief ends early (its outcome).
+ */
+async function askUntilPassed(debrief, first) {
+    const { api, prompter } = debrief;
+    const out = prompter.out;
+    const c = paint(out);
+    let question = first;
+    let followUp = false;
+    for (;;) {
+        printQuestion(out, question, debrief.total, followUp);
+        const answer = await readAnswer(prompter);
+        if (answer === null) {
+            out.write(`\n${c.yellow('Debrief paused.')} ${RESUME_HINT}\n`);
+            return { status: 'pending', reason: 'debrief paused' };
+        }
+        if (isLater(answer))
+            return later(out);
+        let result;
+        try {
+            result = await withSpinner(out, 'Checking your answer…', () => api.request('POST', '/api/interview/answer', {
+                session: debrief.session,
+                idx: question.idx,
+                answer: answer.slice(0, MAX_ANSWER_CHARS),
+                ...debrief.payload,
+            }));
+        }
+        catch (error) {
+            return failure(out, error);
+        }
+        debrief.session = result.session;
+        debrief.earlierCredited = result.earlier_credited ?? 0;
+        if (result.pass) {
+            out.write(`${c.green('✓ Passed.')}\n${c.dim(wrap(result.feedback))}\n`);
+            return null;
+        }
+        out.write(`${c.yellow('Not quite yet.')}\n${wrap(result.feedback)}\n`);
+        if (!result.followup)
+            return { status: 'pending', reason: 'no follow-up question' };
+        out.write(c.dim("Here's another angle on the same topic:\n"));
+        question = result.followup;
+        followUp = true;
+    }
+}
 /** Runs one debrief: asks each question, grades answers, and offers follow-ups until every question passes. */
 export async function runDebrief(api, prompter, target) {
     const out = prompter.out;
     const c = paint(out);
-    const commitWord = target.commits.length === 1 ? 'commit' : 'commits';
-    out.write(`\n${c.bold('Ownit debrief')} ${c.dim(`· ${target.repo} · ${target.commits.length} ${commitWord} · ${target.diff.changedLines} changed ${target.diff.changedLines === 1 ? 'line' : 'lines'}`)}\n`);
+    const commitWord = plural(target.commits.length, 'commit');
+    out.write(`\n${c.bold('Ownit debrief')} ${c.dim(`· ${target.repo} · ${target.commits.length} ${commitWord} · ${target.diff.changedLines} changed ${plural(target.diff.changedLines, 'line')}`)}\n`);
     const payload = {
         commits: target.commits,
         diff: target.diff.diff,
         diff_truncated: target.diff.truncated,
     };
     let start;
-    const spin = spinner(out, 'Nemotron is reading your push…');
     try {
-        start = await api.request('POST', '/api/interview/start', {
+        start = await withSpinner(out, 'Nemotron is reading your push…', () => api.request('POST', '/api/interview/start', {
             repo: target.repo,
             base_sha: target.baseSha,
             head_sha: target.headSha,
             changed_lines: target.diff.changedLines,
             push_id: target.pushId,
             ...payload,
-        });
+        }));
     }
     catch (error) {
-        spin.stop();
         return failure(out, error);
     }
-    spin.stop();
-    let session = start.session;
-    out.write(c.dim(`Answer in your own words, up to 5 sentences. Rough is fine. Type "s" to skip.\n`));
-    for (const first of start.questions) {
-        let question = first;
-        let followUp = false;
-        for (;;) {
-            const label = `Question ${question.idx + 1}/${start.total}`;
-            out.write(`\n${c.bold(c.cyan(label))} ${c.dim(`(${KIND_LABEL[question.kind]}${followUp ? ', follow-up' : ''})`)}\n`);
-            out.write(`${wrap(question.text)}\n`);
-            let answer;
-            do
-                answer = await prompter.ask(c.bold('> '));
-            while (answer !== null && !answer.trim());
-            if (answer === null) {
-                out.write(`\n${c.yellow('Debrief paused.')} ${RESUME_HINT}\n`);
-                return { status: 'pending', reason: 'debrief paused' };
-            }
-            if (isSkip(answer))
-                return skip(api, out, session);
-            const grading = spinner(out, 'Checking your answer…');
-            let result;
-            try {
-                result = await api.request('POST', '/api/interview/answer', {
-                    session,
-                    idx: question.idx,
-                    answer: answer.slice(0, MAX_ANSWER_CHARS),
-                    ...payload,
-                });
-            }
-            catch (error) {
-                grading.stop();
-                return failure(out, error);
-            }
-            grading.stop();
-            session = result.session;
-            if (result.pass) {
-                out.write(`${c.green('✓ Passed.')}\n${c.dim(wrap(result.feedback))}\n`);
-                break;
-            }
-            out.write(`${c.yellow('Not quite yet.')}\n${wrap(result.feedback)}\n`);
-            if (!result.followup)
-                return { status: 'pending', reason: 'no follow-up question' };
-            out.write(c.dim("Here's another angle on the same topic:\n"));
-            question = result.followup;
-            followUp = true;
-        }
+    out.write(c.dim(`Answer in your own words, up to 5 sentences. Rough is fine. Type "s" to stop and finish later.\n`));
+    if (start.answers_public)
+        out.write(c.yellow('Note: this repo shows passing answers on its public Ownit page.\n'));
+    const debrief = { api, prompter, total: start.total, payload, session: start.session, earlierCredited: 0 };
+    for (const question of start.questions) {
+        const ended = await askUntilPassed(debrief, question);
+        if (ended)
+            return ended;
     }
     out.write(`\n${c.green(c.bold('✓ Push verified.'))} ${c.dim(`${target.commits.length} ${commitWord} owned. Nice work.`)}\n`);
+    const earlier = debrief.earlierCredited;
+    if (earlier)
+        out.write(c.dim(`${earlier} earlier ${plural(earlier, 'commit')} now ${earlier === 1 ? 'counts' : 'count'} as verified.\n`));
     return { status: 'verified' };
 }
-async function skip(api, out, session) {
-    try {
-        await api.request('POST', '/api/interview/skip', { session });
-    }
-    catch (error) {
-        return failure(out, error);
-    }
-    out.write(`${paint(out).dim('Skipped. This push is recorded as skipped.')}\n`);
-    return { status: 'skipped' };
+/** "s" stops for now. Nothing is recorded: the push stays pending, so it waits in `ownit interview`. */
+function later(out) {
+    out.write(`${paint(out).dim(`Stopped. This push stays unverified until you debrief it. ${RESUME_HINT}`)}\n`);
+    return { status: 'pending', reason: LATER };
 }
 /** Prints a one-line reason. Provider problems stay out of the stats until retried. */
 function failure(out, error) {
     const c = paint(out);
     if (error instanceof ApiError) {
         if (error.isProviderError) {
-            out.write(`${c.yellow('Ownit:')} ${error.message} This push won't count until you retry. ${RESUME_HINT}\n`);
+            out.write(`${c.yellow('Ownit:')} ${error.message} These commits stay unverified until you retry. ${RESUME_HINT}\n`);
             return { status: 'provider_error', reason: error.message };
         }
         if (error.code === 'already_resolved') {
@@ -110,7 +140,7 @@ function failure(out, error) {
         out.write(`${c.yellow('Ownit:')} ${sentence(error.message)} ${RESUME_HINT}\n`);
         return { status: 'pending', reason: error.message };
     }
-    const message = error instanceof Error ? error.message : String(error);
+    const message = errorMessage(error);
     out.write(`${c.yellow('Ownit:')} ${sentence(message)} ${RESUME_HINT}\n`);
     return { status: 'pending', reason: message };
 }

package/dist/index.js

@@ -1,72 +1,93 @@
 #!/usr/bin/env node
 import { readFileSync } from 'node:fs';
+import { badgeCommand } from './commands/badge.js';
 import { hookCommand } from './commands/hook.js';
 import { initCommand, uninstallCommand } from './commands/init.js';
 import { interviewCommand } from './commands/interview.js';
-import { badgeCommand } from './commands/badge.js';
 import { keyCommand } from './commands/key.js';
 import { loginCommand, logoutCommand, whoamiCommand } from './commands/login.js';
-const HELP = `ownit: debrief the code you just pushed.
+import { settingsCommand } from './commands/settings.js';
+import { closestMatch, errorMessage } from './ui.js';
+/** Every command, in the order `ownit help` lists them. */
+const COMMANDS = {
+    login: { help: [['ownit login [--server URL]', 'Sign in with GitHub (device flow)']], run: loginCommand },
+    logout: { help: [['ownit logout', 'Sign out']], run: logoutCommand },
+    whoami: { help: [['ownit whoami', 'Show server, login, and key status']], run: whoamiCommand },
+    init: { help: [['ownit init [--repo owner/name]', 'Install the pre-push hook in this repo']], run: initCommand },
+    interview: {
+        help: [
+            ['ownit interview', 'List waiting pushes and debrief the one you pick'],
+            ['ownit interview --all', 'Debrief every waiting push in turn'],
+            ['ownit interview --range A..B', 'Debrief a commit range, or one commit (SHA)'],
+        ],
+        run: interviewCommand,
+    },
+    key: {
+        help: [
+            ['ownit key set [nebius|nvidia]', 'Save your model API key (stored locally)'],
+            ['ownit key clear|status', 'Remove or show it'],
+        ],
+        run: keyCommand,
+    },
+    badge: { help: [['ownit badge', "Print this repo's badge Markdown for your README"]], run: badgeCommand },
+    settings: {
+        help: [
+            ['ownit settings', "Show this repo's settings and page link"],
+            ['ownit settings questions on|off', 'Show debrief questions on the page (admins)'],
+            ['ownit settings answers on|off', 'Show passing answers on the page (admins)'],
+            ['ownit settings earlier on|off', 'Count older commits once debriefed (admins)'],
+        ],
+        run: settingsCommand,
+    },
+    uninstall: { help: [['ownit uninstall', 'Remove the pre-push hook']], run: uninstallCommand },
+    help: { help: [['ownit help', 'Show this help']], run: () => print(helpText()) },
+    // Not listed: the installed git hook calls `ownit hook pre-push`.
+    hook: { run: (args) => hookCommand(args) },
+    version: { run: () => print(`${version()}\n`) },
+};
+const ALIASES = { page: 'settings', status: 'whoami', '--help': 'help', '-h': 'help', '--version': 'version', '-v': 'version' };
+function findCommand(name) {
+    const key = Object.hasOwn(ALIASES, name) ? ALIASES[name] : name;
+    return Object.hasOwn(COMMANDS, key) ? COMMANDS[key] : undefined;
+}
+function helpText() {
+    const usage = Object.values(COMMANDS)
+        .flatMap((command) => command.help ?? [])
+        .map(([line, description]) => `  ${line.padEnd(33)}${description}`)
+        .join('\n');
+    return `ownit: debrief the code you just pushed.
 
 Usage:
-  ownit login [--server URL]       Sign in with GitHub (device flow)
-  ownit logout                     Sign out
-  ownit whoami                     Show server, login, and key status
-  ownit init [--repo owner/name]   Install the pre-push hook in this repo
-  ownit interview                  Debrief pushes that are still pending
-  ownit interview --range A..B     Debrief a commit range
-  ownit key set [nebius|nvidia]    Save your model API key (stored locally)
-  ownit key clear|status           Remove or show it
-  ownit badge                      Print this repo's badge Markdown for your README
-  ownit uninstall                  Remove the pre-push hook
-  ownit help                       Show this help
+${usage}
 
 Set OWNIT_SKIP=1 to push once without a debrief prompt (the push is pending).
 `;
+}
 function version() {
     const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
     return pkg.version;
 }
+function print(text) {
+    process.stdout.write(text);
+    return 0;
+}
 async function main(argv) {
-    const [command, ...rest] = argv;
-    switch (command) {
-        case 'login':
-            return loginCommand(rest);
-        case 'logout':
-            return logoutCommand();
-        case 'whoami':
-        case 'status':
-            return whoamiCommand();
-        case 'init':
-            return initCommand(rest);
-        case 'uninstall':
-            return uninstallCommand();
-        case 'hook':
-            return hookCommand(rest);
-        case 'interview':
-            return interviewCommand(rest);
-        case 'key':
-            return keyCommand(rest);
-        case 'badge':
-            return badgeCommand();
-        case '--version':
-        case '-v':
-            process.stdout.write(`${version()}\n`);
-            return 0;
-        case undefined:
-        case 'help':
-        case '--help':
-        case '-h':
-            process.stdout.write(HELP);
-            return 0;
-        default:
-            process.stderr.write(`Unknown command "${command}".\n\n${HELP}`);
-            return 1;
+    const [name = 'help', ...args] = argv;
+    const command = findCommand(name);
+    if (!command) {
+        // Suggest only listed commands, so a typo never points at the hidden hook command.
+        const listed = Object.keys(COMMANDS).filter((key) => COMMANDS[key].help);
+        const guess = closestMatch(name, listed);
+        process.stderr.write(guess
+            ? `Unknown command "${name}". Did you mean "ownit ${guess}"?\nRun "ownit help" to see every command.\n`
+            : `Unknown command "${name}".\n\n${helpText()}`);
+        return 1;
     }
+    return command.run(args);
 }
 main(process.argv.slice(2)).then((code) => {
     process.exitCode = code;
 }, (error) => {
-    process.stderr.write(`Ownit: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.stderr.write(`Ownit: ${errorMessage(error)}\n`);
     process.exitCode = 1;
 });

package/dist/providers.js

@@ -0,0 +1,36 @@
+/**
+ * Model providers the worker accepts, in the order `ownit key set` lists them.
+ * Add a provider here and in the worker's PROVIDERS (worker/src/model.ts).
+ */
+export const PROVIDERS = {
+    nebius: { name: 'Nebius', envVar: 'NEBIUS_API_KEY', keyUrl: 'https://tokenfactory.nebius.com/', keyPrefix: undefined },
+    nvidia: { name: 'NVIDIA', envVar: 'NVIDIA_API_KEY', keyUrl: 'https://build.nvidia.com/', keyPrefix: 'nvapi-' },
+};
+export const PROVIDER_IDS = Object.keys(PROVIDERS);
+export function isProvider(value) {
+    return Object.hasOwn(PROVIDERS, value);
+}
+/** The key to send with debriefs and its provider. A provider's env var wins over the saved key. */
+export function modelKey(config, env = process.env) {
+    for (const provider of PROVIDER_IDS) {
+        const key = env[PROVIDERS[provider].envVar];
+        if (key)
+            return { provider, key };
+    }
+    if (config.apiKey)
+        return { provider: config.provider ?? 'nebius', key: config.apiKey };
+    if (config.nebiusKey)
+        return { provider: 'nebius', key: config.nebiusKey };
+    return undefined;
+}
+/** The provider whose keys have this key's prefix, if any. */
+export function providerByPrefix(key) {
+    return PROVIDER_IDS.find((id) => {
+        const prefix = PROVIDERS[id].keyPrefix;
+        return prefix !== undefined && key.startsWith(prefix);
+    });
+}
+/** e.g. "NVIDIA, …1a2b" */
+export function describeKey({ provider, key }) {
+    return `${PROVIDERS[provider]?.name ?? provider}, …${key.slice(-4)}`;
+}

package/dist/ui.js

@@ -5,6 +5,10 @@ export function paint(out) {
     const wrap = (code) => (text) => (on ? `\x1b[${code}m${text}\x1b[0m` : text);
     return { bold: wrap('1'), dim: wrap('2'), green: wrap('32'), red: wrap('31'), yellow: wrap('33'), cyan: wrap('36') };
 }
+/** "1 commit", "2 commits". Pass the plural form for irregular words. */
+export const plural = (n, singular, pluralForm = `${singular}s`) => (n === 1 ? singular : pluralForm);
+/** The message of whatever was thrown. */
+export const errorMessage = (error) => (error instanceof Error ? error.message : String(error));
 /** Ends a message with a period unless it already ends a sentence (server messages usually do). */
 export function sentence(text) {
     return /[.!?]$/.test(text.trimEnd()) ? text.trimEnd() : `${text.trimEnd()}.`;
@@ -91,3 +95,26 @@ export function wrap(text, indent = '  ', width = Math.min(process.stderr.column
         lines.push(line);
     return lines.map((l) => indent + l).join('\n');
 }
+/** Edit distance between two short strings (insert, delete, or replace one character). */
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j++) {
+            current[j] = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+/** The candidate a typo most likely meant, or null when none is close. */
+export function closestMatch(typed, candidates) {
+    const word = typed.toLowerCase();
+    let best = null;
+    for (const name of candidates) {
+        const distance = editDistance(word, name);
+        if (distance <= 2 && distance < (best?.distance ?? Infinity))
+            best = { name, distance };
+    }
+    return best?.name ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getownit",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Debrief the code you just pushed, in your terminal, with NVIDIA Nemotron.",
   "license": "MIT",
   "repository": {
@@ -31,6 +31,7 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build && npm test",
     "test": "vitest run",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },