@retasc/cli 1.16.0 → 1.16.1

package/CHANGELOG.md

@@ -6,6 +6,29 @@ release commits and the issues they reference.
 
 Dates are the npm publish date. Each entry names the RTSC issue behind it.
 
+## 1.16.1 (2026-08-02)
+
+- **RTSC-528** — two things the first real `retasc import` run turned up.
+
+  **The progress bar never appeared.** It only started drawing once it had seen the run
+  reported as running, and a 15-issue import finishes before that is ever observed, so the
+  output went straight from `Importing…` to `✓ Imported.` with a silent gap. It now draws
+  the moment the run starts, sweeping while it waits for counts and switching to the real
+  bar once they arrive. Still silent without a terminal and under `NO_COLOR`.
+
+  **The column prompt didn't say what to do.** It read
+  `to do  [todo]  (todo / doing / done / canceled):`, where nothing is a verb, so the first
+  person to run it had to guess that you type one of the words. Now:
+
+  ```
+    to do
+      Enter to keep todo, or type: doing, done, canceled
+    >
+  ```
+
+  The suggestion is no longer repeated among the alternatives, which is what made the old
+  line read as four equal options behind a mysterious bracket.
+
 ## 1.16.0 (2026-08-02)
 
 - **RTSC-526** — `retasc import` catches up with the Dash on four things.

package/dist/commands/import.js

@@ -72,6 +72,19 @@ export function summaryLines(summary, label) {
 const LIME = "\x1b[38;5;154m";
 const DIM = "\x1b[38;5;240m";
 const RESET = "\x1b[0m";
+/**
+ * An indeterminate sweep, for the stretch before the server reports counts (RTSC-528).
+ *
+ * Pure and frame-indexed rather than time-based, so a test can pin every frame. A block
+ * that travels is the honest shape when the total is unknown: a 0% bar reads as stalled,
+ * which is the very impression this is here to prevent.
+ */
+export function sweep(frame, width = 24, color = true) {
+    const pos = frame % (width * 2 - 2);
+    const at = pos < width ? pos : width * 2 - 2 - pos; // bounce, so it never jumps
+    const cells = Array.from({ length: width }, (_, i) => Math.abs(i - at) <= 1 ? "\u2588" : "\u2591").join("");
+    return `  ${color ? LIME : ""}${cells}${color ? RESET : ""}  working…`;
+}
 /**
  * One line of progress bar.
  *
@@ -167,7 +180,8 @@ export async function mapStatuses(statuses, reviewers, askFn) {
     const statusMap = {};
     const reviewerByStatus = {};
     console.log(`\nWhat does each column mean? ${statuses.length} to confirm.\n` +
-        "  Enter keeps the suggestion. It comes from the column's type in your tool, not its name.");
+        "  Press Enter to keep the suggested answer, or type a different one.\n" +
+        "  The suggestion comes from the column's type in your tool, not its name.");
     // Grouped under the source's own section names, in the source's own order within each
     // (RTSC-436/526). On a twenty-column Jira board a flat list is a wall; the sections are
     // the shape the human already has in front of them in their tool.
@@ -183,7 +197,20 @@ export async function mapStatuses(statuses, reviewers, askFn) {
             ? s.suggested
             : "todo";
         for (let attempt = 0;; attempt++) {
-            const answer = (await askFn(`\n  ${clean(s.name)}  [${suggested}]  (${allowed.join(" / ")}): `)).trim().toLowerCase();
+            // RTSC-528 — the prompt has to name the ACTION. It used to read
+            //   `to do  [todo]  (todo / doing / done / canceled):`
+            // where nothing is a verb: the bracket is the default and the parenthesis is a bare
+            // word list, so the first person to run it had to guess that you type one of them.
+            // The reviewer picker two lines below says "Choose a number" and is unambiguous,
+            // which made the contrast worse.
+            //
+            // The suggestion is also removed from the alternatives — it is already what Enter
+            // does, and listing it again is what made the line read as four equal options with a
+            // mysterious bracket in front.
+            const others = allowed.filter((m) => m !== suggested);
+            const answer = (await askFn(`\n  ${clean(s.name)}\n` +
+                `    Enter to keep ${suggested}, or type: ${others.join(", ")}\n` +
+                `  > `)).trim().toLowerCase();
             const choice = answer === "" ? suggested : answer;
             if (allowed.includes(choice)) {
                 statusMap[s.id] = choice;
@@ -224,28 +251,56 @@ export async function mapStatuses(statuses, reviewers, askFn) {
  * import failure.
  */
 function followProgress(orgId) {
-    const tty = Boolean(stdout.isTTY) && !process.env.NO_COLOR;
     if (!stdout.isTTY)
         return () => { };
+    const color = !process.env.NO_COLOR;
     let stopped = false;
-    const tick = async () => {
+    let frame = 0;
+    // Declared before the paint timer that reads it. Safe either way (the callback fires
+    // after this line runs), but reading a variable above its declaration is a trap to leave
+    // for the next person.
+    let latest = null;
+    // RTSC-528 — DRAW IMMEDIATELY, and keep drawing, rather than waiting to observe
+    // `status === "running"`.
+    //
+    // The first live run showed nothing at all: a 15-issue import is over in a couple of
+    // seconds, so the first poll landed before `runImport` had created the row and the second
+    // landed after it finished. `running` was never seen, so nothing was ever drawn — and the
+    // silent gap this exists to remove was exactly what the human got. A bar that only works
+    // on slow imports is a bar nobody sees while testing.
+    //
+    // So the render loop is independent of the data: it ticks on its own, showing an
+    // indeterminate sweep until counts arrive and the real bar once they do.
+    const draw = (done, total) => {
+        stdout.write(`\r\x1b[2K${done === null ? sweep(frame++, 24, color) : progressBar(done, total, 24, color)}`);
+    };
+    draw(null, null);
+    const paint = setInterval(() => {
+        if (!stopped && latest === null)
+            draw(null, null);
+    }, 120);
+    // Counts, whenever the server has them. Every failure is swallowed: this is decoration
+    // on a run happening regardless, and must never be what surfaces as an import failure.
+    const poll = async () => {
         while (!stopped) {
             try {
                 const p = (await api.latestImport({ orgId }));
                 if (!stopped && p && p.status === "running") {
-                    stdout.write(`\r\x1b[2K${progressBar(p.issuesDone ?? 0, p.issuesTotal ?? null, 24, tty)}`);
+                    latest = { done: p.issuesDone ?? 0, total: p.issuesTotal ?? null };
+                    draw(latest.done, latest.total);
                 }
             }
             catch {
-                /* progress is decoration; never let it speak for the run */
+                /* progress never speaks for the run */
             }
-            await new Promise((r) => setTimeout(r, 1200));
+            await new Promise((r) => setTimeout(r, 700));
         }
     };
-    void tick();
+    void poll();
     return () => {
         stopped = true;
-        // Clear the line so the summary does not land on top of a half-drawn bar.
+        clearInterval(paint);
+        // Clear the line so the summary never lands on a half-drawn bar.
         stdout.write("\r\x1b[2K");
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.16.0",
+  "version": "1.16.1",
   "description": "Retasc CLI \u2014 the issue tracker AI agents pull work from. Sign in with GitHub or Google, create projects, mint agent API keys, and wire your agent to the Retasc MCP server in one command.",
   "type": "module",
   "bin": {