getownit 0.1.0 → 0.1.1

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.
@@ -52,6 +52,60 @@ 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 record(api, repo, push, 'pending');
+    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, records a skip, or leaves the push pending. */
+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/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')
+            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) {
     const [event, remote = '', url = ''] = argv;
@@ -73,58 +127,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

@@ -4,7 +4,7 @@ import { buildDiff } from '../diff.js';
 import { runDebrief } from '../debrief.js';
 import { githubRepo, listCommits, objectExists, resolveCommit } 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,
@@ -55,7 +55,7 @@ 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`);
+    out.write(`${pushes.length} ${plural(pushes.length, 'push', 'pushes')} 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));

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/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,85 +1,111 @@
 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) {
     return /^(s|skip|:skip)$/i.test(answer.trim());
 }
+/** 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 (isSkip(answer))
+            return skip(api, out, debrief.session);
+        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;
+        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;
-        }
+    const debrief = { api, prompter, total: start.total, payload, session: start.session };
+    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`);
     return { status: 'verified' };
@@ -99,7 +125,7 @@ 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 +136,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,77 @@
 #!/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 { 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', 'Debrief pushes that are still pending'],
+            ['ownit interview --range A..B', 'Debrief a commit range'],
+        ],
+        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 },
+    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 = { 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) {
+        process.stderr.write(`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()}.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getownit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Debrief the code you just pushed, in your terminal, with NVIDIA Nemotron.",
   "license": "MIT",
   "repository": {