ultrahope 0.0.3 → 0.1.0

package/dist/git-ultrahope.js

@@ -0,0 +1,812 @@
+#!/usr/bin/env node
+
+// src/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
+import { execSync } from "child_process";
+function getGitStagedStats() {
+  try {
+    const output = execSync("git diff --cached --numstat", {
+      encoding: "utf-8"
+    });
+    let files = 0;
+    let insertions = 0;
+    let deletions = 0;
+    for (const line of output.trim().split("\n")) {
+      if (!line) continue;
+      const [added, deleted] = line.split("	");
+      files++;
+      if (added !== "-") insertions += Number.parseInt(added, 10) || 0;
+      if (deleted !== "-") deletions += Number.parseInt(deleted, 10) || 0;
+    }
+    return { files, insertions, deletions };
+  } catch {
+    return { files: 0, insertions: 0, deletions: 0 };
+  }
+}
+function formatDiffStats(stats) {
+  const parts = [];
+  parts.push(`${stats.files} file${stats.files !== 1 ? "s" : ""}`);
+  parts.push(
+    `${stats.insertions} insertion${stats.insertions !== 1 ? "s" : ""}`
+  );
+  parts.push(`${stats.deletions} deletion${stats.deletions !== 1 ? "s" : ""}`);
+  return parts.join(", ");
+}
+
+// src/lib/selector.ts
+import { spawn } from "child_process";
+import {
+  accessSync,
+  constants,
+  mkdtempSync,
+  openSync,
+  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;
+  }
+}
+function formatModelName(model) {
+  const parts = model.split("/");
+  return parts.length > 1 ? parts[1] : model;
+}
+function formatCost(cost) {
+  return `$${cost.toFixed(7).replace(/0+$/, "").replace(/\.$/, "")}`;
+}
+function formatSlot(slot, selected) {
+  const radio = selected ? "\u25CF" : "\u25CB";
+  if (slot.status === "pending") {
+    return [];
+  }
+  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` : "";
+    return meta2 ? [line2, meta2] : [line2];
+  }
+  const line = `\x1B[2m  ${radio}  ${title}\x1B[0m`;
+  const meta = modelInfo ? `\x1B[2m     ${modelInfo}\x1B[0m` : "";
+  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");
+  }
+  const lines = [];
+  const readyCount = slots.filter((s) => s.status === "ready").length;
+  if (isGenerating) {
+    const spinner = SPINNER_FRAMES[spinnerFrame % SPINNER_FRAMES.length];
+    const progress = `${readyCount}/${totalSlots}`;
+    lines.push(
+      `\x1B[33m${spinner}\x1B[0m Generating commit messages... ${progress}`
+    );
+  } else {
+    const label = readyCount === 1 ? "1 commit message generated" : `${readyCount} commit messages generated`;
+    lines.push(`\x1B[32m\u2714\x1B[0m ${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}`);
+  } else {
+    lines.push("\x1B[2m  q quit\x1B[0m");
+  }
+  lines.push("");
+  for (let i = 0; i < slots.length; i++) {
+    const slotLines = formatSlot(slots[i], i === selectedIndex);
+    for (const line of slotLines) {
+      lines.push(line);
+    }
+    if (slotLines.length > 0) {
+      lines.push("");
+    }
+  }
+  for (const line of lines) {
+    console.log(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");
+    writeFileSync(tmpFile, content);
+    const child = spawn(editor, [tmpFile], { stdio: "inherit" });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        unlinkSync(tmpFile);
+        reject(new Error(`Editor exited with code ${code}`));
+        return;
+      }
+      const result = readFileSync(tmpFile, "utf-8").trim();
+      unlinkSync(tmpFile);
+      resolve(result);
+    });
+    child.on("error", (err) => {
+      try {
+        unlinkSync(tmpFile);
+      } catch {
+      }
+      reject(err);
+    });
+  });
+}
+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 slots2 = candidates.map((c) => ({
+      status: "ready",
+      candidate: c
+    }));
+    return selectFromSlots(slots2, null);
+  }
+  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
+    };
+  }
+  const slots = Array.from({ length: maxSlots }, () => ({
+    status: "pending"
+  }));
+  const abortController = new AbortController();
+  return selectFromSlots(slots, { candidates, abortController });
+}
+async function selectFromSlots(initialSlots, asyncCtx) {
+  return new Promise((resolve) => {
+    let selectedIndex = 0;
+    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({
+      input: ttyInput,
+      output: process.stdout,
+      terminal: true
+    });
+    readline.emitKeypressEvents(ttyInput, rl);
+    ttyInput.setRawMode(true);
+    const doRender = () => {
+      render({ slots, selectedIndex, isGenerating, spinnerFrame, totalSlots });
+    };
+    doRender();
+    if (isGenerating) {
+      spinnerInterval = setInterval(() => {
+        spinnerFrame++;
+        doRender();
+      }, 80);
+    }
+    const cleanup = () => {
+      asyncCtx?.abortController.abort();
+      if (spinnerInterval) {
+        clearInterval(spinnerInterval);
+        spinnerInterval = null;
+      }
+      ttyInput.setRawMode(false);
+      rl.close();
+      ttyInput.destroy();
+      if (lastRenderLineCount > 0) {
+        process.stdout.write(`\x1B[${lastRenderLineCount}A`);
+        process.stdout.write("\x1B[0J");
+      }
+      lastRenderLineCount = 0;
+    };
+    if (asyncCtx) {
+      (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++;
+            }
+          }
+          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();
+        } catch (err) {
+          if (!asyncCtx.abortController.signal.aborted) {
+            console.error("Error fetching candidates:", err);
+          }
+        }
+      })();
+    }
+    const getSelectedCandidate = () => {
+      const slot = slots[selectedIndex];
+      return slot?.status === "ready" ? slot.candidate : void 0;
+    };
+    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" });
+        return;
+      }
+      if (key.name === "return") {
+        const candidate = getSelectedCandidate();
+        if (!candidate) return;
+        cleanup();
+        resolve({
+          action: "confirm",
+          selected: candidate.content,
+          selectedIndex
+        });
+        return;
+      }
+      if (key.name === "r") {
+        if (!hasReadySlot()) return;
+        cleanup();
+        resolve({ action: "reroll" });
+        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();
+        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;
+          }
+        }
+        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;
+          }
+        }
+        return;
+      }
+      const num = Number.parseInt(key.name || "", 10);
+      if (num >= 1 && num <= slots.length && slots[num - 1]?.status === "ready") {
+        selectedIndex = num - 1;
+        doRender();
+        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}`);
+      }
+      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"
+      };
+    }
+  };
+}
+
+// src/lib/vcs-message-generator.ts
+var DEFAULT_MODELS = [
+  "mistral/mistral-nemo",
+  "cerebras/llama-3.1-8b",
+  "openai/gpt-5-nano",
+  "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 };
+    }
+    return;
+  }
+  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 () => {
+      try {
+        const result = await api.translate({
+          input: diff,
+          model,
+          target: "vcs-commit-message"
+        });
+        return {
+          result: {
+            content: result.output,
+            model,
+            cost: result.cost
+          },
+          index
+        };
+      } catch (error) {
+        if (error instanceof InsufficientBalanceError) {
+          throw error;
+        }
+        return { result: null, index };
+      }
+    })(),
+    index
+  }));
+  const remaining = new Map(pending.map((p) => [p.index, p.promise]));
+  try {
+    while (remaining.size > 0) {
+      const { result, index } = await Promise.race(remaining.values());
+      remaining.delete(index);
+      if (result) yield result;
+    }
+  } catch (error) {
+    if (error instanceof InsufficientBalanceError) {
+      console.error(
+        "Error: Token balance exhausted. Upgrade your plan at https://ultrahope.dev/pricing"
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+// src/commands/commit.ts
+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) {
+    models = DEFAULT_MODELS;
+  }
+  return {
+    message: args2.includes("-m") || args2.includes("--message"),
+    dryRun: args2.includes("--dry-run"),
+    interactive: !args2.includes("--no-interactive"),
+    mock,
+    models
+  };
+}
+function getStagedDiff() {
+  try {
+    return execSync2("git diff --cached", { encoding: "utf-8" });
+  } catch {
+    console.error(
+      "Error: Failed to get staged changes. Are you in a git repository?"
+    );
+    process.exit(1);
+  }
+}
+function openEditor2(initialMessage) {
+  return new Promise((resolve, reject) => {
+    const editor = process.env.GIT_EDITOR || process.env.EDITOR || "vi";
+    const tmpDir = mkdtempSync2(join4(tmpdir2(), "ultrahope-"));
+    const tmpFile = join4(tmpDir, "COMMIT_EDITMSG");
+    writeFileSync2(tmpFile, initialMessage);
+    const child = spawn2(editor, [tmpFile], {
+      stdio: "inherit"
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        unlinkSync2(tmpFile);
+        reject(new Error(`Editor exited with code ${code}`));
+        return;
+      }
+      const message = readFileSync2(tmpFile, "utf-8").trim();
+      unlinkSync2(tmpFile);
+      resolve(message);
+    });
+    child.on("error", (err) => {
+      unlinkSync2(tmpFile);
+      reject(err);
+    });
+  });
+}
+function commitWithMessage(message) {
+  try {
+    execSync2(`git commit -m ${JSON.stringify(message)}`, { stdio: "inherit" });
+  } catch {
+    process.exit(1);
+  }
+}
+async function commit(args2) {
+  const options = parseArgs(args2);
+  const diff = getStagedDiff();
+  if (!diff.trim()) {
+    console.error(
+      "Error: No staged changes. Stage files with `git add` first."
+    );
+    process.exit(1);
+  }
+  const createGenerator = () => generateCommitMessages({
+    diff,
+    models: options.models,
+    mock: options.mock
+  });
+  if (!options.interactive) {
+    const gen = generateCommitMessages({
+      diff,
+      models: options.models.slice(0, 1),
+      mock: options.mock
+    });
+    const first = await gen.next();
+    const message = first.value?.content ?? "";
+    if (options.dryRun) {
+      console.log(message);
+      return;
+    }
+    if (options.message) {
+      commitWithMessage(message);
+      return;
+    }
+    const editedMessage = await openEditor2(message);
+    if (!editedMessage) {
+      console.error("Aborting commit due to empty message.");
+      process.exit(1);
+    }
+    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)}`);
+  while (true) {
+    const result = await selectCandidate({
+      candidates: createGenerator(),
+      maxSlots: options.models.length
+    });
+    if (result.action === "abort") {
+      console.error("Aborting commit.");
+      process.exit(1);
+    }
+    if (result.action === "reroll") {
+      continue;
+    }
+    if (result.action === "confirm" && result.selected) {
+      console.log(`\x1B[32m\u2714\x1B[0m Message selected`);
+      if (options.message) {
+        console.log(`\x1B[32m\u2714\x1B[0m Running git commit
+`);
+        commitWithMessage(result.selected);
+      } else {
+        const editedMessage = await openEditor2(result.selected);
+        if (!editedMessage) {
+          console.error("Aborting commit due to empty message.");
+          process.exit(1);
+        }
+        console.log(`\x1B[32m\u2714\x1B[0m Running git commit
+`);
+        commitWithMessage(editedMessage);
+      }
+      return;
+    }
+  }
+}
+
+// src/git-ultrahope.ts
+var [command, ...args] = process.argv.slice(2);
+async function main() {
+  switch (command) {
+    case "commit":
+      await commit(args);
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.error("Run `git ultrahope --help` for usage.");
+      process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`Usage: git ultrahope <command>
+
+Commands:
+  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
+
+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`);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});