@rotorsoft/gent 1.11.0 → 1.12.0

package/dist/index.js

@@ -13,6 +13,7 @@ import {
   configExists,
   createIssue,
   createPullRequest,
+  createSpinner,
   extractPriorityFromLabels,
   extractTypeFromLabels,
   generateDefaultConfig,
@@ -32,9 +33,10 @@ import {
   sanitizeSlug,
   setupLabelsCommand,
   sortByPriority,
+  updateConfigProvider,
   updateIssueLabels,
   withSpinner
-} from "./chunk-3N6U3NTN.js";
+} from "./chunk-TLGYE7J2.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -195,7 +197,7 @@ async function initCommand(options) {
     }
   ]);
   if (setupLabels) {
-    const { setupLabelsCommand: setupLabelsCommand2 } = await import("./setup-labels-HKXXO65J.js");
+    const { setupLabelsCommand: setupLabelsCommand2 } = await import("./setup-labels-FLCGVPFY.js");
     await setupLabelsCommand2();
   }
 }
@@ -540,6 +542,22 @@ ${issue ? `Closes #${issue.number}` : ""}
 
 Only output the PR description, nothing else.`;
 }
+function buildCommitMessagePrompt(diff, issueNumber, issueTitle) {
+  const issueContext = issueNumber ? `
+Related Issue: #${issueNumber}${issueTitle ? ` - ${issueTitle}` : ""}
+` : "";
+  return `Generate a concise git commit message for the following changes.
+${issueContext}
+## Diff
+${diff}
+
+Rules:
+- Use conventional commit format: <type>: <short description>
+- Types: feat, fix, refactor, chore, docs, test, style, perf
+- Keep the first line under 72 characters
+- Do NOT include a body or footer
+- Output ONLY the commit message, nothing else`;
+}
 function parseTicketMeta(output) {
   const metaMatch = output.match(
     /META:type=(\w+),priority=(\w+),risk=(\w+),area=(\w+)/
@@ -592,6 +610,46 @@ function generateFallbackTitle(description) {
   }
   return truncated;
 }
+function buildVideoPrompt(issueNumber, issueTitle, videoConfig, agentInstructions) {
+  return `You are helping capture a Playwright video demonstration of UI changes for GitHub Issue #${issueNumber}: ${issueTitle}
+
+${agentInstructions ? `## Project-Specific Instructions
+${agentInstructions}
+
+` : ""}
+
+## Task: Record UI Demo Video
+
+Create a short video (max ${videoConfig.max_duration}s) demonstrating the UI changes made for this issue.
+
+### Video Requirements
+- Resolution: ${videoConfig.width}x${videoConfig.height}
+- Format: WebM or MP4
+- Duration: Under ${videoConfig.max_duration} seconds
+- Show the key UI interactions and visual changes
+
+### Steps
+
+1. **Start the development server** if not already running
+2. **Use Playwright to record video** of the relevant UI interactions:
+   - Navigate to the affected pages/components
+   - Demonstrate the new or changed functionality
+   - Show before/after if applicable
+
+3. **Upload video to GitHub** as a release asset or use GitHub's drag-drop upload:
+   - Create a GitHub release or upload to issue comments
+   - Get the permanent URL for the video
+   - Do NOT commit video files to the repository
+
+4. **Add video to PR** by commenting with the video URL or embedding it
+
+### Important
+- Upload video to GitHub assets, NOT to the repository
+- Keep the video concise - focus on demonstrating the changes
+- Ensure the video clearly shows the UI improvements
+
+Output the GitHub URL where the video was uploaded when complete.`;
+}
 
 // src/commands/create.ts
 async function createCommand(description, options) {
@@ -1836,7 +1894,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "@rotorsoft/gent",
-  version: "1.11.0",
+  version: "1.12.0",
   description: "AI-powered GitHub workflow CLI - leverage AI (Claude, Gemini, or Codex) to create tickets, implement features, and manage PRs",
   keywords: [
     "cli",
@@ -2245,6 +2303,722 @@ async function statusCommand() {
   }
 }
 
+// src/commands/tui.ts
+import inquirer6 from "inquirer";
+import { execa as execa4 } from "execa";
+
+// src/tui/state.ts
+async function aggregateState() {
+  const isGitRepo = await checkGitRepo();
+  if (!isGitRepo) {
+    const config2 = loadConfig();
+    return {
+      isGitRepo: false,
+      isGhAuthenticated: false,
+      isAIProviderAvailable: false,
+      config: config2,
+      hasConfig: false,
+      hasProgress: false,
+      branch: "",
+      branchInfo: null,
+      isOnMain: false,
+      hasUncommittedChanges: false,
+      hasUnpushedCommits: false,
+      commits: [],
+      baseBranch: "main",
+      issue: null,
+      workflowStatus: "none",
+      pr: null,
+      reviewFeedback: [],
+      hasActionableFeedback: false,
+      hasUIChanges: false,
+      isPlaywrightAvailable: false
+    };
+  }
+  const config = loadConfig();
+  const workflowLabels = getWorkflowLabels(config);
+  const [
+    isGhAuthenticated,
+    isAIProviderAvailable,
+    branch,
+    isOnMain,
+    uncommitted,
+    baseBranch
+  ] = await Promise.all([
+    checkGhAuth(),
+    checkAIProvider(config.ai.provider),
+    getCurrentBranch(),
+    isOnMainBranch(),
+    hasUncommittedChanges(),
+    getDefaultBranch()
+  ]);
+  const hasConfig = configExists();
+  const hasProgress = progressExists(config);
+  const branchInfo = parseBranchName(branch);
+  const [commits, unpushed] = await Promise.all([
+    getCommitsSinceBase(baseBranch),
+    getUnpushedCommits()
+  ]);
+  let issue = null;
+  let workflowStatus = "none";
+  let pr = null;
+  let reviewFeedback = [];
+  let hasActionableFeedback = false;
+  let uiChanges = false;
+  let playwrightAvailable = false;
+  if (!isOnMain) {
+    const issueNumber = extractIssueNumber(branch);
+    const [issueResult, prResult, changedFiles, playwrightResult] = await Promise.all([
+      issueNumber ? getIssue(issueNumber).catch(() => null) : Promise.resolve(null),
+      getPrStatus().catch(() => null),
+      getChangedFiles(baseBranch),
+      isPlaywrightAvailable()
+    ]);
+    issue = issueResult;
+    pr = prResult;
+    uiChanges = hasUIChanges(changedFiles);
+    playwrightAvailable = playwrightResult;
+    if (issue) {
+      if (issue.labels.includes(workflowLabels.ready)) {
+        workflowStatus = "ready";
+      } else if (issue.labels.includes(workflowLabels.inProgress)) {
+        workflowStatus = "in-progress";
+      } else if (issue.labels.includes(workflowLabels.completed)) {
+        workflowStatus = "completed";
+      } else if (issue.labels.includes(workflowLabels.blocked)) {
+        workflowStatus = "blocked";
+      }
+    }
+    if (pr && pr.state === "open") {
+      try {
+        const lastCommitTimestamp = await getLastCommitTimestamp();
+        const reviewData = await getPrReviewData(pr.number);
+        const { items } = summarizeReviewFeedback(reviewData, { afterTimestamp: lastCommitTimestamp });
+        reviewFeedback = items;
+        hasActionableFeedback = items.length > 0;
+      } catch {
+      }
+    }
+  }
+  return {
+    isGitRepo,
+    isGhAuthenticated,
+    isAIProviderAvailable,
+    config,
+    hasConfig,
+    hasProgress,
+    branch,
+    branchInfo,
+    isOnMain,
+    hasUncommittedChanges: uncommitted,
+    hasUnpushedCommits: unpushed,
+    commits,
+    baseBranch,
+    issue,
+    workflowStatus,
+    pr,
+    reviewFeedback,
+    hasActionableFeedback,
+    hasUIChanges: uiChanges,
+    isPlaywrightAvailable: playwrightAvailable
+  };
+}
+
+// src/tui/actions.ts
+function getAvailableActions(state) {
+  const actions = [];
+  if (!state.isGitRepo || !state.isGhAuthenticated) {
+    actions.push({ id: "quit", label: "quit", shortcut: "q" });
+    return actions;
+  }
+  if (state.isOnMain) {
+    actions.push({ id: "create", label: "new", shortcut: "n" });
+    actions.push({ id: "run-auto", label: "run next", shortcut: "r" });
+    actions.push({ id: "list", label: "list", shortcut: "l" });
+    actions.push({ id: "switch-provider", label: "switch", shortcut: "s" });
+    actions.push({ id: "quit", label: "quit", shortcut: "q" });
+    return actions;
+  }
+  if (state.hasUncommittedChanges) {
+    actions.push({ id: "commit", label: "commit", shortcut: "c" });
+  }
+  if (state.hasUnpushedCommits) {
+    actions.push({ id: "push", label: "Push", shortcut: "P" });
+  }
+  if (!state.pr && state.commits.length > 0) {
+    actions.push({ id: "pr", label: "Create pr", shortcut: "C" });
+  }
+  if (state.pr && state.pr.state === "open") {
+    if (state.hasActionableFeedback) {
+      actions.push({ id: "fix", label: "fix feedback", shortcut: "f" });
+    }
+    if (state.hasUIChanges && state.isPlaywrightAvailable && state.config.video.enabled) {
+      actions.push({ id: "video", label: "video", shortcut: "v" });
+    }
+  }
+  if (state.pr && (state.pr.state === "merged" || state.pr.state === "closed")) {
+    actions.push({ id: "checkout-main", label: "main", shortcut: "m" });
+  }
+  actions.push({ id: "switch-provider", label: "switch", shortcut: "s" });
+  actions.push({ id: "quit", label: "quit", shortcut: "q" });
+  return actions;
+}
+
+// src/tui/display.ts
+import chalk3 from "chalk";
+var stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, "");
+var visibleLen = (str) => stripAnsi(str).length;
+function termWidth() {
+  return Math.min(process.stdout.columns || 80, 90);
+}
+function termHeight() {
+  return process.stdout.rows || 24;
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+function extractDescription(body, maxLen) {
+  const lines = body.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("---")) continue;
+    if (trimmed.startsWith("META:")) continue;
+    if (trimmed.startsWith("**Type:**")) continue;
+    const clean = trimmed.replace(/\*\*/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    return truncate(clean, maxLen);
+  }
+  return "";
+}
+function topRow(title, w) {
+  const label = ` ${title} `;
+  const fill = w - 2 - label.length;
+  return chalk3.dim("\u250C") + chalk3.bold.cyan(label) + chalk3.dim("\u2500".repeat(Math.max(0, fill)) + "\u2510");
+}
+function midRow(title, w) {
+  const label = ` ${title} `;
+  const fill = w - 2 - label.length;
+  return chalk3.dim("\u251C") + chalk3.bold.cyan(label) + chalk3.dim("\u2500".repeat(Math.max(0, fill)) + "\u2524");
+}
+function divRow(w) {
+  return chalk3.dim("\u251C" + "\u2500".repeat(w - 2) + "\u2524");
+}
+function botRow(w) {
+  return chalk3.dim("\u2514" + "\u2500".repeat(w - 2) + "\u2518");
+}
+function row(text, w) {
+  const inner = w - 4;
+  const pad = Math.max(0, inner - visibleLen(text));
+  return chalk3.dim("\u2502") + " " + text + " ".repeat(pad) + " " + chalk3.dim("\u2502");
+}
+function workflowBadge(status) {
+  switch (status) {
+    case "ready":
+      return chalk3.bgGreen.black(" READY ");
+    case "in-progress":
+      return chalk3.bgYellow.black(" IN PROGRESS ");
+    case "completed":
+      return chalk3.bgBlue.white(" COMPLETED ");
+    case "blocked":
+      return chalk3.bgRed.white(" BLOCKED ");
+    default:
+      return "";
+  }
+}
+function prBadge(state, draft) {
+  if (state === "merged") return chalk3.bgMagenta.white(" MERGED ");
+  if (state === "closed") return chalk3.bgRed.white(" CLOSED ");
+  return draft ? chalk3.bgYellow.black(" DRAFT ") : chalk3.bgGreen.black(" OPEN ");
+}
+function reviewBadge(decision) {
+  if (!decision) return "";
+  switch (decision) {
+    case "APPROVED":
+      return "  " + chalk3.green("Approved");
+    case "CHANGES_REQUESTED":
+      return "  " + chalk3.red("Changes requested");
+    case "REVIEW_REQUIRED":
+      return "  " + chalk3.yellow("Review pending");
+    default:
+      return "";
+  }
+}
+var shortcutColors = [
+  chalk3.cyan.bold,
+  chalk3.green.bold,
+  chalk3.yellow.bold,
+  chalk3.magenta.bold,
+  chalk3.blue.bold,
+  chalk3.red.bold
+];
+function formatAction(a, color) {
+  const key = a.shortcut;
+  const idx = a.label.indexOf(key);
+  if (idx >= 0) {
+    const before = a.label.slice(0, idx);
+    const after = a.label.slice(idx + key.length);
+    return chalk3.dim(before) + color(key) + chalk3.dim(after);
+  }
+  return color(key) + " " + chalk3.dim(a.label);
+}
+function formatCommandBar(actions, w) {
+  const parts = actions.map((a, i) => {
+    const color = shortcutColors[i % shortcutColors.length];
+    return formatAction(a, color);
+  });
+  const inner = w - 4;
+  const lines = [];
+  let cur = "";
+  for (const part of parts) {
+    const next = cur + (cur.length > 0 ? "   " : "") + part;
+    if (visibleLen(next) > inner) {
+      lines.push(cur);
+      cur = part;
+    } else {
+      cur = next;
+    }
+  }
+  if (cur.length > 0) lines.push(cur);
+  return lines;
+}
+function renderModal(message) {
+  const w = termWidth();
+  const h = termHeight();
+  const modalW = Math.min(w - 4, Math.max(30, visibleLen(message) + 8));
+  const padX = Math.max(0, Math.floor((w - modalW) / 2));
+  const padY = Math.max(0, Math.floor((h - 5) / 2));
+  const indent = " ".repeat(padX);
+  const inner = modalW - 4;
+  const textPad = Math.max(0, inner - visibleLen(message));
+  const lines = [
+    indent + chalk3.dim("\u250C" + "\u2500".repeat(modalW - 2) + "\u2510"),
+    indent + chalk3.dim("\u2502") + " ".repeat(modalW - 2) + chalk3.dim("\u2502"),
+    indent + chalk3.dim("\u2502") + " " + chalk3.bold(message) + " ".repeat(textPad) + " " + chalk3.dim("\u2502"),
+    indent + chalk3.dim("\u2502") + " ".repeat(modalW - 2) + chalk3.dim("\u2502"),
+    indent + chalk3.dim("\u2514" + "\u2500".repeat(modalW - 2) + "\u2518")
+  ];
+  for (let i = 0; i < padY; i++) console.log();
+  for (const line of lines) console.log(line);
+}
+function renderSettings(state, w) {
+  const provider = getProviderDisplayName(state.config.ai.provider);
+  const provTag = state.isAIProviderAvailable ? chalk3.green(provider) : chalk3.red(provider);
+  const ghTag = state.isGhAuthenticated ? chalk3.green("authenticated") : chalk3.red("not authenticated");
+  const videoTag = state.config.video.enabled ? chalk3.green("on") : chalk3.dim("off");
+  console.log(row(chalk3.dim("Provider: ") + provTag, w));
+  console.log(row(chalk3.dim("GitHub:   ") + ghTag, w));
+  console.log(row(chalk3.dim("Video:    ") + videoTag, w));
+}
+function renderDashboard(state, actions, hint) {
+  const w = termWidth();
+  const descMax = w - 8;
+  const version2 = getVersion();
+  const titleLabel = `gent v${version2}`;
+  console.log(topRow(titleLabel, w));
+  if (!state.isGitRepo) {
+    console.log(row(chalk3.red("Not a git repository"), w));
+    console.log(row(chalk3.dim("Run gent init in a git repo to get started"), w));
+    console.log(botRow(w));
+    return;
+  }
+  if (!state.isGhAuthenticated) {
+    console.log(row(chalk3.red("GitHub CLI not authenticated"), w));
+    console.log(row(chalk3.dim("Run: gh auth login"), w));
+    console.log(botRow(w));
+    return;
+  }
+  if (state.isOnMain) {
+    console.log(row(chalk3.magenta(state.branch) + chalk3.dim("  \xB7  ready to start new work"), w));
+    if (state.hasUncommittedChanges) {
+      console.log(row(chalk3.yellow("\u25CF uncommitted changes"), w));
+    }
+    console.log(midRow("Settings", w));
+    renderSettings(state, w);
+    if (hint) {
+      console.log(midRow("Hint", w));
+      console.log(row(chalk3.yellow(hint), w));
+    }
+    console.log(divRow(w));
+    for (const line of formatCommandBar(actions, w)) {
+      console.log(row(line, w));
+    }
+    console.log(botRow(w));
+    console.log();
+    return;
+  }
+  const section = (title) => {
+    console.log(midRow(title, w));
+  };
+  section("Ticket");
+  if (state.issue) {
+    console.log(row(
+      chalk3.cyan(`#${state.issue.number}`) + "  " + chalk3.bold(truncate(state.issue.title, descMax - 6)),
+      w
+    ));
+    const desc = extractDescription(state.issue.body, descMax);
+    if (desc) console.log(row(chalk3.dim(desc), w));
+    const tags = [];
+    if (state.workflowStatus !== "none") tags.push(workflowBadge(state.workflowStatus));
+    for (const prefix of ["type:", "priority:", "risk:", "area:"]) {
+      const l = state.issue.labels.find((x) => x.startsWith(prefix));
+      if (l) tags.push(chalk3.dim(l));
+    }
+    if (tags.length) console.log(row(tags.join("  "), w));
+  } else {
+    console.log(row(chalk3.dim("No linked issue"), w));
+  }
+  section("Branch");
+  console.log(row(chalk3.magenta(state.branch), w));
+  const bits = [];
+  if (state.commits.length > 0) bits.push(chalk3.dim(`${state.commits.length} ahead`));
+  if (state.hasUncommittedChanges) bits.push(chalk3.yellow("\u25CF uncommitted"));
+  if (state.hasUnpushedCommits) bits.push(chalk3.yellow("\u25CF unpushed"));
+  if (!state.hasUncommittedChanges && !state.hasUnpushedCommits && state.commits.length > 0) {
+    bits.push(chalk3.green("\u25CF synced"));
+  }
+  if (bits.length) console.log(row(bits.join(chalk3.dim("  \xB7  ")), w));
+  section("Pull Request");
+  if (state.pr) {
+    const titleText = state.pr.title ? "  " + truncate(state.pr.title, descMax - 12) : "";
+    console.log(row(
+      chalk3.cyan(`#${state.pr.number}`) + titleText,
+      w
+    ));
+    console.log(row(
+      prBadge(state.pr.state, state.pr.isDraft) + reviewBadge(state.pr.reviewDecision),
+      w
+    ));
+    if (state.hasActionableFeedback) {
+      const n = state.reviewFeedback.length;
+      console.log(row(chalk3.yellow(`${n} actionable comment${n !== 1 ? "s" : ""} pending`), w));
+    }
+    if (state.hasUIChanges && state.isPlaywrightAvailable && state.config.video.enabled && state.pr.state === "open") {
+      console.log(row(chalk3.cyan("UI changes detected") + chalk3.dim(" \xB7 video capture available"), w));
+    }
+    console.log(row(chalk3.dim(state.pr.url), w));
+  } else {
+    console.log(row(chalk3.dim("No PR created"), w));
+  }
+  section("Commits");
+  if (state.commits.length > 0) {
+    const max = 6;
+    for (const c of state.commits.slice(0, max)) {
+      console.log(row(c, w));
+    }
+    if (state.commits.length > max) {
+      console.log(row(chalk3.dim(`\u2026 and ${state.commits.length - max} more`), w));
+    }
+  } else {
+    console.log(row(chalk3.dim("No commits"), w));
+  }
+  section("Settings");
+  renderSettings(state, w);
+  if (hint) {
+    section("Hint");
+    console.log(row(chalk3.yellow(hint), w));
+  }
+  console.log(divRow(w));
+  for (const line of formatCommandBar(actions, w)) {
+    console.log(row(line, w));
+  }
+  console.log(botRow(w));
+}
+function clearScreen() {
+  process.stdout.write("\x1B[2J\x1B[0f");
+}
+
+// src/commands/tui.ts
+var CANCEL = /* @__PURE__ */ Symbol("cancel");
+async function confirm(message) {
+  const { ok } = await inquirer6.prompt([
+    {
+      type: "confirm",
+      name: "ok",
+      message,
+      default: true
+    }
+  ]);
+  return ok;
+}
+async function loadState() {
+  clearScreen();
+  renderModal("Loading workflow state...");
+  const state = await aggregateState();
+  return state;
+}
+async function waitForKey(validKeys) {
+  return new Promise((resolve) => {
+    const { stdin } = process;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (key) => {
+      if (key === "") {
+        stdin.setRawMode(wasRaw ?? false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        resolve("q");
+        return;
+      }
+      if (validKeys.includes(key)) {
+        stdin.setRawMode(wasRaw ?? false);
+        stdin.pause();
+        stdin.removeListener("data", onData);
+        resolve(key);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function executeAction(actionId, state) {
+  switch (actionId) {
+    case "quit":
+      return false;
+    case "list":
+      clearScreen();
+      await listCommand({ status: "ready", limit: 20 });
+      await promptContinue();
+      return true;
+    case "run-auto": {
+      clearScreen();
+      if (!await confirm("Start AI agent to implement next ticket?")) return true;
+      await runCommand(void 0, { auto: true });
+      return false;
+    }
+    case "create": {
+      clearScreen();
+      const { description } = await inquirer6.prompt([
+        {
+          type: "input",
+          name: "description",
+          message: "Describe the ticket (empty to cancel):"
+        }
+      ]);
+      if (!description.trim()) {
+        logger.info("Cancelled");
+        return true;
+      }
+      await createCommand(description, {});
+      await promptContinue();
+      return true;
+    }
+    case "commit":
+      clearScreen();
+      await handleCommit(state);
+      await promptContinue();
+      return true;
+    case "push":
+      clearScreen();
+      await handlePush();
+      await promptContinue();
+      return true;
+    case "pr": {
+      clearScreen();
+      if (!await confirm("Create a pull request?")) return true;
+      await prCommand({});
+      await promptContinue();
+      return true;
+    }
+    case "fix": {
+      clearScreen();
+      if (!await confirm("Start AI agent to fix review feedback?")) return true;
+      await fixCommand({});
+      return false;
+    }
+    case "video": {
+      clearScreen();
+      if (!await confirm("Record video of UI changes?")) return true;
+      await handleVideoCapture(state);
+      await promptContinue();
+      return true;
+    }
+    case "switch-provider":
+      clearScreen();
+      await handleSwitchProvider(state);
+      return true;
+    case "checkout-main": {
+      clearScreen();
+      if (!await confirm("Switch to main branch?")) return true;
+      await handleCheckoutMain();
+      return true;
+    }
+    default:
+      return true;
+  }
+}
+async function handleCommit(state) {
+  try {
+    const { stdout: status } = await execa4("git", ["status", "--short"]);
+    if (!status.trim()) {
+      logger.info("No changes to commit");
+      return;
+    }
+    logger.info("Changes:");
+    console.log(status);
+    console.log();
+    await execa4("git", ["add", "-A"]);
+    const { stdout: diffStat } = await execa4("git", ["diff", "--cached", "--stat"]);
+    const { stdout: diffPatch } = await execa4("git", ["diff", "--cached"]);
+    const diffContent = (diffStat + "\n\n" + diffPatch).slice(0, 4e3);
+    const issueNumber = state.issue?.number ?? null;
+    const issueTitle = state.issue?.title ?? null;
+    const provider = state.config.ai.provider;
+    const providerName = getProviderDisplayName(provider);
+    logger.info(`Generating commit message with ${providerName}...`);
+    const message = await generateCommitMessage(diffContent, issueNumber, issueTitle, state);
+    if (message === CANCEL) {
+      await execa4("git", ["reset", "HEAD"]);
+      logger.info("Cancelled");
+      return;
+    }
+    console.log();
+    logger.info(`Message: ${message}`);
+    console.log();
+    if (!await confirm("Commit with this message?")) {
+      await execa4("git", ["reset", "HEAD"]);
+      logger.info("Commit cancelled");
+      return;
+    }
+    const providerEmail = getProviderEmail(provider);
+    const fullMessage = `${message}
+
+Co-Authored-By: ${providerName} <${providerEmail}>`;
+    const spinner = createSpinner("Committing...");
+    spinner.start();
+    await execa4("git", ["commit", "-m", fullMessage]);
+    spinner.succeed("Changes committed");
+  } catch (error) {
+    logger.error(`Commit failed: ${error}`);
+  }
+}
+async function generateCommitMessage(diffContent, issueNumber, issueTitle, state) {
+  try {
+    const prompt = buildCommitMessagePrompt(diffContent, issueNumber, issueTitle);
+    const result = await invokeAI({ prompt, streamOutput: true }, state.config);
+    let message = result.output.trim().split("\n")[0].trim();
+    for (const q of ['"', "'", "`"]) {
+      if (message.startsWith(q) && message.endsWith(q)) {
+        message = message.slice(1, -1);
+        break;
+      }
+    }
+    message = message.replace(/^```\w*\s*/, "").replace(/\s*```$/, "");
+    return message;
+  } catch {
+    logger.warning("AI commit message generation failed");
+    console.log();
+    const { message } = await inquirer6.prompt([
+      {
+        type: "input",
+        name: "message",
+        message: "Commit message (empty to cancel):"
+      }
+    ]);
+    return message.trim() || CANCEL;
+  }
+}
+async function handlePush() {
+  try {
+    const { stdout: branch } = await execa4("git", ["branch", "--show-current"]);
+    if (!await confirm(`Push ${branch.trim()} to remote?`)) return;
+    const spinner = createSpinner("Pushing...");
+    spinner.start();
+    await execa4("git", ["push", "-u", "origin", branch.trim()]);
+    spinner.succeed("Pushed to remote");
+  } catch (error) {
+    logger.error(`Push failed: ${error}`);
+  }
+}
+var PROVIDERS = ["claude", "gemini", "codex"];
+async function handleSwitchProvider(state) {
+  const current = state.config.ai.provider;
+  const { provider } = await inquirer6.prompt([
+    {
+      type: "list",
+      name: "provider",
+      message: "Select AI provider:",
+      choices: PROVIDERS.map((p) => ({
+        name: p.charAt(0).toUpperCase() + p.slice(1) + (p === current ? " (current)" : ""),
+        value: p
+      })),
+      default: current
+    }
+  ]);
+  if (provider === current) return;
+  try {
+    updateConfigProvider(provider);
+    logger.success(`Provider switched to ${provider}`);
+  } catch (error) {
+    logger.error(`Failed to switch provider: ${error}`);
+  }
+}
+async function handleCheckoutMain() {
+  try {
+    const spinner = createSpinner("Switching to main...");
+    spinner.start();
+    await execa4("git", ["checkout", "main"]);
+    await execa4("git", ["pull"]);
+    spinner.succeed("Switched to main");
+  } catch (error) {
+    logger.error(`Checkout failed: ${error}`);
+  }
+}
+async function handleVideoCapture(state) {
+  if (!state.issue) {
+    logger.error("No linked issue found");
+    return;
+  }
+  try {
+    const agentInstructions = loadAgentInstructions();
+    const videoPrompt = buildVideoPrompt(
+      state.issue.number,
+      state.issue.title,
+      state.config.video,
+      agentInstructions
+    );
+    await invokeAIInteractive(videoPrompt, state.config);
+    logger.success("Video capture completed");
+  } catch (error) {
+    logger.error(`Video capture failed: ${error}`);
+  }
+}
+async function promptContinue() {
+  console.log();
+  await inquirer6.prompt([
+    {
+      type: "input",
+      name: "continue",
+      message: "Press Enter to continue..."
+    }
+  ]);
+}
+async function tuiCommand() {
+  let running = true;
+  while (running) {
+    const state = await loadState();
+    clearScreen();
+    const actions = getAvailableActions(state);
+    let hint;
+    if (state.isOnMain) {
+      hint = "Select an action to get started";
+    } else if (state.hasUncommittedChanges && !state.pr) {
+      hint = "Commit your changes before creating a PR";
+    } else if (state.hasActionableFeedback) {
+      hint = "Review feedback needs attention";
+    }
+    renderDashboard(state, actions, hint);
+    const validKeys = actions.map((a) => a.shortcut);
+    const key = await waitForKey(validKeys);
+    const action = actions.find((a) => a.shortcut === key);
+    if (action) {
+      running = await executeAction(action.id, state);
+    }
+  }
+}
+
 // src/index.ts
 var version = getVersion();
 function startVersionCheck() {
@@ -2295,5 +3069,11 @@ program.command("fix").description("Apply PR review feedback using AI").option("
 program.command("status").description("Show current workflow status").action(async () => {
   await statusCommand();
 });
+program.command("ui").description("Launch interactive dashboard").action(async () => {
+  await tuiCommand();
+});
+program.action(async () => {
+  await tuiCommand();
+});
 program.parse();
 //# sourceMappingURL=index.js.map