@rotorsoft/gent 1.14.0 → 1.14.2

package/dist/index.js

@@ -13,7 +13,6 @@ import {
   configExists,
   createIssue,
   createPullRequest,
-  createSpinner,
   extractTypeFromLabels,
   generateDefaultConfig,
   getConfigPath,
@@ -37,7 +36,7 @@ import {
   sortByPriority,
   updateIssueLabels,
   withSpinner
-} from "./chunk-SKWCS6Z2.js";
+} from "./chunk-JHIW57FY.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -201,7 +200,7 @@ async function initCommand(options) {
     }
   ]);
   if (setupLabels) {
-    const { setupLabelsCommand: setupLabelsCommand2 } = await import("./setup-labels-C6YHJ637.js");
+    const { setupLabelsCommand: setupLabelsCommand2 } = await import("./setup-labels-LB7X6A3K.js");
     await setupLabelsCommand2();
   }
 }
@@ -1556,9 +1555,6 @@ No commits were created. Please retry later.`
   );
 }
 
-// src/commands/pr.ts
-import inquirer5 from "inquirer";
-
 // src/lib/playwright.ts
 import { execa as execa3 } from "execa";
 var UI_FILE_PATTERNS = [
@@ -1616,17 +1612,17 @@ async function prCommand(options) {
   ]);
   if (!ghAuth) {
     logger.error("Not authenticated with GitHub. Run 'gh auth login' first.");
-    process.exit(1);
+    return;
   }
   if (!aiOk) {
     logger.error(
       `${providerName} CLI not found. Please install ${provider} CLI first.`
     );
-    process.exit(1);
+    return;
   }
   if (await isOnMainBranch()) {
     logger.error("Cannot create PR from main/master branch.");
-    process.exit(1);
+    return;
   }
   const existingPr = await getPrForBranch();
   if (existingPr) {
@@ -1641,21 +1637,10 @@ async function prCommand(options) {
   logger.info(`Base: ${colors.branch(baseBranch)}`);
   const hasUnpushed = await getUnpushedCommits();
   if (hasUnpushed) {
-    logger.warning("Branch has unpushed commits.");
-    const { push } = await inquirer5.prompt([
-      {
-        type: "confirm",
-        name: "push",
-        message: "Push to remote before creating PR?",
-        default: true
-      }
-    ]);
-    if (push) {
-      await withSpinner("Pushing branch...", async () => {
-        await pushBranch();
-      });
-      logger.success("Branch pushed");
-    }
+    await withSpinner("Pushing branch...", async () => {
+      await pushBranch();
+    });
+    logger.success("Branch pushed");
   }
   const issueNumber = extractIssueNumber(currentBranch);
   let issue = null;
@@ -1808,7 +1793,7 @@ function generateFallbackBody(issue, commits) {
 }
 
 // src/commands/fix.ts
-import inquirer6 from "inquirer";
+import inquirer5 from "inquirer";
 
 // src/lib/review-feedback.ts
 var ACTIONABLE_KEYWORDS = [
@@ -2005,7 +1990,7 @@ async function fixCommand(options) {
   const hasChanges = await hasUncommittedChanges();
   if (hasChanges) {
     logger.warning("You have uncommitted changes.");
-    const { proceed } = await inquirer6.prompt([
+    const { proceed } = await inquirer5.prompt([
       {
         type: "confirm",
         name: "proceed",
@@ -2165,7 +2150,7 @@ import { homedir } from "os";
 // package.json
 var package_default = {
   name: "@rotorsoft/gent",
-  version: "1.14.0",
+  version: "1.14.2",
   description: "AI-powered GitHub workflow CLI - leverage AI (Claude, Gemini, or Codex) to create tickets, implement features, and manage PRs",
   keywords: [
     "cli",
@@ -2587,7 +2572,6 @@ async function statusCommand() {
 }
 
 // src/commands/tui.ts
-import inquirer7 from "inquirer";
 import { execa as execa4 } from "execa";
 
 // src/tui/state.ts
@@ -2868,75 +2852,73 @@ function renderActionPanel(title, content) {
   }
   console.log(botRow(w));
 }
-function renderSettings(state, w) {
+function renderSettingsTo(state, w, out) {
   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));
+  out(row(chalk3.dim("Provider: ") + provTag, w));
+  out(row(chalk3.dim("GitHub:   ") + ghTag, w));
 }
-function renderDashboard(state, actions, hint, refreshing) {
+function buildDashboardLines(state, actions, hint, refreshing) {
+  const lines = [];
+  const out = (line) => lines.push(line);
   const w = termWidth();
   const descMax = w - 8;
   const version2 = getVersion();
   const titleLabel = `gent v${version2}`;
-  console.log(topRow(titleLabel, w));
-  renderSettings(state, w);
+  out(topRow(titleLabel, w));
+  renderSettingsTo(state, w, out);
   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;
+    out(row(chalk3.red("Not a git repository"), w));
+    out(row(chalk3.dim("Run gent init in a git repo to get started"), w));
+    out(botRow(w));
+    return lines;
   }
   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;
+    out(row(chalk3.red("GitHub CLI not authenticated"), w));
+    out(row(chalk3.dim("Run: gh auth login"), w));
+    out(botRow(w));
+    return lines;
   }
   if (state.isOnMain) {
-    console.log(
+    out(
       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));
+      out(row(chalk3.yellow("\u25CF uncommitted changes"), w));
     }
     if (hint) {
-      console.log(midRow("Hint", w));
-      console.log(row(chalk3.yellow(hint), w));
+      out(midRow("Hint", w));
+      out(row(chalk3.yellow(hint), w));
     }
-    console.log(divRow(w));
+    out(divRow(w));
     if (refreshing) {
-      console.log(row(chalk3.yellow("Refreshing\u2026"), w));
+      out(row(chalk3.yellow("Refreshing\u2026"), w));
     } else {
       for (const line of formatCommandBar(actions, w)) {
-        console.log(row(line, w));
+        out(row(line, w));
       }
     }
-    console.log(botRow(w));
-    console.log();
-    return;
+    out(botRow(w));
+    out("");
+    return lines;
   }
   const section = (title) => {
-    console.log(midRow(title, w));
+    out(midRow(title, w));
   };
   section("Ticket");
   if (state.issue) {
-    console.log(
+    out(
       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));
+    if (desc) out(row(chalk3.dim(desc), w));
     const tags = [];
     if (state.workflowStatus !== "none")
       tags.push(workflowBadge(state.workflowStatus));
@@ -2944,12 +2926,12 @@ function renderDashboard(state, actions, hint, refreshing) {
       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));
+    if (tags.length) out(row(tags.join("  "), w));
   } else {
-    console.log(row(chalk3.dim("No linked issue"), w));
+    out(row(chalk3.dim("No linked issue"), w));
   }
   section("Branch");
-  console.log(row(chalk3.magenta(state.branch), w));
+  out(row(chalk3.magenta(state.branch), w));
   const bits = [];
   if (state.commits.length > 0)
     bits.push(chalk3.dim(`${state.commits.length} ahead`));
@@ -2958,12 +2940,12 @@ function renderDashboard(state, actions, hint, refreshing) {
   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));
+  if (bits.length) out(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(
+    out(row(chalk3.cyan(`#${state.pr.number}`) + titleText, w));
+    out(
       row(
         prBadge(state.pr.state, state.pr.isDraft) + reviewBadge(state.pr.reviewDecision),
         w
@@ -2971,7 +2953,7 @@ function renderDashboard(state, actions, hint, refreshing) {
     );
     if (state.hasActionableFeedback) {
       const n = state.reviewFeedback.length;
-      console.log(
+      out(
         row(
           chalk3.yellow(`${n} actionable comment${n !== 1 ? "s" : ""} pending`),
           w
@@ -2979,62 +2961,421 @@ function renderDashboard(state, actions, hint, refreshing) {
       );
     }
     if (state.hasUIChanges && state.isPlaywrightAvailable && state.config.video.enabled && state.pr.state === "open") {
-      console.log(
+      out(
         row(
           chalk3.cyan("UI changes detected") + chalk3.dim(" \xB7 video capture available"),
           w
         )
       );
     }
-    console.log(row(chalk3.dim(state.pr.url), w));
+    out(row(chalk3.dim(state.pr.url), w));
   } else {
-    console.log(row(chalk3.dim("No PR created"), w));
+    out(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.substring(0, w - 5), w));
+      out(row(c.substring(0, w - 5), w));
     }
     if (state.commits.length > max) {
-      console.log(
-        row(chalk3.dim(`\u2026 and ${state.commits.length - max} more`), w)
-      );
+      out(row(chalk3.dim(`\u2026 and ${state.commits.length - max} more`), w));
     }
   } else {
-    console.log(row(chalk3.dim("No commits"), w));
+    out(row(chalk3.dim("No commits"), w));
   }
   if (hint) {
     section("Hint");
-    console.log(row(chalk3.yellow(hint), w));
+    out(row(chalk3.yellow(hint), w));
   }
-  console.log(divRow(w));
+  out(divRow(w));
   if (refreshing) {
-    console.log(row(chalk3.yellow("Refreshing\u2026"), w));
+    out(row(chalk3.yellow("Refreshing\u2026"), w));
   } else {
     for (const line of formatCommandBar(actions, w)) {
-      console.log(row(line, w));
+      out(row(line, w));
     }
   }
-  console.log(botRow(w));
+  out(botRow(w));
+  return lines;
+}
+function renderDashboard(state, actions, hint, refreshing) {
+  const lines = buildDashboardLines(state, actions, hint, refreshing);
+  for (const line of lines) {
+    console.log(line);
+  }
 }
 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 inquirer7.prompt([
-    {
-      type: "confirm",
-      name: "ok",
-      message,
-      default: true
+// src/tui/modal.ts
+import chalk4 from "chalk";
+function modalTopRow(title, w) {
+  const label = ` ${title} `;
+  const fill = w - 2 - label.length;
+  return chalk4.bold("\u250C") + chalk4.bold.cyan(label) + chalk4.bold("\u2500".repeat(Math.max(0, fill)) + "\u2510");
+}
+function modalDivRow(w) {
+  return chalk4.bold("\u251C" + "\u2500".repeat(w - 2) + "\u2524");
+}
+function modalBotRow(w) {
+  return chalk4.bold("\u2514" + "\u2500".repeat(w - 2) + "\u2518");
+}
+function truncateAnsi(text, max) {
+  if (visibleLen(text) <= max) return text;
+  let visible = 0;
+  let i = 0;
+  while (i < text.length && visible < max - 1) {
+    if (text[i] === "\x1B") {
+      const end = text.indexOf("m", i);
+      if (end !== -1) {
+        i = end + 1;
+        continue;
+      }
     }
-  ]);
-  return ok;
+    visible++;
+    i++;
+  }
+  return text.slice(0, i) + "\x1B[0m\u2026";
+}
+function modalRow(text, w) {
+  const inner = w - 4;
+  const fitted = truncateAnsi(text, inner);
+  const pad = Math.max(0, inner - visibleLen(fitted));
+  return chalk4.bold("\u2502") + " " + fitted + " ".repeat(pad) + " " + chalk4.bold("\u2502");
+}
+function modalEmptyRow(w) {
+  return modalRow("", w);
+}
+function buildModalFrame(title, contentLines, footerText, width) {
+  const lines = [];
+  lines.push(modalTopRow(title, width));
+  lines.push(modalEmptyRow(width));
+  for (const line of contentLines) {
+    lines.push(modalRow(line, width));
+  }
+  lines.push(modalEmptyRow(width));
+  lines.push(modalDivRow(width));
+  lines.push(modalRow(chalk4.dim(footerText), width));
+  lines.push(modalBotRow(width));
+  return lines;
+}
+function isSeparator(entry) {
+  return "separator" in entry;
+}
+function buildSelectContent(items, selectedIndex, maxWidth) {
+  const lines = [];
+  let selectableIdx = 0;
+  for (const item of items) {
+    if (isSeparator(item)) {
+      lines.push(chalk4.dim(item.separator));
+    } else {
+      const isSelected = selectableIdx === selectedIndex;
+      const prefix = isSelected ? chalk4.cyan.bold("> ") : "  ";
+      const label = item.name.length > maxWidth - 2 ? item.name.slice(0, maxWidth - 3) + "\u2026" : item.name;
+      lines.push(
+        prefix + (isSelected ? chalk4.bold(label) : label)
+      );
+      selectableIdx++;
+    }
+  }
+  return lines;
+}
+function buildConfirmContent(message, selectedYes) {
+  const yes = selectedYes ? chalk4.cyan.bold("> Yes") : chalk4.dim("  Yes");
+  const no = !selectedYes ? chalk4.cyan.bold("> No") : chalk4.dim("  No");
+  return [message, "", yes, no];
+}
+function buildInputContent(label, value, cursorVisible) {
+  const cursor = cursorVisible ? chalk4.cyan("_") : " ";
+  return [label, "", chalk4.cyan("> ") + value + cursor];
+}
+function buildMultilineInputContent(label, value, cursorVisible, maxWidth) {
+  const cursor = cursorVisible ? chalk4.cyan("_") : " ";
+  const lines = [label, ""];
+  if (value === "") {
+    lines.push(chalk4.cyan("  ") + cursor);
+  } else {
+    const inputLines = value.split("\n");
+    const contentWidth = maxWidth - 2;
+    for (let i = 0; i < inputLines.length; i++) {
+      const raw = inputLines[i];
+      const wrapped = wrapLine(raw, contentWidth);
+      for (let j = 0; j < wrapped.length; j++) {
+        const isLastLine = i === inputLines.length - 1 && j === wrapped.length - 1;
+        const text = wrapped[j] + (isLastLine ? cursor : "");
+        lines.push(chalk4.cyan("  ") + text);
+      }
+    }
+  }
+  return lines;
 }
+function wrapLine(text, width) {
+  if (width <= 0) return [text];
+  if (text.length <= width) return [text];
+  const result = [];
+  let remaining = text;
+  while (remaining.length > width) {
+    let breakAt = remaining.lastIndexOf(" ", width);
+    if (breakAt <= 0) breakAt = width;
+    result.push(remaining.slice(0, breakAt));
+    remaining = remaining.slice(breakAt).replace(/^ /, "");
+  }
+  if (remaining.length > 0 || result.length === 0) {
+    result.push(remaining);
+  }
+  return result;
+}
+function termSize() {
+  return {
+    cols: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  };
+}
+function moveTo(row2, col) {
+  return `\x1B[${row2};${col}H`;
+}
+function hideCursor() {
+  return "\x1B[?25l";
+}
+function showCursor() {
+  return "\x1B[?25h";
+}
+function modalWidth() {
+  const cols = process.stdout.columns || 80;
+  return Math.min(60, cols - 4);
+}
+function renderOverlay(dashboardLines, modalLines, mWidth) {
+  const { cols, rows } = termSize();
+  process.stdout.write("\x1B[2J\x1B[0f");
+  process.stdout.write(hideCursor());
+  for (let i = 0; i < dashboardLines.length && i < rows; i++) {
+    process.stdout.write(
+      moveTo(i + 1, 1) + chalk4.dim(stripAnsi(dashboardLines[i]))
+    );
+  }
+  const startRow = Math.max(1, Math.floor((rows - modalLines.length) / 2));
+  const startCol = Math.max(1, Math.floor((cols - mWidth) / 2));
+  for (let i = 0; i < modalLines.length; i++) {
+    process.stdout.write(moveTo(startRow + i, startCol) + modalLines[i]);
+  }
+  process.stdout.write(moveTo(startRow + modalLines.length + 1, 1));
+}
+function readKey() {
+  return new Promise((resolve) => {
+    const { stdin } = process;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (data) => {
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      if (data === "") {
+        resolve({ name: "escape", raw: data });
+      } else if (data === "\x1B" || data === "\x1B\x1B") {
+        resolve({ name: "escape", raw: data });
+      } else if (data === "\x1B[A") {
+        resolve({ name: "up", raw: data });
+      } else if (data === "\x1B[B") {
+        resolve({ name: "down", raw: data });
+      } else if (data === "\x1B[C") {
+        resolve({ name: "right", raw: data });
+      } else if (data === "\x1B[D") {
+        resolve({ name: "left", raw: data });
+      } else if (data === "\r" || data === "\n") {
+        resolve({ name: "enter", raw: data });
+      } else if (data === "\x7F" || data === "\b") {
+        resolve({ name: "backspace", raw: data });
+      } else if (data === "	") {
+        resolve({ name: "tab", raw: data });
+      } else if (data === "") {
+        resolve({ name: "ctrl-s", raw: data });
+      } else if (data.length === 1 && data.charCodeAt(0) >= 32) {
+        resolve({ name: data, raw: data });
+      } else {
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function showConfirm(opts) {
+  const w = modalWidth();
+  let selectedYes = true;
+  const render = () => {
+    const content = buildConfirmContent(opts.message, selectedYes);
+    const footer = "\u2191\u2193 Select  Enter Confirm  Esc Cancel";
+    const lines = buildModalFrame(opts.title, content, footer, w);
+    renderOverlay(opts.dashboardLines, lines, w);
+  };
+  render();
+  while (true) {
+    const key = await readKey();
+    switch (key.name) {
+      case "up":
+      case "down":
+      case "tab":
+        selectedYes = !selectedYes;
+        render();
+        break;
+      case "enter":
+        process.stdout.write(showCursor());
+        return selectedYes;
+      case "escape":
+        process.stdout.write(showCursor());
+        return false;
+      case "y":
+        process.stdout.write(showCursor());
+        return true;
+      case "n":
+        process.stdout.write(showCursor());
+        return false;
+    }
+  }
+}
+function selectableCount(items) {
+  return items.filter((i) => !isSeparator(i)).length;
+}
+async function showSelect(opts) {
+  const w = modalWidth();
+  const maxItems = selectableCount(opts.items);
+  if (maxItems === 0) return null;
+  let selectedIndex = 0;
+  const render = () => {
+    const content = buildSelectContent(opts.items, selectedIndex, w - 6);
+    const footer = "\u2191\u2193 Navigate  Enter Select  Esc Cancel";
+    const lines = buildModalFrame(opts.title, content, footer, w);
+    renderOverlay(opts.dashboardLines, lines, w);
+  };
+  render();
+  while (true) {
+    const key = await readKey();
+    switch (key.name) {
+      case "up":
+        selectedIndex = (selectedIndex - 1 + maxItems) % maxItems;
+        render();
+        break;
+      case "down":
+        selectedIndex = (selectedIndex + 1) % maxItems;
+        render();
+        break;
+      case "enter": {
+        process.stdout.write(showCursor());
+        let idx = 0;
+        for (const item of opts.items) {
+          if (!isSeparator(item)) {
+            if (idx === selectedIndex) return item.value;
+            idx++;
+          }
+        }
+        return null;
+      }
+      case "escape":
+        process.stdout.write(showCursor());
+        return null;
+    }
+  }
+}
+async function showInput(opts) {
+  const w = modalWidth();
+  let value = "";
+  let cursorBlink = true;
+  const render = () => {
+    const maxLen = w - 10;
+    const displayValue = value.length > maxLen ? value.slice(value.length - maxLen) : value;
+    const content = buildInputContent(opts.label, displayValue, cursorBlink);
+    const footer = "Enter Submit  Esc Cancel";
+    const lines = buildModalFrame(opts.title, content, footer, w);
+    renderOverlay(opts.dashboardLines, lines, w);
+  };
+  render();
+  while (true) {
+    const key = await readKey();
+    switch (key.name) {
+      case "enter":
+        process.stdout.write(showCursor());
+        return value.trim() || null;
+      case "escape":
+        process.stdout.write(showCursor());
+        return null;
+      case "backspace":
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+        }
+        render();
+        break;
+      default:
+        if (key.raw.length === 1 && key.raw.charCodeAt(0) >= 32) {
+          value += key.raw;
+          cursorBlink = true;
+          render();
+        }
+        break;
+    }
+  }
+}
+async function showMultilineInput(opts) {
+  const w = modalWidth();
+  let value = "";
+  let cursorBlink = true;
+  const contentWidth = w - 6;
+  const render = () => {
+    const content = buildMultilineInputContent(
+      opts.label,
+      value,
+      cursorBlink,
+      contentWidth
+    );
+    const footer = "Enter Newline  Ctrl+S Submit  Esc Cancel";
+    const lines = buildModalFrame(opts.title, content, footer, w);
+    renderOverlay(opts.dashboardLines, lines, w);
+  };
+  render();
+  while (true) {
+    const key = await readKey();
+    switch (key.name) {
+      case "ctrl-s":
+        process.stdout.write(showCursor());
+        return value.trim() || null;
+      case "enter":
+        value += "\n";
+        cursorBlink = true;
+        render();
+        break;
+      case "escape":
+        process.stdout.write(showCursor());
+        return null;
+      case "backspace":
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+        }
+        render();
+        break;
+      default:
+        if (key.raw.length === 1 && key.raw.charCodeAt(0) >= 32) {
+          value += key.raw;
+          cursorBlink = true;
+          render();
+        }
+        break;
+    }
+  }
+}
+function showStatus(title, message, dashboardLines) {
+  const w = modalWidth();
+  const content = [message];
+  const footer = "";
+  const lines = buildModalFrame(title, content, footer, w);
+  renderOverlay(dashboardLines, lines, w);
+}
+
+// src/commands/tui.ts
+var CANCEL = /* @__PURE__ */ Symbol("cancel");
 async function waitForKey(validKeys) {
   return new Promise((resolve) => {
     const { stdin } = process;
@@ -3060,99 +3401,66 @@ async function waitForKey(validKeys) {
     stdin.on("data", onData);
   });
 }
-async function executeAction(actionId, state) {
+var CONTINUE = { running: true, refresh: true };
+var SKIP_REFRESH = { running: true, refresh: false };
+var QUIT = { running: false, refresh: false };
+async function executeAction(actionId, state, dashboardLines) {
   switch (actionId) {
     case "quit":
-      return false;
+      return QUIT;
     case "list": {
-      clearScreen();
-      try {
-        await listCommand({});
-      } catch (error) {
-        logger.error(`List failed: ${error}`);
-      }
-      await promptContinue();
-      return true;
+      const switched = await handleList(dashboardLines);
+      return switched ? CONTINUE : SKIP_REFRESH;
     }
     case "create": {
+      const description = await showMultilineInput({
+        title: "New Ticket",
+        label: "Describe the ticket:",
+        dashboardLines
+      });
+      if (!description) return SKIP_REFRESH;
       clearScreen();
-      const { description } = await inquirer7.prompt([
-        {
-          type: "input",
-          name: "description",
-          message: "Describe the ticket (empty to cancel):"
-        }
-      ]);
-      if (!description.trim()) {
-        logger.info("Cancelled");
-        return true;
-      }
       try {
         await createCommand(description, {});
       } catch (error) {
         logger.error(`Create failed: ${error}`);
       }
-      await promptContinue();
-      return true;
+      return CONTINUE;
+    }
+    case "commit": {
+      const committed = await handleCommit(state, dashboardLines);
+      return committed ? CONTINUE : SKIP_REFRESH;
     }
-    case "commit":
-      clearScreen();
-      await handleCommit(state);
-      await promptContinue();
-      return true;
     case "push":
-      clearScreen();
-      await handlePush();
-      await promptContinue();
-      return true;
+      await handlePush(dashboardLines);
+      return CONTINUE;
     case "pr": {
       clearScreen();
-      if (!await confirm("Create a pull request?")) return true;
       await prCommand({});
-      await promptContinue();
-      return true;
+      return CONTINUE;
     }
     case "run": {
-      clearScreen();
-      const hasCommits = state.commits.length > 0;
-      const hasFeedback = state.hasActionableFeedback;
-      let msg;
-      if (hasFeedback && hasCommits) {
-        msg = "Start AI agent to address review feedback?";
-      } else if (hasCommits) {
-        msg = "Start AI agent to continue implementation from existing commits?";
-      } else {
-        msg = "Start AI agent to implement this ticket from scratch?";
-      }
-      if (!await confirm(msg)) return true;
       await handleRun(state);
-      await promptContinue();
-      return true;
+      return CONTINUE;
     }
     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;
-    }
+      await handleSwitchProvider(state, dashboardLines);
+      return SKIP_REFRESH;
+    case "checkout-main":
+      await handleCheckoutMain(dashboardLines);
+      return CONTINUE;
     default:
-      return true;
+      return SKIP_REFRESH;
   }
 }
-async function handleCommit(state) {
+async function handleCommit(state, dashboardLines) {
   try {
     const { stdout: status } = await execa4("git", ["status", "--short"]);
     if (!status.trim()) {
-      logger.info("No changes to commit");
-      return;
+      showStatus("Commit", "No changes to commit", dashboardLines);
+      await new Promise((r) => setTimeout(r, 1500));
+      return false;
     }
-    logger.info("Changes:");
-    console.log(status);
-    console.log();
     await execa4("git", ["add", "-A"]);
     const { stdout: diffStat } = await execa4("git", [
       "diff",
@@ -3165,69 +3473,69 @@ async function handleCommit(state) {
     const issueTitle = state.issue?.title ?? null;
     const provider = state.config.ai.provider;
     const providerName = getProviderDisplayName(provider);
-    const { mode } = await inquirer7.prompt([
-      {
-        type: "list",
-        name: "mode",
-        message: "How would you like to provide the commit message?",
-        choices: [
-          { name: `Generate with ${providerName}`, value: "ai" },
-          { name: "Enter manually", value: "manual" }
-        ]
-      }
-    ]);
+    const mode = await showSelect({
+      title: "Commit",
+      items: [
+        { name: `Generate with ${providerName}`, value: "ai" },
+        { name: "Enter manually", value: "manual" }
+      ],
+      dashboardLines
+    });
+    if (!mode) {
+      await execa4("git", ["reset", "HEAD"]);
+      return false;
+    }
     let message;
     if (mode === "manual") {
-      const { manualInput } = await inquirer7.prompt([
-        {
-          type: "input",
-          name: "manualInput",
-          message: "Commit message (empty to cancel):"
-        }
-      ]);
-      message = manualInput.trim() || CANCEL;
+      const input = await showInput({
+        title: "Commit Message",
+        label: "Enter commit message:",
+        dashboardLines
+      });
+      message = input || CANCEL;
     } else {
-      logger.info(`Generating commit message with ${providerName}...`);
+      showStatus("Generating", `Generating commit message with ${providerName}...`, dashboardLines);
       message = await generateCommitMessage(
         diffContent,
         issueNumber,
         issueTitle,
-        state
+        state,
+        dashboardLines
       );
     }
     if (message === CANCEL) {
       await execa4("git", ["reset", "HEAD"]);
-      logger.info("Cancelled");
-      return;
+      return false;
     }
-    console.log();
-    logger.info(`Message: ${message}`);
-    console.log();
-    if (!await confirm("Commit with this message?")) {
+    const confirmed = await showConfirm({
+      title: "Commit",
+      message: `Message: ${message.length > 50 ? message.slice(0, 50) + "\u2026" : message}`,
+      dashboardLines
+    });
+    if (!confirmed) {
       await execa4("git", ["reset", "HEAD"]);
-      logger.info("Commit cancelled");
-      return;
+      return false;
     }
     const providerEmail = getProviderEmail(provider);
     const fullMessage = `${message}
 
 Co-Authored-By: ${providerName} <${providerEmail}>`;
-    const spinner = createSpinner("Committing...");
-    spinner.start();
+    showStatus("Committing", "Committing changes...", dashboardLines);
     await execa4("git", ["commit", "-m", fullMessage]);
-    spinner.succeed("Changes committed");
+    return true;
   } catch (error) {
     logger.error(`Commit failed: ${error}`);
+    return false;
   }
 }
-async function generateCommitMessage(diffContent, issueNumber, issueTitle, state) {
+async function generateCommitMessage(diffContent, issueNumber, issueTitle, state, dashboardLines) {
   try {
     const prompt = buildCommitMessagePrompt(
       diffContent,
       issueNumber,
       issueTitle
     );
-    const result = await invokeAI({ prompt, streamOutput: true }, state.config);
+    const result = await invokeAI({ prompt, streamOutput: false }, state.config);
     let message = result.output.trim().split("\n")[0].trim();
     for (const q of ['"', "'", "`"]) {
       if (message.startsWith(q) && message.endsWith(q)) {
@@ -3238,16 +3546,12 @@ async function generateCommitMessage(diffContent, issueNumber, issueTitle, state
     message = message.replace(/^```\w*\s*/, "").replace(/\s*```$/, "");
     return message;
   } catch {
-    logger.warning("AI commit message generation failed");
-    console.log();
-    const { message } = await inquirer7.prompt([
-      {
-        type: "input",
-        name: "message",
-        message: "Commit message (empty to cancel):"
-      }
-    ]);
-    return message.trim() || CANCEL;
+    const input = await showInput({
+      title: "Commit Message",
+      label: "AI generation failed. Enter commit message:",
+      dashboardLines
+    });
+    return input || CANCEL;
   }
 }
 async function handleRun(state) {
@@ -3295,61 +3599,190 @@ ${feedbackLines}`);
     logger.error(`${providerName} session failed: ${error}`);
   }
 }
-async function handlePush() {
+async function handlePush(dashboardLines) {
   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");
+    const branchName = branch.trim();
+    showStatus("Pushing", `Pushing ${branchName} to remote...`, dashboardLines);
+    await execa4("git", ["push", "-u", "origin", branchName]);
   } catch (error) {
     logger.error(`Push failed: ${error}`);
   }
 }
 var PROVIDERS = ["claude", "gemini", "codex"];
-async function handleSwitchProvider(state) {
+async function handleSwitchProvider(state, dashboardLines) {
   const current = state.config.ai.provider;
-  const { provider } = await inquirer7.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;
+  const items = PROVIDERS.map((p) => ({
+    name: p.charAt(0).toUpperCase() + p.slice(1) + (p === current ? " (current)" : ""),
+    value: p
+  }));
+  const provider = await showSelect({
+    title: "AI Provider",
+    items,
+    dashboardLines
+  });
+  if (!provider || provider === current) return;
   setRuntimeProvider(provider);
-  logger.success(`Provider switched to ${provider} (session only)`);
+  state.config.ai.provider = provider;
 }
-async function handleCheckoutMain() {
+async function handleCheckoutMain(dashboardLines) {
   try {
-    const spinner = createSpinner("Switching to main...");
-    spinner.start();
+    showStatus("Switching", "Switching to main...", dashboardLines);
     await execa4("git", ["checkout", "main"]);
     await execa4("git", ["pull"]);
-    spinner.succeed("Switched to main");
   } catch (error) {
     logger.error(`Checkout failed: ${error}`);
   }
 }
-async function promptContinue() {
-  console.log();
-  await inquirer7.prompt([
-    {
-      type: "input",
-      name: "continue",
-      message: "Press Enter to continue..."
+async function handleList(dashboardLines) {
+  try {
+    showStatus("Loading", "Fetching tickets...", dashboardLines);
+    const config = loadConfig();
+    const workflowLabels = getWorkflowLabels(config);
+    const [inProgress, ready, prs, localBranches] = await Promise.all([
+      listIssues({
+        labels: [workflowLabels.inProgress],
+        state: "open",
+        limit: 20
+      }),
+      listIssues({
+        labels: [workflowLabels.ready],
+        state: "open",
+        limit: 20
+      }),
+      listOpenPrs(30),
+      listLocalBranches()
+    ]);
+    sortByPriority(inProgress);
+    sortByPriority(ready);
+    const choices = buildTicketChoices(inProgress, ready, prs, localBranches);
+    const currentBranch = await getCurrentBranch();
+    const defaultBranch = await getDefaultBranch();
+    const items = [];
+    const mainLabel = defaultBranch + (currentBranch === defaultBranch ? " (current)" : "");
+    items.push({ name: mainLabel, value: "__main__" });
+    const inProgressChoices = choices.filter(
+      (c) => c.category === "in-progress"
+    );
+    const openPrChoices = choices.filter((c) => c.category === "open-pr");
+    const readyChoices = choices.filter((c) => c.category === "ready");
+    if (inProgressChoices.length > 0) {
+      items.push({ separator: "\u2500\u2500 In Progress \u2500\u2500" });
+      for (const c of inProgressChoices) {
+        items.push({
+          name: `#${c.issueNumber} ${c.title}`,
+          value: String(c.issueNumber)
+        });
+      }
     }
-  ]);
+    if (openPrChoices.length > 0) {
+      items.push({ separator: "\u2500\u2500 Open PRs \u2500\u2500" });
+      for (const c of openPrChoices) {
+        items.push({
+          name: `#${c.issueNumber} ${c.title}`,
+          value: String(c.issueNumber)
+        });
+      }
+    }
+    if (readyChoices.length > 0) {
+      items.push({ separator: "\u2500\u2500 Ready \u2500\u2500" });
+      for (const c of readyChoices) {
+        items.push({
+          name: `#${c.issueNumber} ${c.title}`,
+          value: String(c.issueNumber)
+        });
+      }
+    }
+    if (choices.length === 0) {
+      showStatus("List", "No tickets found", dashboardLines);
+      await new Promise((r) => setTimeout(r, 1500));
+      return false;
+    }
+    const selected = await showSelect({
+      title: "Switch Ticket",
+      items,
+      dashboardLines
+    });
+    if (!selected) return false;
+    if (selected === "__main__") {
+      if (currentBranch === defaultBranch) return false;
+      const dirty2 = await hasUncommittedChanges();
+      if (dirty2) {
+        const ok = await showConfirm({
+          title: "Uncommitted Changes",
+          message: "You have uncommitted changes. Continue?",
+          dashboardLines
+        });
+        if (!ok) return false;
+      }
+      showStatus("Switching", `Switching to ${defaultBranch}...`, dashboardLines);
+      await checkoutBranch(defaultBranch);
+      return true;
+    }
+    const issueNumber = parseInt(selected, 10);
+    const ticket = choices.find((c) => c.issueNumber === issueNumber);
+    if (!ticket) return false;
+    const dirty = await hasUncommittedChanges();
+    if (dirty) {
+      const ok = await showConfirm({
+        title: "Uncommitted Changes",
+        message: "You have uncommitted changes. Continue?",
+        dashboardLines
+      });
+      if (!ok) return false;
+    }
+    const targetBranch = ticket.branch;
+    if (targetBranch) {
+      if (await branchExists(targetBranch)) {
+        showStatus("Switching", `Switching to ${targetBranch}...`, dashboardLines);
+        await checkoutBranch(targetBranch);
+        return true;
+      } else if (await remoteBranchExists(targetBranch)) {
+        showStatus("Fetching", `Fetching ${targetBranch}...`, dashboardLines);
+        await fetchAndCheckout(targetBranch);
+        return true;
+      } else {
+        return await offerCreateBranch2(
+          issueNumber,
+          ticket.title,
+          dashboardLines
+        );
+      }
+    } else {
+      return await offerCreateBranch2(
+        issueNumber,
+        ticket.title,
+        dashboardLines
+      );
+    }
+  } catch (error) {
+    logger.error(`List failed: ${error}`);
+    return false;
+  }
+}
+async function offerCreateBranch2(issueNumber, title, dashboardLines) {
+  const config = loadConfig();
+  const branchName = await generateBranchName(
+    config,
+    issueNumber,
+    title,
+    "feature"
+  );
+  const create = await showConfirm({
+    title: "Create Branch",
+    message: `No branch found. Create ${branchName}?`,
+    dashboardLines
+  });
+  if (!create) return false;
+  const defaultBranch = await getDefaultBranch();
+  showStatus("Creating", `Creating ${branchName}...`, dashboardLines);
+  await createBranch(branchName, defaultBranch);
+  return true;
 }
 async function tuiCommand() {
   let running = true;
   let lastActions = [];
+  let lastDashboardLines = [];
   const config = loadConfig();
   let lastState = {
     isGitRepo: true,
@@ -3373,28 +3806,36 @@ async function tuiCommand() {
     hasUIChanges: false,
     isPlaywrightAvailable: false
   };
+  let needsRefresh = true;
   while (running) {
-    clearScreen();
-    renderDashboard(lastState, lastActions, void 0, true);
-    const state = await aggregateState();
-    const actions = getAvailableActions(state);
-    lastState = state;
-    lastActions = actions;
-    clearScreen();
+    if (needsRefresh) {
+      clearScreen();
+      renderDashboard(lastState, lastActions, void 0, true);
+      const state = await aggregateState();
+      const actions = getAvailableActions(state);
+      lastState = state;
+      lastActions = actions;
+    }
     let hint;
-    if (state.isOnMain) {
+    if (lastState.isOnMain) {
       hint = "Select an action to get started";
-    } else if (state.hasUncommittedChanges && !state.pr) {
+    } else if (lastState.hasUncommittedChanges && !lastState.pr) {
       hint = "Commit your changes before creating a PR";
-    } else if (state.hasActionableFeedback) {
+    } else if (lastState.hasActionableFeedback) {
       hint = "Review feedback needs attention";
     }
-    renderDashboard(state, actions, hint);
-    const validKeys = actions.map((a) => a.shortcut);
+    lastDashboardLines = buildDashboardLines(lastState, lastActions, hint);
+    clearScreen();
+    for (const line of lastDashboardLines) {
+      console.log(line);
+    }
+    const validKeys = lastActions.map((a) => a.shortcut);
     const key = await waitForKey(validKeys);
-    const action = actions.find((a) => a.shortcut === key);
+    const action = lastActions.find((a) => a.shortcut === key);
     if (action) {
-      running = await executeAction(action.id, state);
+      const result = await executeAction(action.id, lastState, lastDashboardLines);
+      running = result.running;
+      needsRefresh = result.refresh;
     }
   }
 }