ultrahope 0.1.0 → 0.1.2

package/dist/git-ultrahope.js

@@ -1,12 +1,703 @@
 #!/usr/bin/env node
 
-// src/commands/commit.ts
+// commands/commit.ts
 import { execSync as execSync2, spawn as spawn2 } from "child_process";
 import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join4 } from "path";
 
-// src/lib/diff-stats.ts
+// lib/api-client.ts
+import createClient from "openapi-fetch";
+
+// lib/logger.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var LOG_DIR = join(homedir(), ".local", "state", "ultrahope");
+var LOG_FILE = join(LOG_DIR, "log");
+var initialized = false;
+function ensureLogDir() {
+  if (initialized) return;
+  try {
+    mkdirSync(LOG_DIR, { recursive: true });
+    initialized = true;
+  } catch {
+  }
+}
+function log(message, data) {
+  ensureLogDir();
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const line = data ? `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
+` : `[${timestamp}] ${message}
+`;
+  try {
+    appendFileSync(LOG_FILE, line);
+  } catch {
+  }
+}
+
+// lib/api-client.ts
+var API_BASE_URL = process.env.ULTRAHOPE_API_URL ?? "https://ultrahope.dev";
+var InsufficientBalanceError = class extends Error {
+  constructor(balance) {
+    super("Token balance exhausted");
+    this.balance = balance;
+    this.name = "InsufficientBalanceError";
+  }
+};
+var DailyLimitExceededError = class extends Error {
+  constructor(count, limit, resetsAt) {
+    super("Daily request limit reached");
+    this.count = count;
+    this.limit = limit;
+    this.resetsAt = resetsAt;
+    this.name = "DailyLimitExceededError";
+  }
+};
+var UnauthorizedError = class extends Error {
+  constructor() {
+    super("Unauthorized");
+    this.name = "UnauthorizedError";
+  }
+};
+async function getErrorText(response, error) {
+  if (error) {
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return String(error);
+    }
+  }
+  try {
+    return await response.text();
+  } catch (readError) {
+    return `Failed to read response body: ${readError instanceof Error ? readError.message : String(readError)}`;
+  }
+}
+function extractGatewayMetadata(providerMetadata) {
+  const gateway = providerMetadata?.gateway;
+  if (!gateway) return {};
+  const generationId = typeof gateway.generationId === "string" ? gateway.generationId : void 0;
+  const costValue = typeof gateway.marketCost === "string" && gateway.marketCost || typeof gateway.cost === "string" && gateway.cost ? String(gateway.marketCost ?? gateway.cost) : void 0;
+  const cost = costValue ? Number.parseFloat(costValue) : void 0;
+  return { generationId, cost };
+}
+function parseSseEvents(buffer) {
+  const events = [];
+  let remainder = buffer;
+  while (true) {
+    const separatorIndex = remainder.indexOf("\n\n");
+    if (separatorIndex === -1) break;
+    const rawEvent = remainder.slice(0, separatorIndex);
+    remainder = remainder.slice(separatorIndex + 2);
+    const lines = rawEvent.split("\n");
+    for (const line of lines) {
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (!payload) continue;
+      const parsed = JSON.parse(payload);
+      events.push(parsed);
+    }
+  }
+  return { events, remainder };
+}
+function handle402Error(error) {
+  const errorBalance = error?.balance;
+  if (typeof errorBalance === "number") {
+    log("generate error (402 insufficient_balance)", error);
+    throw new InsufficientBalanceError(errorBalance);
+  }
+  const payload = error;
+  const count = typeof payload?.count === "number" ? payload.count : 0;
+  const limit = typeof payload?.limit === "number" ? payload.limit : 0;
+  const resetsAt = payload?.resetsAt ?? "";
+  log("generate error (402 daily_limit)", error);
+  throw new DailyLimitExceededError(count, limit, resetsAt);
+}
+function createApiClient(token) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  const client = createClient({
+    baseUrl: API_BASE_URL,
+    headers
+  });
+  return {
+    async *streamCommitMessage(req, options) {
+      log("streamCommitMessage request", req);
+      const res = await fetch(`${API_BASE_URL}/api/v1/commit-message/stream`, {
+        method: "POST",
+        headers: {
+          ...headers,
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify(req),
+        signal: options?.signal
+      });
+      if (res.status === 401) {
+        log("streamCommitMessage error (401)");
+        throw new UnauthorizedError();
+      }
+      if (res.status === 402) {
+        let errorPayload;
+        try {
+          errorPayload = await res.json();
+        } catch {
+          errorPayload = await getErrorText(res, null);
+        }
+        handle402Error(errorPayload);
+      }
+      if (!res.ok) {
+        const text = await getErrorText(res, null);
+        log("streamCommitMessage error", {
+          status: res.status,
+          text
+        });
+        throw new Error(`API error: ${res.status} ${text}`);
+      }
+      if (!res.body) {
+        throw new Error("API error: empty response body");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      const reader = res.body.getReader();
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const parsed2 = parseSseEvents(buffer);
+          buffer = parsed2.remainder;
+          for (const event of parsed2.events) {
+            yield event;
+          }
+        }
+        buffer += decoder.decode();
+        const parsed = parseSseEvents(buffer);
+        for (const event of parsed.events) {
+          yield event;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    },
+    async recordGenerationScore(req) {
+      log("generation_score request", req);
+      const res = await fetch(`${API_BASE_URL}/api/v1/generation_score`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(req)
+      });
+      if (!res.ok) {
+        const text = await getErrorText(res, null);
+        log("generation_score error", { status: res.status, text });
+        throw new Error(`API error: ${res.status} ${text}`);
+      }
+    },
+    async commandExecution(req) {
+      log("command_execution request", req);
+      const { data, error, response } = await client.POST(
+        "/api/v1/command_execution",
+        {
+          body: req
+        }
+      );
+      if (response.status === 401) {
+        log("command_execution error (401)", error);
+        throw new UnauthorizedError();
+      }
+      if (response.status === 402) {
+        const payload = error;
+        const count = typeof payload?.count === "number" ? payload.count : 0;
+        const limit = typeof payload?.limit === "number" ? payload.limit : 0;
+        const resetsAt = payload?.resetsAt ?? "";
+        log("command_execution error (402)", error);
+        throw new DailyLimitExceededError(count, limit, resetsAt);
+      }
+      if (!response.ok) {
+        const text = await getErrorText(response, error);
+        log("command_execution error", { status: response.status, text });
+        throw new Error(`API error: ${response.status} ${text}`);
+      }
+      if (!data) {
+        throw new Error("API error: empty response");
+      }
+      log("command_execution response", data);
+      return data;
+    },
+    async generateCommitMessage(req, options) {
+      log("generateCommitMessage request", req);
+      const { data, error, response } = await client.POST(
+        "/api/v1/commit-message",
+        {
+          body: req,
+          signal: options?.signal
+        }
+      );
+      if (response.status === 401) {
+        log("generateCommitMessage error (401)", error);
+        throw new UnauthorizedError();
+      }
+      if (response.status === 402) {
+        handle402Error(error);
+      }
+      if (!response.ok) {
+        const text = await getErrorText(response, error);
+        log("generateCommitMessage error", { status: response.status, text });
+        throw new Error(`API error: ${response.status} ${text}`);
+      }
+      if (!data) {
+        throw new Error("API error: empty response");
+      }
+      log("generateCommitMessage response", data);
+      return data;
+    },
+    async generateCommitMessageStream(req, options) {
+      let lastCommitMessage = "";
+      let providerMetadata;
+      for await (const event of this.streamCommitMessage(req, options)) {
+        if (event.type === "commit-message") {
+          lastCommitMessage = event.commitMessage;
+        } else if (event.type === "provider-metadata") {
+          providerMetadata = event.providerMetadata;
+        } else if (event.type === "error") {
+          throw new Error(event.message);
+        }
+      }
+      if (!lastCommitMessage) {
+        throw new Error("API error: empty stream response");
+      }
+      const { generationId, cost } = extractGatewayMetadata(providerMetadata);
+      const result = {
+        output: lastCommitMessage,
+        cost,
+        generationId
+      };
+      log("generateCommitMessageStream response", result);
+      return result;
+    },
+    async generatePrTitleBody(req, options) {
+      log("generatePrTitleBody request", req);
+      const { data, error, response } = await client.POST(
+        "/api/v1/pr-title-body",
+        {
+          body: req,
+          signal: options?.signal
+        }
+      );
+      if (response.status === 401) {
+        log("generatePrTitleBody error (401)", error);
+        throw new UnauthorizedError();
+      }
+      if (response.status === 402) {
+        handle402Error(error);
+      }
+      if (!response.ok) {
+        const text = await getErrorText(response, error);
+        log("generatePrTitleBody error", { status: response.status, text });
+        throw new Error(`API error: ${response.status} ${text}`);
+      }
+      if (!data) {
+        throw new Error("API error: empty response");
+      }
+      log("generatePrTitleBody response", data);
+      return data;
+    },
+    async generatePrIntent(req, options) {
+      log("generatePrIntent request", req);
+      const { data, error, response } = await client.POST("/api/v1/pr-intent", {
+        body: req,
+        signal: options?.signal
+      });
+      if (response.status === 401) {
+        log("generatePrIntent error (401)", error);
+        throw new UnauthorizedError();
+      }
+      if (response.status === 402) {
+        handle402Error(error);
+      }
+      if (!response.ok) {
+        const text = await getErrorText(response, error);
+        log("generatePrIntent error", { status: response.status, text });
+        throw new Error(`API error: ${response.status} ${text}`);
+      }
+      if (!data) {
+        throw new Error("API error: empty response");
+      }
+      log("generatePrIntent response", data);
+      return data;
+    },
+    async requestDeviceCode() {
+      const res = await fetch(`${API_BASE_URL}/api/auth/device/code`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ client_id: "ultrahope-cli" })
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`API error: ${res.status} ${text}`);
+      }
+      return res.json();
+    },
+    async pollDeviceToken(deviceCode) {
+      const res = await fetch(`${API_BASE_URL}/api/auth/device/token`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: "ultrahope-cli"
+        })
+      });
+      if (!res.ok && res.status !== 400) {
+        const text = await res.text();
+        throw new Error(`API error: ${res.status} ${text}`);
+      }
+      return res.json();
+    }
+  };
+}
+
+// lib/abort.ts
+function mergeAbortSignals(...signals) {
+  const validSignals = signals.filter(
+    (signal) => signal !== void 0
+  );
+  if (validSignals.length === 0) return void 0;
+  if (validSignals.length === 1) return validSignals[0];
+  const controller = new AbortController();
+  for (const signal of validSignals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener(
+      "abort",
+      () => {
+        controller.abort(signal.reason);
+      },
+      { once: true }
+    );
+  }
+  return controller.signal;
+}
+function commandAbortReason(signal) {
+  if (!signal?.aborted) return void 0;
+  const reason = signal.reason;
+  if (reason === "daily_limit" || reason === "unauthorized") {
+    return reason;
+  }
+  if (reason === "user" || reason === "internal") {
+    return reason;
+  }
+  if (reason instanceof DailyLimitExceededError) return "daily_limit";
+  if (reason instanceof UnauthorizedError) return "unauthorized";
+  return "internal";
+}
+function isCommandExecutionAbort(signal) {
+  const reason = commandAbortReason(signal);
+  return reason === "daily_limit" || reason === "unauthorized";
+}
+function abortReasonForError(error) {
+  if (error instanceof DailyLimitExceededError) return "daily_limit";
+  if (error instanceof UnauthorizedError) return "unauthorized";
+  return "internal";
+}
+
+// lib/auth.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function getCredentialsPath() {
+  const configDir = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  const env = process.env.ULTRAHOPE_ENV;
+  const filename = env && env !== "production" ? `credentials.${env}.json` : "credentials.json";
+  return path.join(configDir, "ultrahope", filename);
+}
+async function getToken() {
+  const credPath = getCredentialsPath();
+  try {
+    const content = await fs.promises.readFile(credPath, "utf-8");
+    const creds = JSON.parse(content);
+    return creds.access_token ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// lib/command-execution.ts
+import { randomUUID } from "crypto";
+
+// lib/daily-limit-prompt.ts
+import { accessSync, constants, openSync } from "fs";
+import * as readline from "readline";
+import * as tty from "tty";
+import open from "open";
+
+// lib/format-time.ts
+function formatResetTime(resetsAt) {
+  const resetDate = new Date(resetsAt);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = resetDate.getTime() - now.getTime();
+  const local = resetDate.toLocaleTimeString(void 0, {
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZoneName: "short"
+  });
+  if (diffMs <= 0) {
+    return { relative: "now", local };
+  }
+  const diffMinutes = Math.ceil(diffMs / 6e4);
+  if (diffMinutes < 60) {
+    const unit2 = diffMinutes === 1 ? "minute" : "minutes";
+    return { relative: `in ${diffMinutes} ${unit2}`, local };
+  }
+  const diffHours = Math.ceil(diffMinutes / 60);
+  const unit = diffHours === 1 ? "hour" : "hours";
+  return { relative: `in ${diffHours} ${unit}`, local };
+}
+
+// lib/theme.ts
+var isColorDisabled = process.env.NO_COLOR !== void 0 || process.env.CI !== void 0 || !process.stdout.isTTY;
+function color(code) {
+  return isColorDisabled ? "" : code;
+}
+var theme = {
+  primary: color("\x1B[38;5;250m"),
+  secondary: color("\x1B[38;5;235m"),
+  success: color("\x1B[38;5;72m"),
+  progress: color("\x1B[38;5;74m"),
+  blocked: color("\x1B[38;5;179m"),
+  fatal: color("\x1B[38;5;167m"),
+  prompt: color("\x1B[38;5;81m"),
+  link: color("\x1B[38;5;81m"),
+  bold: color("\x1B[1m"),
+  dim: color("\x1B[2m"),
+  reset: color("\x1B[0m")
+};
+
+// lib/ui.ts
+function formatTotalCost(cost) {
+  return `$${cost.toFixed(6)}`;
+}
+var ui = {
+  success: (msg) => `${theme.success}\u2714${theme.reset} ${theme.primary}${msg}${theme.reset}`,
+  progress: (msg) => `${theme.progress}\u25B6${theme.reset} ${theme.primary}${msg}${theme.reset}`,
+  blocked: (msg) => `${theme.blocked}!${theme.reset} ${theme.primary}${msg}${theme.reset}`,
+  bullet: (msg) => `  ${theme.secondary}\u2022${theme.reset} ${theme.secondary}${msg}${theme.reset}`,
+  prompt: (msg) => `${theme.prompt}?${theme.reset} ${msg}`,
+  hint: (msg) => `${theme.dim}${msg}${theme.reset}`,
+  bold: (msg) => `${theme.bold}${msg}${theme.reset}`,
+  link: (msg) => `${theme.link}${msg}${theme.reset}`
+};
+
+// lib/daily-limit-prompt.ts
+var PRICING_URL = "https://ultrahope.dev/pricing";
+function canUseInteractive() {
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+  try {
+    accessSync("/dev/tty", constants.R_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function showDailyLimitPrompt(info) {
+  const { relative, local } = formatResetTime(info.resetsAt);
+  if (info.progress) {
+    console.log(
+      ui.blocked(
+        `Generating commit messages... ${info.progress.ready}/${info.progress.total}`
+      )
+    );
+  }
+  console.log("");
+  console.log(
+    `${theme.primary}Commit message generation was skipped${theme.reset}`
+  );
+  console.log("");
+  console.log(
+    ui.bullet(`Daily request limit reached (${info.count} / ${info.limit})`)
+  );
+  console.log(ui.bullet(`Resets ${relative} (${local})`));
+  console.log("");
+  if (!canUseInteractive()) {
+    console.log(
+      `${theme.primary}Run the same command again after the reset:${theme.reset}`
+    );
+    console.log(`  ${ui.link("ultrahope jj describe")}`);
+    console.log("");
+    console.log(`${theme.primary}Or upgrade your plan:${theme.reset}`);
+    console.log(`  ${ui.link(PRICING_URL)}`);
+    return;
+  }
+  console.log(`${theme.primary}What would you like to do?${theme.reset}`);
+  console.log("");
+  console.log(
+    `${theme.secondary}  1) Retry after the daily limit resets${theme.reset}`
+  );
+  console.log(
+    `${theme.secondary}  2) Upgrade your plan to continue immediately${theme.reset}`
+  );
+  console.log("");
+  const choice = await promptChoice();
+  switch (choice) {
+    case "1":
+      handleRetryLater();
+      break;
+    case "2":
+      await handleUpgrade();
+      break;
+    case "q":
+      break;
+  }
+}
+function promptChoice() {
+  return new Promise((resolve) => {
+    const fd = openSync("/dev/tty", "r");
+    const ttyInput = new tty.ReadStream(fd);
+    const rl = readline.createInterface({
+      input: ttyInput,
+      output: process.stdout,
+      terminal: true
+    });
+    process.stdout.write(
+      `${theme.prompt}Select an option [1-2], or press q to quit:${theme.reset} `
+    );
+    readline.emitKeypressEvents(ttyInput, rl);
+    ttyInput.setRawMode(true);
+    const cleanup = () => {
+      ttyInput.setRawMode(false);
+      rl.close();
+      ttyInput.destroy();
+      console.log("");
+    };
+    const handleKeypress = (str, key) => {
+      if (!key && !str) return;
+      if (str === "q" || str === "Q" || key?.name === "q" || key?.name === "c" && key.ctrl || key?.name === "escape") {
+        cleanup();
+        resolve("q");
+        return;
+      }
+      if (str === "1" || key?.name === "1" || key?.sequence === "1") {
+        cleanup();
+        resolve("1");
+        return;
+      }
+      if (str === "2" || key?.name === "2" || key?.sequence === "2") {
+        cleanup();
+        resolve("2");
+        return;
+      }
+    };
+    ttyInput.on("keypress", handleKeypress);
+  });
+}
+function handleRetryLater() {
+  console.log("");
+  console.log(ui.success("Will retry after the daily limit resets"));
+  console.log(ui.bullet("No requests were sent"));
+  console.log("");
+  console.log(
+    `${theme.primary}Run the same command again after the reset:${theme.reset}`
+  );
+  console.log(`  ${ui.link("ultrahope jj describe")}`);
+  console.log("");
+  return new Promise((resolve) => {
+    const fd = openSync("/dev/tty", "r");
+    const ttyInput = new tty.ReadStream(fd);
+    const rl = readline.createInterface({
+      input: ttyInput,
+      output: process.stdout,
+      terminal: true
+    });
+    readline.emitKeypressEvents(ttyInput, rl);
+    ttyInput.setRawMode(true);
+    const cleanup = () => {
+      ttyInput.setRawMode(false);
+      rl.close();
+      ttyInput.destroy();
+      console.log("");
+    };
+    const handleKeypress = (str, key) => {
+      if (!key && !str) return;
+      if (str === "\r" || str === "\n" || str === "q" || str === "Q" || key?.name === "return" || key?.name === "q" || key?.name === "c" && key.ctrl) {
+        cleanup();
+        resolve();
+      }
+    };
+    ttyInput.on("keypress", handleKeypress);
+  });
+}
+async function handleUpgrade() {
+  console.log("");
+  console.log(`${theme.primary}Opening pricing page:${theme.reset}`);
+  console.log(`  ${ui.link(PRICING_URL)}`);
+  try {
+    await open(PRICING_URL);
+  } catch {
+  }
+}
+
+// lib/command-execution.ts
+function startCommandExecution(options) {
+  const commandExecutionId = randomUUID();
+  const cliSessionId = commandExecutionId;
+  const abortController = new AbortController();
+  const commandExecutionPromise = options.api.commandExecution({
+    commandExecutionId,
+    cliSessionId,
+    command: options.command,
+    args: options.args,
+    api: options.apiPath,
+    requestPayload: options.requestPayload
+  });
+  return {
+    commandExecutionId,
+    cliSessionId,
+    abortController,
+    commandExecutionPromise
+  };
+}
+async function handleCommandExecutionError(error, options) {
+  if (error instanceof UnauthorizedError) {
+    const additionalLines = options?.additionalLinesToClear ?? 0;
+    if (additionalLines > 0) {
+      process.stdout.write(`\x1B[${additionalLines}A`);
+      process.stdout.write("\x1B[0J");
+    }
+    console.error(
+      "\x1B[31m\u2716\x1B[0m Unauthorized. Your session may have expired."
+    );
+    console.error("");
+    console.error(
+      "\x1B[2mPlease run the following command to re-authenticate:\x1B[0m"
+    );
+    console.error("");
+    console.error("  \x1B[36multrahope login\x1B[0m");
+    console.error("");
+    process.exit(1);
+  }
+  if (error instanceof DailyLimitExceededError) {
+    await showDailyLimitPrompt({
+      count: error.count,
+      limit: error.limit,
+      resetsAt: error.resetsAt,
+      progress: options?.progress
+    });
+    process.exit(1);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Error: Failed to start command execution. ${message}`);
+  process.exit(1);
+}
+
+// lib/diff-stats.ts
 import { execSync } from "child_process";
 function getGitStagedStats() {
   try {
@@ -38,33 +729,81 @@ function formatDiffStats(stats) {
   return parts.join(", ");
 }
 
-// src/lib/selector.ts
+// lib/selector.ts
 import { spawn } from "child_process";
 import {
-  accessSync,
-  constants,
+  accessSync as accessSync2,
+  constants as constants2,
   mkdtempSync,
-  openSync,
+  openSync as openSync2,
   readFileSync,
   unlinkSync,
   writeFileSync
 } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
-import * as readline from "readline";
-import * as tty from "tty";
-var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-function canUseInteractive() {
-  if (!process.stdout.isTTY) {
-    return false;
-  }
-  try {
-    accessSync("/dev/tty", constants.R_OK);
-    return true;
-  } catch {
-    return false;
-  }
+import { join as join3 } from "path";
+import * as readline3 from "readline";
+import * as tty2 from "tty";
+
+// lib/renderer.ts
+import * as readline2 from "readline";
+var SPINNER_FRAMES = [
+  "\u280B",
+  "\u2819",
+  "\u2839",
+  "\u2838",
+  "\u283C",
+  "\u2834",
+  "\u2826",
+  "\u2827",
+  "\u2807",
+  "\u280F"
+];
+function isTTY(output) {
+  return output.isTTY === true;
 }
+function createRenderer(output) {
+  let pendingHeight = 0;
+  let committedHeight = 0;
+  const render = (content) => {
+    if (!isTTY(output)) {
+      output.write(content);
+      return;
+    }
+    if (pendingHeight > 0) {
+      readline2.moveCursor(output, 0, -pendingHeight);
+      readline2.cursorTo(output, 0);
+      readline2.clearScreenDown(output);
+    }
+    output.write(content);
+    pendingHeight = content.split("\n").length - 1;
+  };
+  const flush = () => {
+    committedHeight += pendingHeight;
+    pendingHeight = 0;
+  };
+  const clearAll = () => {
+    if (!isTTY(output)) {
+      return;
+    }
+    const totalHeight = pendingHeight + committedHeight;
+    if (totalHeight > 0) {
+      readline2.moveCursor(output, 0, -totalHeight);
+      readline2.cursorTo(output, 0);
+      readline2.clearScreenDown(output);
+    }
+    pendingHeight = 0;
+    committedHeight = 0;
+  };
+  const reset = () => {
+    pendingHeight = 0;
+    committedHeight = 0;
+  };
+  return { render, flush, clearAll, reset };
+}
+
+// lib/selector.ts
+var TTY_PATH = "/dev/tty";
 function formatModelName(model) {
   const parts = model.split("/");
   return parts.length > 1 ? parts[1] : model;
@@ -72,48 +811,94 @@ function formatModelName(model) {
 function formatCost(cost) {
   return `$${cost.toFixed(7).replace(/0+$/, "").replace(/\.$/, "")}`;
 }
+function getReadyCount(slots) {
+  return slots.filter((s) => s.status === "ready").length;
+}
+function getTotalCost(slots) {
+  return slots.reduce((sum, slot) => {
+    if (slot.status === "ready" && slot.candidate.cost != null) {
+      return sum + slot.candidate.cost;
+    }
+    return sum;
+  }, 0);
+}
+function getLatestQuota(slots) {
+  for (const slot of slots) {
+    if (slot.status === "ready" && slot.candidate.quota) {
+      return slot.candidate.quota;
+    }
+  }
+  return void 0;
+}
+function hasReadySlot(slots) {
+  return slots.some((s) => s.status === "ready");
+}
+function getSelectedCandidate(slots, selectedIndex) {
+  const slot = slots[selectedIndex];
+  return slot?.status === "ready" ? slot.candidate : void 0;
+}
+function selectNearestReady(slots, startIndex, direction) {
+  for (let i = startIndex + direction; i >= 0 && i < slots.length; i += direction) {
+    if (slots[i]?.status === "ready") {
+      return i;
+    }
+  }
+  return startIndex;
+}
+function collapseToReady(slots) {
+  const readySlots = slots.filter((s) => s.status === "ready");
+  slots.length = 0;
+  for (const slot of readySlots) {
+    slots.push(slot);
+  }
+}
 function formatSlot(slot, selected) {
-  const radio = selected ? "\u25CF" : "\u25CB";
   if (slot.status === "pending") {
-    return [];
+    const radio2 = "\u25CB";
+    const line2 = `${theme.dim}  ${radio2}  Generating...${theme.reset}`;
+    const meta2 = slot.model ? `${theme.dim}     ${formatModelName(slot.model)}${theme.reset}` : "";
+    return meta2 ? [line2, meta2] : [line2];
   }
   const candidate = slot.candidate;
   const title = candidate.content.split("\n")[0]?.trim() || "";
   const modelInfo = candidate.model ? candidate.cost ? `${formatModelName(candidate.model)} ${formatCost(candidate.cost)}` : formatModelName(candidate.model) : "";
   if (selected) {
-    const line2 = `  ${radio}  \x1B[1m${title}\x1B[0m`;
-    const meta2 = modelInfo ? `     \x1B[36m${modelInfo}\x1B[0m` : "";
+    const radio2 = "\u25CF";
+    const line2 = `  ${radio2}  ${theme.bold}${title}${theme.reset}`;
+    const meta2 = modelInfo ? `     ${theme.progress}${modelInfo}${theme.reset}` : "";
     return meta2 ? [line2, meta2] : [line2];
   }
-  const line = `\x1B[2m  ${radio}  ${title}\x1B[0m`;
-  const meta = modelInfo ? `\x1B[2m     ${modelInfo}\x1B[0m` : "";
+  const radio = "\u25CB";
+  const line = `${theme.dim}  ${radio}  ${title}${theme.reset}`;
+  const meta = modelInfo ? `${theme.dim}     ${modelInfo}${theme.reset}` : "";
   return meta ? [line, meta] : [line];
 }
-var lastRenderLineCount = 0;
-function render(state) {
-  const { slots, selectedIndex, isGenerating, spinnerFrame, totalSlots } = state;
-  if (lastRenderLineCount > 0) {
-    process.stdout.write(`\x1B[${lastRenderLineCount}A`);
-    process.stdout.write("\x1B[0J");
-  }
+function formatTotalCostLabel(cost) {
+  return `$${cost.toFixed(6)}`;
+}
+function renderSelector(state, nowMs, renderer) {
+  const { slots, selectedIndex, isGenerating, totalSlots } = state;
   const lines = [];
-  const readyCount = slots.filter((s) => s.status === "ready").length;
+  const readyCount = getReadyCount(slots);
+  const totalCost = getTotalCost(slots);
+  const costSuffix = totalCost > 0 ? ` (total: ${formatTotalCostLabel(totalCost)})` : "";
   if (isGenerating) {
-    const spinner = SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
+    const frameIndex = Math.floor(nowMs / 80) % SPINNER_FRAMES.length;
+    const spinner = SPINNER_FRAMES[frameIndex];
     const progress = `${readyCount}/${totalSlots}`;
     lines.push(
-      `\x1B[33m${spinner}\x1B[0m Generating commit messages... ${progress}`
+      `${theme.progress}${spinner}${theme.reset} ${theme.primary}Generating commit messages... ${progress}${costSuffix}${theme.reset}`
     );
   } else {
-    const label = readyCount === 1 ? "1 commit message generated" : `${readyCount} commit messages generated`;
-    lines.push(`\x1B[32m\u2714\x1B[0m ${label}`);
+    const label = readyCount === 1 ? `1 commit message generated${costSuffix}` : `${readyCount} commit messages generated${costSuffix}`;
+    lines.push(ui.success(label));
   }
   const hasReady = readyCount > 0;
   if (hasReady) {
-    const hint = "\x1B[2m\u2191\u2193 navigate  \u23CE confirm  e edit  r reroll  q quit\x1B[0m";
-    lines.push(`\x1B[36m?\x1B[0m Select a commit message ${hint}`);
+    const hint = ui.hint("\u2191\u2193 navigate  \u23CE confirm  e edit  r reroll  q quit");
+    lines.push(ui.prompt(`Select a commit message ${hint}`));
   } else {
-    lines.push("\x1B[2m  q quit\x1B[0m");
+    lines.push(ui.hint("  q quit"));
   }
   lines.push("");
   for (let i = 0; i < slots.length; i++) {
@@ -125,16 +910,27 @@ function render(state) {
       lines.push("");
     }
   }
+  renderer.render(`${lines.join("\n")}
+`);
+}
+function renderError(error, slots, totalSlots, output) {
+  const readyCount = slots.filter((s) => s.status === "ready").length;
+  const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+  const lines = [
+    ui.blocked(`Generating commit messages... ${readyCount}/${totalSlots}`),
+    "",
+    `${theme.fatal}Error: ${message}${theme.reset}`
+  ];
   for (const line of lines) {
-    console.log(line);
+    output.write(`${line}
+`);
   }
-  lastRenderLineCount = lines.length;
 }
 function openEditor(content) {
   return new Promise((resolve, reject) => {
     const editor = process.env.GIT_EDITOR || process.env.EDITOR || "vi";
-    const tmpDir = mkdtempSync(join(tmpdir(), "ultrahope-"));
-    const tmpFile = join(tmpDir, "EDIT_MESSAGE");
+    const tmpDir = mkdtempSync(join3(tmpdir(), "ultrahope-"));
+    const tmpFile = join3(tmpDir, "EDIT_MESSAGE");
     writeFileSync(tmpFile, content);
     const child = spawn(editor, [tmpFile], { stdio: "inherit" });
     child.on("close", (code) => {
@@ -157,462 +953,439 @@ function openEditor(content) {
   });
 }
 async function selectCandidate(options) {
-  const { candidates, maxSlots = 4 } = options;
-  if (Array.isArray(candidates)) {
-    if (!canUseInteractive() || candidates.length === 0) {
-      return {
-        action: "confirm",
-        selected: candidates[0]?.content,
-        selectedIndex: 0
-      };
+  const { createCandidates, maxSlots = 4, abortSignal, models } = options;
+  const abortController = new AbortController();
+  if (abortSignal?.aborted) {
+    abortController.abort();
+    return { action: "abort" };
+  }
+  if (abortSignal) {
+    abortSignal.addEventListener("abort", () => abortController.abort(), {
+      once: true
+    });
+  }
+  const candidates = createCandidates(abortController.signal);
+  let ttyInput = null;
+  let ttyOutput = null;
+  try {
+    accessSync2(TTY_PATH, constants2.R_OK | constants2.W_OK);
+    const inputFd = openSync2(TTY_PATH, "r");
+    ttyInput = new tty2.ReadStream(inputFd);
+    if (process.stdout.isTTY) {
+      ttyOutput = process.stdout;
+    } else {
+      const outputFd = openSync2(TTY_PATH, "w");
+      ttyOutput = new tty2.WriteStream(outputFd);
     }
-    const slots2 = candidates.map((c) => ({
-      status: "ready",
-      candidate: c
-    }));
-    return selectFromSlots(slots2, null);
+  } catch {
+    console.error(
+      "Error: /dev/tty is not available. Use --no-interactive for non-interactive mode."
+    );
+    process.exit(1);
   }
-  if (!canUseInteractive()) {
-    const first = await (async () => {
-      for await (const c of candidates) return c;
-      return void 0;
-    })();
-    return {
-      action: "confirm",
-      selected: first?.content,
-      selectedIndex: 0
-    };
+  if (!ttyInput || !ttyOutput) {
+    console.error(
+      "Error: /dev/tty is not available. Use --no-interactive for non-interactive mode."
+    );
+    process.exit(1);
   }
-  const slots = Array.from({ length: maxSlots }, () => ({
-    status: "pending"
+  const slots = Array.from({ length: maxSlots }, (_, i) => ({
+    status: "pending",
+    slotId: models?.[i] ?? `slot-${i}`,
+    model: models?.[i]
   }));
-  const abortController = new AbortController();
-  return selectFromSlots(slots, { candidates, abortController });
+  return selectFromSlots(
+    slots,
+    { candidates, abortController, abortSignal },
+    { input: ttyInput, output: ttyOutput }
+  );
 }
-async function selectFromSlots(initialSlots, asyncCtx) {
+async function selectFromSlots(initialSlots, asyncCtx, ttyIo) {
   return new Promise((resolve) => {
-    let selectedIndex = 0;
+    let resolved = false;
+    const resolveOnce = (result) => {
+      if (resolved) return;
+      resolved = true;
+      resolve(result);
+    };
     const slots = [...initialSlots];
-    const totalSlots = initialSlots.length;
-    let isGenerating = asyncCtx !== null;
-    let spinnerFrame = 0;
-    let spinnerInterval = null;
-    const fd = openSync("/dev/tty", "r");
-    const ttyInput = new tty.ReadStream(fd);
-    const rl = readline.createInterface({
+    const state = {
+      slots,
+      selectedIndex: 0,
+      isGenerating: asyncCtx !== null,
+      totalSlots: initialSlots.length
+    };
+    let renderInterval = null;
+    let cleanedUp = false;
+    const ttyInput = ttyIo.input;
+    const ttyOutput = ttyIo.output;
+    const renderer = createRenderer(ttyOutput);
+    const rl = readline3.createInterface({
       input: ttyInput,
-      output: process.stdout,
+      output: ttyOutput,
       terminal: true
     });
-    readline.emitKeypressEvents(ttyInput, rl);
+    readline3.emitKeypressEvents(ttyInput, rl);
     ttyInput.setRawMode(true);
     const doRender = () => {
-      render({ slots, selectedIndex, isGenerating, spinnerFrame, totalSlots });
+      if (!cleanedUp) {
+        renderSelector(state, Date.now(), renderer);
+      }
     };
-    doRender();
-    if (isGenerating) {
-      spinnerInterval = setInterval(() => {
-        spinnerFrame++;
+    const updateState = (update) => {
+      update(state);
+      doRender();
+    };
+    const startRenderLoop = () => {
+      if (!state.isGenerating) return;
+      renderInterval = setInterval(() => {
         doRender();
       }, 80);
-    }
-    const cleanup = () => {
+    };
+    const stopRenderLoop = () => {
+      if (!renderInterval) return;
+      clearInterval(renderInterval);
+      renderInterval = null;
+    };
+    doRender();
+    startRenderLoop();
+    const cancelGeneration = () => {
       asyncCtx?.abortController.abort();
-      if (spinnerInterval) {
-        clearInterval(spinnerInterval);
-        spinnerInterval = null;
+    };
+    const cleanup = (clearOutput = true) => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      stopRenderLoop();
+      if (clearOutput) {
+        renderer.clearAll();
       }
       ttyInput.setRawMode(false);
       rl.close();
       ttyInput.destroy();
-      if (lastRenderLineCount > 0) {
-        process.stdout.write(`\x1B[${lastRenderLineCount}A`);
-        process.stdout.write("\x1B[0J");
-      }
-      lastRenderLineCount = 0;
+      ttyOutput.destroy();
+    };
+    const nextCandidate = async (iterator) => {
+      const abortPromise = new Promise(
+        (resolve2) => {
+          asyncCtx?.abortController.signal.addEventListener(
+            "abort",
+            () => resolve2({ done: true, value: void 0 }),
+            { once: true }
+          );
+        }
+      );
+      return Promise.race([iterator.next(), abortPromise]);
+    };
+    const finalizeGeneration = () => {
+      collapseToReady(slots);
+      stopRenderLoop();
+      updateState((draft) => {
+        if (draft.selectedIndex >= slots.length) {
+          draft.selectedIndex = Math.max(0, slots.length - 1);
+        }
+        draft.isGenerating = false;
+      });
     };
     if (asyncCtx) {
+      const iterator = asyncCtx.candidates[Symbol.asyncIterator]();
       (async () => {
-        let i = 0;
         try {
-          for await (const candidate of asyncCtx.candidates) {
-            if (asyncCtx.abortController.signal.aborted) break;
-            if (i < slots.length) {
-              slots[i] = { status: "ready", candidate };
-              if (selectedIndex >= slots.length || slots[selectedIndex].status === "pending") {
-                selectedIndex = i;
-              }
-              doRender();
-              i++;
+          while (!cleanedUp) {
+            const result = await nextCandidate(iterator);
+            if (result.done || cleanedUp) break;
+            const candidate = result.value;
+            const targetIndex = slots.findIndex(
+              (slot) => slot.status === "pending" ? slot.slotId === candidate.slotId : slot.candidate.slotId === candidate.slotId
+            );
+            if (targetIndex >= 0 && targetIndex < slots.length) {
+              const isNewSlot = slots[targetIndex].status === "pending";
+              updateState((draft) => {
+                slots[targetIndex] = { status: "ready", candidate };
+                if (isNewSlot && (draft.selectedIndex >= slots.length || slots[draft.selectedIndex].status === "pending")) {
+                  draft.selectedIndex = targetIndex;
+                }
+              });
             }
           }
-          const readySlots = slots.filter((s) => s.status === "ready");
-          slots.length = readySlots.length;
-          for (let j = 0; j < readySlots.length; j++) {
-            slots[j] = readySlots[j];
-          }
-          if (selectedIndex >= slots.length) {
-            selectedIndex = Math.max(0, slots.length - 1);
-          }
-          isGenerating = false;
-          if (spinnerInterval) {
-            clearInterval(spinnerInterval);
-            spinnerInterval = null;
-          }
-          doRender();
+          if (cleanedUp) return;
+          finalizeGeneration();
         } catch (err) {
-          if (!asyncCtx.abortController.signal.aborted) {
-            console.error("Error fetching candidates:", err);
+          if (asyncCtx?.abortController.signal.aborted || err instanceof Error && err.name === "AbortError") {
+            return;
           }
+          if (!cleanedUp) {
+            cancelGeneration();
+            renderer.clearAll();
+            renderError(err, slots, state.totalSlots, ttyOutput);
+            cleanup(false);
+            resolveOnce({ action: "abort" });
+          }
+        } finally {
+          iterator.return?.();
         }
       })();
     }
-    const getSelectedCandidate = () => {
-      const slot = slots[selectedIndex];
-      return slot?.status === "ready" ? slot.candidate : void 0;
+    const confirmSelection = () => {
+      const candidate = getSelectedCandidate(slots, state.selectedIndex);
+      if (!candidate) return;
+      cancelGeneration();
+      const totalCost = getTotalCost(slots);
+      const quota = getLatestQuota(slots);
+      resolveOnce({
+        action: "confirm",
+        selected: candidate.content,
+        selectedIndex: state.selectedIndex,
+        selectedCandidate: candidate,
+        totalCost: totalCost > 0 ? totalCost : void 0,
+        quota
+      });
+      cleanup();
+    };
+    const rerollSelection = () => {
+      if (!hasReadySlot(slots)) return;
+      cancelGeneration();
+      resolveOnce({ action: "reroll" });
+      cleanup();
+    };
+    const abortSelection = () => {
+      cancelGeneration();
+      cleanup();
+      resolveOnce({ action: "abort" });
+    };
+    const editSelection = async () => {
+      const candidate = getSelectedCandidate(slots, state.selectedIndex);
+      if (!candidate) return;
+      renderer.flush();
+      ttyInput.setRawMode(false);
+      let edited = null;
+      try {
+        const result = await openEditor(candidate.content);
+        edited = result ? result : null;
+      } catch {
+      }
+      ttyInput.setRawMode(true);
+      renderer.reset();
+      updateState(() => {
+        if (!edited) return;
+        slots[state.selectedIndex] = {
+          status: "ready",
+          candidate: { ...candidate, content: edited }
+        };
+      });
     };
-    const hasReadySlot = () => slots.some((s) => s.status === "ready");
     const handleKeypress = async (_str, key) => {
       if (!key) return;
       if (key.name === "q" || key.name === "c" && key.ctrl || key.name === "escape") {
-        cleanup();
-        resolve({ action: "abort" });
+        abortSelection();
         return;
       }
       if (key.name === "return") {
-        const candidate = getSelectedCandidate();
-        if (!candidate) return;
-        cleanup();
-        resolve({
-          action: "confirm",
-          selected: candidate.content,
-          selectedIndex
-        });
+        confirmSelection();
         return;
       }
       if (key.name === "r") {
-        if (!hasReadySlot()) return;
-        cleanup();
-        resolve({ action: "reroll" });
+        rerollSelection();
         return;
       }
       if (key.name === "e") {
-        const candidate = getSelectedCandidate();
-        if (!candidate) return;
-        ttyInput.setRawMode(false);
-        try {
-          const edited = await openEditor(candidate.content);
-          if (edited) {
-            slots[selectedIndex] = {
-              status: "ready",
-              candidate: { ...candidate, content: edited }
-            };
-          }
-        } catch {
-        }
-        ttyInput.setRawMode(true);
-        doRender();
+        await editSelection();
         return;
       }
       if (key.name === "up" || key.name === "k") {
-        for (let i = selectedIndex - 1; i >= 0; i--) {
-          if (slots[i]?.status === "ready") {
-            selectedIndex = i;
-            doRender();
-            break;
-          }
-        }
+        updateState((draft) => {
+          draft.selectedIndex = selectNearestReady(
+            slots,
+            draft.selectedIndex,
+            -1
+          );
+        });
         return;
       }
       if (key.name === "down" || key.name === "j") {
-        for (let i = selectedIndex + 1; i < slots.length; i++) {
-          if (slots[i]?.status === "ready") {
-            selectedIndex = i;
-            doRender();
-            break;
-          }
-        }
+        updateState((draft) => {
+          draft.selectedIndex = selectNearestReady(
+            slots,
+            draft.selectedIndex,
+            1
+          );
+        });
         return;
       }
       const num = Number.parseInt(key.name || "", 10);
       if (num >= 1 && num <= slots.length && slots[num - 1]?.status === "ready") {
-        selectedIndex = num - 1;
-        doRender();
+        updateState((draft) => {
+          draft.selectedIndex = num - 1;
+        });
         return;
       }
     };
-    ttyInput.on("keypress", handleKeypress);
-  });
-}
-
-// src/lib/api-client.ts
-import createClient from "openapi-fetch";
-
-// src/lib/logger.ts
-import { appendFileSync, mkdirSync } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
-var LOG_DIR = join2(homedir(), ".local", "state", "ultrahope");
-var LOG_FILE = join2(LOG_DIR, "log");
-var initialized = false;
-function ensureLogDir() {
-  if (initialized) return;
-  try {
-    mkdirSync(LOG_DIR, { recursive: true });
-    initialized = true;
-  } catch {
-  }
-}
-function log(message, data) {
-  ensureLogDir();
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  const line = data ? `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
-` : `[${timestamp}] ${message}
-`;
-  try {
-    appendFileSync(LOG_FILE, line);
-  } catch {
-  }
-}
-
-// src/lib/api-client.ts
-var API_BASE_URL = process.env.ULTRAHOPE_API_URL ?? "https://ultrahope.dev";
-var InsufficientBalanceError = class extends Error {
-  constructor(balance) {
-    super("Token balance exhausted");
-    this.balance = balance;
-    this.name = "InsufficientBalanceError";
-  }
-};
-function createApiClient(token) {
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (token) {
-    headers.Authorization = `Bearer ${token}`;
-  }
-  const client = createClient({
-    baseUrl: API_BASE_URL,
-    headers
-  });
-  return {
-    async translate(req) {
-      log("translate request", req);
-      const { data, error, response } = await client.POST("/api/v1/translate", {
-        body: req
-      });
-      if (response.status === 402) {
-        const errorBalance = error?.balance;
-        const balance = typeof errorBalance === "number" ? errorBalance : 0;
-        log("translate error (402)", error);
-        throw new InsufficientBalanceError(balance);
-      }
-      if (!response.ok) {
-        const text = await response.text();
-        log("translate error", { status: response.status, text });
-        throw new Error(`API error: ${response.status} ${text}`);
-      }
-      if (!data) {
-        throw new Error("API error: empty response");
-      }
-      log("translate response", data);
-      return data;
-    },
-    async requestDeviceCode() {
-      const res = await fetch(`${API_BASE_URL}/api/auth/device/code`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ client_id: "ultrahope-cli" })
-      });
-      if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`API error: ${res.status} ${text}`);
-      }
-      return res.json();
-    },
-    async pollDeviceToken(deviceCode) {
-      const res = await fetch(`${API_BASE_URL}/api/auth/device/token`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-          device_code: deviceCode,
-          client_id: "ultrahope-cli"
-        })
-      });
-      if (!res.ok && res.status !== 400) {
-        const text = await res.text();
-        throw new Error(`API error: ${res.status} ${text}`);
+    if (asyncCtx?.abortSignal) {
+      if (asyncCtx.abortSignal.aborted) {
+        abortSelection();
+      } else {
+        asyncCtx.abortSignal.addEventListener("abort", abortSelection, {
+          once: true
+        });
       }
-      return res.json();
-    }
-  };
-}
-
-// src/lib/auth.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-function getCredentialsPath() {
-  const configDir = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
-  const env = process.env.ULTRAHOPE_ENV;
-  const filename = env && env !== "production" ? `credentials.${env}.json` : "credentials.json";
-  return path.join(configDir, "ultrahope", filename);
-}
-async function getToken() {
-  const credPath = getCredentialsPath();
-  try {
-    const content = await fs.promises.readFile(credPath, "utf-8");
-    const creds = JSON.parse(content);
-    return creds.access_token ?? null;
-  } catch {
-    return null;
-  }
-}
-
-// src/lib/mock-api-client.ts
-var MOCK_COMMIT_MESSAGES = [
-  "feat: implement new feature with improved performance",
-  "fix: resolve edge case in data processing logic",
-  "refactor: simplify code structure for better maintainability",
-  "docs: update README with usage examples",
-  "chore: update dependencies to latest versions",
-  "test: add unit tests for core functionality",
-  "style: format code according to style guide",
-  "perf: optimize algorithm for faster execution"
-];
-var MOCK_PR_TITLES = [
-  "Add new authentication flow",
-  "Fix memory leak in worker process",
-  "Refactor database connection handling",
-  "Update documentation for API endpoints"
-];
-var MOCK_PR_BODIES = [
-  `## Summary
-This PR adds a new authentication flow that improves security and user experience.
-
-## Changes
-- Added OAuth2 support
-- Implemented token refresh logic
-- Updated session management
-
-## Testing
-- Added unit tests for auth module
-- Tested manually with staging environment`
-];
-function getMockOutput(target) {
-  let pool;
-  switch (target) {
-    case "vcs-commit-message":
-      pool = MOCK_COMMIT_MESSAGES;
-      break;
-    case "pr-title-body":
-      pool = MOCK_PR_TITLES.map(
-        (title, i) => `${title}
-
-${MOCK_PR_BODIES[i % MOCK_PR_BODIES.length]}`
-      );
-      break;
-    case "pr-intent":
-      pool = MOCK_PR_TITLES;
-      break;
-    default:
-      pool = MOCK_COMMIT_MESSAGES;
-  }
-  const shuffled = [...pool].sort(() => Math.random() - 0.5);
-  return shuffled[0];
-}
-function createMockApiClient() {
-  return {
-    async translate(req) {
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      const output = getMockOutput(req.target);
-      return {
-        output,
-        content: output,
-        vendor: "mock",
-        model: "mock/mock-model",
-        inputTokens: 100,
-        outputTokens: 50,
-        cost: 1e-3
-      };
-    },
-    async requestDeviceCode() {
-      return {
-        device_code: "mock-device-code",
-        user_code: "MOCK-1234",
-        verification_uri: "https://ultrahope.dev/device",
-        expires_in: 900,
-        interval: 5
-      };
-    },
-    async pollDeviceToken(_deviceCode) {
-      return {
-        access_token: "mock-access-token",
-        token_type: "Bearer"
-      };
     }
-  };
+    ttyInput.on("keypress", handleKeypress);
+  });
 }
 
-// src/lib/vcs-message-generator.ts
+// lib/vcs-message-generator.ts
 var DEFAULT_MODELS = [
-  "mistral/mistral-nemo",
-  "cerebras/llama-3.1-8b",
-  "openai/gpt-5-nano",
+  // "mistral/ministral-3b",
+  // "cerebras/qwen-3-235b",
+  // "openai/gpt-5.1",
+  "mistral/ministral-3b",
   "xai/grok-code-fast-1"
 ];
-async function* generateCommitMessages(options) {
-  const { diff, models, mock = false } = options;
-  if (mock) {
-    const api2 = createMockApiClient();
-    for (const model of models) {
-      const result = await api2.translate({
-        input: diff,
-        model,
-        target: "vcs-commit-message"
-      });
-      yield { content: result.output, model };
-    }
+var isAbortError = (error) => error instanceof Error && error.name === "AbortError";
+var isInvalidCliSessionIdError = (error) => error instanceof Error && error.message.includes("Invalid cliSessionId");
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var createAbortPromise = (signal) => signal ? new Promise((resolve) => {
+  if (signal.aborted) {
+    resolve(null);
     return;
   }
+  signal.addEventListener("abort", () => resolve(null), { once: true });
+}) : null;
+async function* generateCommitMessages(options) {
+  const {
+    diff,
+    models,
+    signal,
+    cliSessionId,
+    commandExecutionPromise,
+    useStream = false
+  } = options;
+  const resolvedCliSessionId = cliSessionId;
+  if (!resolvedCliSessionId) {
+    throw new Error("Missing cliSessionId for generate request.");
+  }
+  const requiredCliSessionId = resolvedCliSessionId;
   const token = await getToken();
   if (!token) {
     console.error("Error: Not authenticated. Run `ultrahope login` first.");
     process.exit(1);
   }
   const api = createApiClient(token);
-  const pending = models.map((model, index) => ({
-    promise: (async () => {
+  const generateWithRetry = async function* (payload) {
+    const maxAttempts = 3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
       try {
-        const result = await api.translate({
-          input: diff,
-          model,
-          target: "vcs-commit-message"
-        });
-        return {
-          result: {
-            content: result.output,
-            model,
-            cost: result.cost
-          },
-          index
-        };
+        for await (const event of api.streamCommitMessage(payload, {
+          signal
+        })) {
+          log("generate", event);
+          yield event;
+        }
+        return;
       } catch (error) {
-        if (error instanceof InsufficientBalanceError) {
-          throw error;
+        if (signal?.aborted || isAbortError(error)) throw error;
+        if (isInvalidCliSessionIdError(error)) {
+          if (commandExecutionPromise) {
+            try {
+              await commandExecutionPromise;
+              continue;
+            } catch {
+              const abortError = new Error("Aborted");
+              abortError.name = "AbortError";
+              throw abortError;
+            }
+          }
+          if (attempt < maxAttempts - 1) {
+            await delay(80 * (attempt + 1));
+            continue;
+          }
+        }
+        throw error;
+      }
+    }
+    throw new Error("Failed to generate after retries.");
+  };
+  async function* generateForModel(model, slotIndex) {
+    try {
+      if (signal?.aborted) return;
+      let lastCommitMessage = "";
+      let providerMetadata;
+      for await (const event of generateWithRetry({
+        cliSessionId: requiredCliSessionId,
+        input: diff,
+        model
+      })) {
+        if (event.type === "commit-message") {
+          lastCommitMessage = event.commitMessage;
+          if (useStream) {
+            yield {
+              content: lastCommitMessage,
+              slotId: model,
+              model,
+              isPartial: true,
+              slotIndex
+            };
+          }
+        } else if (event.type === "provider-metadata") {
+          providerMetadata = event.providerMetadata;
+        } else if (event.type === "error") {
+          throw new Error(event.message);
         }
-        return { result: null, index };
       }
-    })(),
+      if (lastCommitMessage) {
+        const { generationId, cost } = extractGatewayMetadata(providerMetadata);
+        yield {
+          content: lastCommitMessage,
+          slotId: model,
+          model,
+          cost,
+          generationId,
+          ...useStream ? { isPartial: false } : {},
+          slotIndex
+        };
+      }
+    } catch (error) {
+      if (signal?.aborted || isAbortError(error)) return;
+      if (error instanceof InsufficientBalanceError) throw error;
+      if (isInvalidCliSessionIdError(error)) throw error;
+    }
+  }
+  const iterators = models.map((model, index) => ({
+    iterator: generateForModel(model, index)[Symbol.asyncIterator](),
     index
   }));
-  const remaining = new Map(pending.map((p) => [p.index, p.promise]));
+  const pending = /* @__PURE__ */ new Map();
+  const startNext = (it) => {
+    const promise = it.iterator.next().then((result) => ({
+      result,
+      index: it.index
+    }));
+    pending.set(it.index, {
+      iterator: it.iterator,
+      promise,
+      index: it.index
+    });
+  };
+  for (const it of iterators) {
+    startNext(it);
+  }
+  const abortPromise = createAbortPromise(signal);
   try {
-    while (remaining.size > 0) {
-      const { result, index } = await Promise.race(remaining.values());
-      remaining.delete(index);
-      if (result) yield result;
+    while (pending.size > 0) {
+      if (signal?.aborted) break;
+      const next = Promise.race(
+        Array.from(pending.values()).map((p) => p.promise)
+      );
+      const winner = abortPromise ? await Promise.race([next, abortPromise]) : await next;
+      if (!winner || signal?.aborted) break;
+      const { result, index } = winner;
+      const entry = pending.get(index);
+      if (!entry) continue;
+      if (result.done) {
+        pending.delete(index);
+      } else {
+        yield result.value;
+        startNext({ iterator: entry.iterator, index });
+      }
     }
   } catch (error) {
     if (error instanceof InsufficientBalanceError) {
@@ -625,17 +1398,23 @@ async function* generateCommitMessages(options) {
   }
 }
 
-// src/commands/commit.ts
+// commands/commit.ts
+function showQuotaInfo(quota) {
+  const { relative, local } = formatResetTime(quota.resetsAt);
+  console.log("");
+  console.log(
+    ui.hint(
+      `Daily quota: ${quota.remaining} of ${quota.limit} remaining. Resets ${relative} (${local}).`
+    )
+  );
+}
 function parseArgs(args2) {
   let models = [];
-  let mock = false;
   for (let i = 0; i < args2.length; i++) {
     const arg = args2[i];
     if (arg === "--models" && args2[i + 1]) {
       models = args2[i + 1].split(",").map((m) => m.trim());
       i++;
-    } else if (arg === "--mock") {
-      mock = true;
     }
   }
   if (models.length === 0) {
@@ -643,9 +1422,7 @@ function parseArgs(args2) {
   }
   return {
     message: args2.includes("-m") || args2.includes("--message"),
-    dryRun: args2.includes("--dry-run"),
     interactive: !args2.includes("--no-interactive"),
-    mock,
     models
   };
 }
@@ -700,23 +1477,70 @@ async function commit(args2) {
     );
     process.exit(1);
   }
-  const createGenerator = () => generateCommitMessages({
+  const token = await getToken();
+  if (!token) {
+    console.error("Error: Not authenticated. Run `ultrahope login` first.");
+    process.exit(1);
+  }
+  const api = createApiClient(token);
+  const {
+    commandExecutionPromise: promise,
+    abortController,
+    cliSessionId: id
+  } = startCommandExecution({
+    api,
+    command: "commit",
+    args: args2,
+    apiPath: "/v1/commit-message",
+    requestPayload: {
+      input: diff,
+      target: "vcs-commit-message",
+      models: options.models
+    }
+  });
+  const cliSessionId = id;
+  const commandExecutionSignal = abortController.signal;
+  const commandExecutionPromise = promise;
+  const apiClient = api;
+  commandExecutionPromise.catch(async (error) => {
+    abortController.abort(abortReasonForError(error));
+    await handleCommandExecutionError(error, {
+      progress: { ready: 0, total: options.models.length }
+    });
+  });
+  const recordSelection = async (generationId) => {
+    if (!generationId || !apiClient) return;
+    try {
+      await apiClient.recordGenerationScore({
+        generationId,
+        value: 1
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Generation not found")) {
+        return;
+      }
+      console.error(`Warning: Failed to record selection. ${message}`);
+    }
+  };
+  const createCandidates = (signal) => generateCommitMessages({
     diff,
     models: options.models,
-    mock: options.mock
+    signal: mergeAbortSignals(signal, commandExecutionSignal),
+    cliSessionId,
+    commandExecutionPromise
   });
   if (!options.interactive) {
     const gen = generateCommitMessages({
       diff,
       models: options.models.slice(0, 1),
-      mock: options.mock
+      signal: commandExecutionSignal,
+      cliSessionId,
+      commandExecutionPromise
     });
     const first = await gen.next();
+    await recordSelection(first.value?.generationId);
     const message = first.value?.content ?? "";
-    if (options.dryRun) {
-      console.log(message);
-      return;
-    }
     if (options.message) {
       commitWithMessage(message);
       return;
@@ -729,21 +1553,19 @@ async function commit(args2) {
     commitWithMessage(editedMessage);
     return;
   }
-  if (options.dryRun) {
-    for await (const candidate of createGenerator()) {
-      console.log("---");
-      console.log(candidate.content);
-    }
-    return;
-  }
   const stats = getGitStagedStats();
-  console.log(`\x1B[32m\u2714\x1B[0m Found ${formatDiffStats(stats)}`);
+  console.log(ui.success(`Found ${formatDiffStats(stats)}`));
   while (true) {
     const result = await selectCandidate({
-      candidates: createGenerator(),
-      maxSlots: options.models.length
+      createCandidates,
+      maxSlots: options.models.length,
+      abortSignal: commandExecutionSignal,
+      models: options.models
     });
     if (result.action === "abort") {
+      if (isCommandExecutionAbort(commandExecutionSignal)) {
+        return;
+      }
       console.error("Aborting commit.");
       process.exit(1);
     }
@@ -751,9 +1573,11 @@ async function commit(args2) {
       continue;
     }
     if (result.action === "confirm" && result.selected) {
-      console.log(`\x1B[32m\u2714\x1B[0m Message selected`);
+      await recordSelection(result.selectedCandidate?.generationId);
+      const costLabel = result.totalCost != null ? ` (total: ${formatTotalCost(result.totalCost)})` : "";
+      console.log(ui.success(`Message selected${costLabel}`));
       if (options.message) {
-        console.log(`\x1B[32m\u2714\x1B[0m Running git commit
+        console.log(`${ui.success("Running git commit")}
 `);
         commitWithMessage(result.selected);
       } else {
@@ -762,16 +1586,19 @@ async function commit(args2) {
           console.error("Aborting commit due to empty message.");
           process.exit(1);
         }
-        console.log(`\x1B[32m\u2714\x1B[0m Running git commit
+        console.log(`${ui.success("Running git commit")}
 `);
         commitWithMessage(editedMessage);
       }
+      if (result.quota) {
+        showQuotaInfo(result.quota);
+      }
       return;
     }
   }
 }
 
-// src/git-ultrahope.ts
+// git-ultrahope.ts
 var [command, ...args] = process.argv.slice(2);
 async function main() {
   switch (command) {
@@ -793,18 +1620,16 @@ function printHelp() {
   console.log(`Usage: git ultrahope <command>
 
 Commands:
-  commit      Generate commit message from staged changes
+   commit      Generate commit message from staged changes
 
 Commit options:
-  -m, --message     Commit directly with generated message
-  --dry-run         Print candidates only, don't commit
-  --no-interactive  Single candidate, open in editor
+   -m, --message     Commit directly with generated message
+   --no-interactive  Single candidate, open in editor
 
 Examples:
-  git ultrahope commit               # interactive selector (default)
-  git ultrahope commit -m            # select and commit directly
-  git ultrahope commit --dry-run     # preview candidates only
-  git ultrahope commit --no-interactive  # single candidate, open editor`);
+   git ultrahope commit               # interactive selector (default)
+   git ultrahope commit -m            # select and commit directly
+   git ultrahope commit --no-interactive  # single candidate, open editor`);
 }
 main().catch((err) => {
   console.error(err);