@retasc/cli 1.15.0 → 1.16.1

package/CHANGELOG.md

@@ -6,6 +6,51 @@ 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.
+
+  **It warns before a second import.** Re-importing does not duplicate anything, but it
+  does re-sync: status, labels, title and body are replaced with whatever the source says
+  now. Import from Jira, spend two weeks moving issues along in Retasc, re-import to pick up
+  new tickets, and those two weeks of changes snap back. You now get told, with the date of
+  the last import, before the confirmation.
+
+  **The run shows progress**, as a bar that fills while it works, rather than a silent wait
+  that looks like it has hung. The run is server-side, so pressing Ctrl-C out of boredom
+  never stopped it anyway.
+
+  **The column list is grouped** under your own tool's sections (Not started, Active, Done,
+  Closed) instead of arriving flat. On a twenty-column board that is the difference between
+  scannable and a wall.
+
+  **Columns that were not mapped are named.** If a column appears between the moment you set
+  the mapping and the moment the import runs, its issues land in `todo`. They used to show
+  as a number; now they are listed, with what to do about it.
+
 ## 1.15.0 (2026-08-02)
 
 - **RTSC-524** — new command: `retasc import`. Bring a Linear, Jira, Asana, ClickUp or

package/dist/api.js

@@ -35,6 +35,11 @@ const fns = {
     listImportStatuses: makeFunctionReference("import:listImportStatuses"),
     listReviewCandidates: makeFunctionReference("import:listReviewCandidates"),
     runImport: makeFunctionReference("import:runImport"),
+    // RTSC-526: `latestImport` is LIVE progress and is swept after 24h; `importHistory` is
+    // permanent and per source, so it is the only thing that can answer "has this org
+    // imported from X before?" once the progress row is gone.
+    latestImport: makeFunctionReference("import:latestImport"),
+    importHistory: makeFunctionReference("import:importHistory"),
     claimableGhosts: makeFunctionReference("ghosts:claimableGhosts"),
     claimGhost: makeFunctionReference("ghosts:claimGhost"),
     dismissGhostPrompt: makeFunctionReference("ghosts:dismissGhostPrompt"),
@@ -171,6 +176,8 @@ export const api = {
     listImportStatuses: (args) => withAuth(() => client().action(fns.listImportStatuses, args)),
     listReviewCandidates: (args) => withAuth(() => client().query(fns.listReviewCandidates, args)),
     runImport: (args) => withAuth(() => client().action(fns.runImport, args)),
+    latestImport: (args) => withAuth(() => client().query(fns.latestImport, args)),
+    importHistory: (args) => withAuth(() => client().query(fns.importHistory, args)),
     claimableGhosts: (args) => withAuth(() => client().query(fns.claimableGhosts, args)),
     claimGhost: (args) => withAuth(() => client().mutation(fns.claimGhost, args)),
     dismissGhostPrompt: (args) => withAuth(() => client().mutation(fns.dismissGhostPrompt, args)),

package/dist/commands/import.js

@@ -6,6 +6,104 @@ import { ask, confirm, isInteractive } from "../lib/prompt.js";
 import { pickExisting } from "./bind.js";
 /** The five destinations a column can be mapped to. Mirrors `MappedStatus`. */
 const MAPPED = ["todo", "doing", "review", "done", "canceled"];
+/**
+ * The source's own section names, so the list reads as the shape the human already knows
+ * from their tool. Mirrors `GROUP_LABEL` in `dash/src/lib/statusMapping.ts` (RTSC-436).
+ */
+const GROUP_LABEL = {
+    not_started: "Not started",
+    active: "Active",
+    done: "Done",
+    closed: "Closed",
+};
+/** Section order, matching the Dash. */
+const GROUP_ORDER = ["not_started", "active", "done", "closed"];
+/**
+ * What to say before a SECOND import into the same org (RTSC-526).
+ *
+ * Not a formality. `convex/importWrite.ts` upserts by `sourceIssueId` and patches the match,
+ * so a re-import does not duplicate — the identifier and number survive even a rename — but
+ * it DOES replace status, labels, title and body with whatever the source says now. Two
+ * weeks of moving issues along in Retasc snap back to the source's version.
+ *
+ * Read from `importHistory`, NOT `latestImport`. The latter is live progress and is swept
+ * after 24h, so gating on it means the warning stops firing for exactly the person most at
+ * risk: the one who imported last week and has been working in Retasc since.
+ *
+ * Null when this source has never been imported, so a first run says nothing.
+ */
+export function reimportWarning(history, source, label) {
+    const prior = history.find((h) => h.source === source);
+    if (!prior)
+        return null;
+    const when = prior.lastImportedAt
+        ? ` (last on ${new Date(prior.lastImportedAt).toISOString().slice(0, 10)})`
+        : "";
+    return (`\n! You've imported from ${clean(label)} into this org before${when}.\n` +
+        `  Re-importing re-syncs those issues, so any edits you made in Retasc to them\n` +
+        `  (status, labels, and so on) will be replaced by ${clean(label)}'s version.`);
+}
+/**
+ * The summary after a run, with the one field that needs words rather than a number.
+ *
+ * `unmappedStatuses` holds columns that appeared BETWEEN the mapping being set and the run;
+ * their issues landed in `todo`. As a count it is a silent slice of work in the wrong place,
+ * which is the whole reason the Dash names them.
+ */
+export function summaryLines(summary, label) {
+    const out = [];
+    const unmapped = [];
+    for (const [k, v] of Object.entries(summary ?? {})) {
+        if (k === "unmappedStatuses") {
+            if (Array.isArray(v))
+                unmapped.push(...v.map(String));
+            continue;
+        }
+        if (typeof v === "number" || typeof v === "string")
+            out.push(`  ${k.padEnd(20)}${clean(v)}`);
+    }
+    if (unmapped.length) {
+        out.push("", `! These ${clean(label)} statuses weren't mapped, so their issues landed in todo:`, `    ${unmapped.map((u) => clean(u)).join(", ")}`, "  They appeared after you set the mapping. Re-import to place them.");
+    }
+    return out;
+}
+// --- the progress bar --------------------------------------------------------
+/** Lime, in 256-colour. Bright enough to read on both a light and a dark terminal. */
+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.
+ *
+ * Pure, so the shape can be tested without a terminal. Colour is opt-out via `color`, which
+ * the caller ties to a TTY and to `NO_COLOR` — a bar full of escape sequences in a piped log
+ * is worse than no bar.
+ */
+export function progressBar(done, total, width = 24, color = true) {
+    const known = typeof total === "number" && total > 0;
+    // Clamp: a server that reports more done than total must not print a bar wider than the
+    // terminal, or a negative one.
+    const frac = known ? Math.max(0, Math.min(1, done / total)) : 0;
+    const filled = Math.round(frac * width);
+    const bar = known
+        ? `${color ? LIME : ""}${"█".repeat(filled)}${color ? DIM : ""}${"░".repeat(width - filled)}${color ? RESET : ""}`
+        : `${color ? DIM : ""}${"░".repeat(width)}${color ? RESET : ""}`;
+    const count = known ? `${Math.round(frac * 100)}%  ${done}/${total}` : `${done} so far`;
+    return `  ${bar}  ${count}`;
+}
 /**
  * May this column be mapped to `review`?
  *
@@ -82,15 +180,37 @@ 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.");
-    // The source's own order, so the list reads the way it does in the tool they know.
-    for (const s of [...statuses].sort((a, b) => a.order - b.order)) {
+        "  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.
+    const ordered = GROUP_ORDER.flatMap((g) => {
+        const rows = statuses.filter((s) => s.group === g).sort((a, b) => a.order - b.order);
+        return rows.map((s, i) => ({ s, heading: i === 0 ? GROUP_LABEL[g] : null }));
+    });
+    for (const { s, heading } of ordered) {
+        if (heading)
+            console.log(`\n  ${heading}`);
         const allowed = MAPPED.filter((m) => m !== "review" || (reviewAllowed(s.group) && reviewers.length > 0));
         const suggested = allowed.includes(s.suggested)
             ? 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;
@@ -119,6 +239,71 @@ export async function mapStatuses(statuses, reviewers, askFn) {
     }
     return { statusMap, reviewerByStatus };
 }
+/**
+ * Poll `latestImport` and redraw one line until told to stop. Returns the stopper.
+ *
+ * One LINE, rewritten in place, rather than a scrolling log: the interesting number is the
+ * current one. Silent without a TTY — a progress bar in a piped log is noise, and the
+ * escape codes would end up in whatever reads it.
+ *
+ * Every failure here is swallowed. This is decoration on top of a run that is happening
+ * server-side regardless; a hiccup in the progress query must never be what surfaces as an
+ * import failure.
+ */
+function followProgress(orgId) {
+    if (!stdout.isTTY)
+        return () => { };
+    const color = !process.env.NO_COLOR;
+    let stopped = false;
+    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") {
+                    latest = { done: p.issuesDone ?? 0, total: p.issuesTotal ?? null };
+                    draw(latest.done, latest.total);
+                }
+            }
+            catch {
+                /* progress never speaks for the run */
+            }
+            await new Promise((r) => setTimeout(r, 700));
+        }
+    };
+    void poll();
+    return () => {
+        stopped = true;
+        clearInterval(paint);
+        // Clear the line so the summary never lands on a half-drawn bar.
+        stdout.write("\r\x1b[2K");
+    };
+}
 export async function importAction(opts) {
     if (!isInteractive() && !opts.yes) {
         cliError("NEEDS_TERMINAL", "Importing asks what each of your columns means, so it needs a terminal.", "Run it interactively, or use the Dash.");
@@ -182,12 +367,24 @@ export async function importAction(opts) {
     // undoing a mistake means an org-level cleanup.
     console.log(`\nAbout to import ${clean(target.name)} from ${clean(src.label)} into org ${orgLabel},\n` +
         `as a new project. Issues, comments and their authors come across.`);
+    // RTSC-526 — the second run is the dangerous one, and the terminal is where a command
+    // gets re-run casually. Read from `importHistory` (permanent) rather than `latestImport`
+    // (live progress, swept after 24h), so this still fires for someone who imported last
+    // week and has been working in Retasc since — the person with the most to lose.
+    const history = (await api.importHistory({ orgId: orgId }));
+    const warning = reimportWarning(history, src.source, src.label);
+    if (warning)
+        console.log(warning);
     if (!opts.yes && !(await confirm("This can't be undone. Go ahead?"))) {
         console.log("Nothing imported.");
         return;
     }
     // --- run -------------------------------------------------------------------
-    console.log("\nImporting. This can take a few minutes on a big project…");
+    console.log("\nImporting…\n");
+    // RTSC-526 — show it moving. The run is server-side and can take minutes on a big
+    // project; a silent wait is exactly when someone decides it has hung and presses Ctrl-C,
+    // which is the worst moment to do it because the server keeps going regardless.
+    const stop = followProgress(orgId);
     let res;
     try {
         res = (await api.runImport({
@@ -200,6 +397,7 @@ export async function importAction(opts) {
         }));
     }
     catch (e) {
+        stop();
         // The run is server-side, so a dead connection here does NOT mean a dead import.
         // Saying "failed" would be a guess, and the wrong one sends someone re-importing on
         // top of a run that is still writing.
@@ -211,10 +409,10 @@ export async function importAction(opts) {
         console.error("  Check the Dash before running it again.");
         throw e;
     }
+    stop();
     console.log("\n✓ Imported.");
-    for (const [k, v] of Object.entries(res.summary ?? {})) {
-        if (typeof v === "number" || typeof v === "string")
-            console.log(`  ${k.padEnd(18)}${clean(v)}`);
+    for (const line of summaryLines(res.summary, src.label)) {
+        console.log(line);
     }
     // The import just minted a placeholder for whoever authored that work, and the person
     // who ran it is very often one of them. `identityLoop` is the same prompt `join` uses and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.15.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": {