flowviant 0.72.0 → 0.73.0

package/bin/cli.mjs

@@ -244,7 +244,7 @@ if (process.argv[2] === 'env') {
 // two TTYs and cannot be asked anything — the first read raises SIGTTIN and the
 // kernel STOPS the process, which is why 0.55.2's timeout did not save it (a
 // stopped process runs no timers). See tty.mjs.
-const { canPrompt, askWithTimeout } = await import('./lib/tty.mjs');
+const { canPrompt, askWithTimeout, selectMenu, menuSupported } = await import('./lib/tty.mjs');
 const interactive = canPrompt() && process.env.FLOWVIANT_REEXEC !== '1';
 
 /** How long the one-time binding confirm waits before serving unbound. A person
@@ -285,6 +285,8 @@ if (!FLEET_TOKEN) {
   }
   if (CREDENTIAL.choices?.length && interactive) {
     const creds = await import('./lib/credentials.mjs');
+    const { originSlug } = await import('./lib/git.mjs');
+    const { basename } = await import('node:path');
     const { choices, repoRoot } = CREDENTIAL;
     console.log(
       CREDENTIAL.reason === 'outside-repo'
@@ -293,27 +295,78 @@ if (!FLEET_TOKEN) {
           ? `More than one connected project names this repo (${repoRoot}) — pick which one this daemon serves:`
           : `This repo (${repoRoot}) is not connected to any project yet. Connected on this machine:`
     );
-    console.log(listLines(choices, creds));
-    console.log(`  ${choices.length + 1}. connect ${repoRoot ? 'this repo' : 'a repo'} to a different project (flowviant login)`);
+
+    const loginLabel = `connect ${repoRoot ? 'this repo' : 'a repo'} to a different project (flowviant login)`;
+    // WHICH ONE LOOKS RIGHT — a pre-selection, never an auto-serve. The resolver
+    // refuses to serve a project the repo PATH did not name (the skadooble law);
+    // this only decides which row the cursor starts on, using the repo's folder
+    // name and its github repo-name against the stored project names. A unique
+    // match becomes ONE keypress; a wrong guess costs nothing, because the human
+    // still confirms. `multiple-bound` gets no hint — every choice already names
+    // this repo, so nothing distinguishes them.
+    const slug = repoRoot ? originSlug(repoRoot) : null;
+    const likely =
+      CREDENTIAL.reason === 'multiple-bound'
+        ? -1
+        : creds.likelyChoiceIndex(choices, {
+            repoBasename: repoRoot ? basename(repoRoot) : null,
+            repoSlugName: slug ? slug.split('/')[1] : null,
+          });
+
     // Bounded like the confirm below, and for the same reason — but silence
     // means something DIFFERENT here and the difference is load-bearing. There
     // is a real ambiguity to resolve; serving a guess is the skadooble bug.
     // So no answer REFUSES, which is exactly what this branch already does
     // headless, and the message says how to answer without being present.
-    const raw = await askWithTimeout(
-      `Which project should this daemon serve? [1-${choices.length + 1}] `,
-      PICK_TIMEOUT_MS
-    );
-    if (raw === null) {
-      console.error(
-        `\nno answer in ${Math.round(PICK_TIMEOUT_MS / 1000)}s — nothing started. ` +
-          `Name one with \`--project <name|id>\`, or run \`flowviant\` here in the foreground and pick.`
+    let chosen = null; // 0-based into [...choices, login]
+    if (menuSupported()) {
+      const rowLabel = (e) =>
+        creds.projectLabel(e) + (e.repoRoot ? `  — connected for ${e.repoRoot}` : '  — not tied to a repo yet');
+      const options = [...choices.map(rowLabel), loginLabel];
+      // Say WHY the cursor starts where it does — "intuitive" made visible.
+      if (likely >= 0) options[likely] += '   ← looks like this repo';
+      const res = await selectMenu({
+        options,
+        defaultIndex: likely >= 0 ? likely : 0,
+        timeoutMs: PICK_TIMEOUT_MS,
+      });
+      if (res.timedOut) {
+        console.error(
+          `\nno answer in ${Math.round(PICK_TIMEOUT_MS / 1000)}s — nothing started. ` +
+            `Name one with \`--project <name|id>\`, or run \`flowviant\` here in the foreground and pick.`
+        );
+        process.exit(1);
+      }
+      if (res.cancelled) {
+        console.error('nothing chosen — nothing started.');
+        process.exit(1);
+      }
+      if (!res.unsupported) chosen = res.index;
+    }
+    if (chosen === null) {
+      // Numeric fallback — a pipe, or a terminal without raw mode. Empty Enter
+      // takes the likely default when there is one, so it is one keystroke here
+      // too.
+      console.log(listLines(choices, creds));
+      console.log(`  ${choices.length + 1}. ${loginLabel}`);
+      const hint = likely >= 0 ? ` (enter for ${creds.projectLabel(choices[likely])})` : '';
+      const raw = await askWithTimeout(
+        `Which project should this daemon serve? [1-${choices.length + 1}]${hint} `,
+        PICK_TIMEOUT_MS
       );
-      process.exit(1);
+      if (raw === null) {
+        console.error(
+          `\nno answer in ${Math.round(PICK_TIMEOUT_MS / 1000)}s — nothing started. ` +
+            `Name one with \`--project <name|id>\`, or run \`flowviant\` here in the foreground and pick.`
+        );
+        process.exit(1);
+      }
+      const n = raw === '' && likely >= 0 ? likely + 1 : Number.parseInt(raw, 10);
+      chosen = Number.isInteger(n) ? n - 1 : -1;
     }
-    const n = Number.parseInt(raw, 10);
-    if (n === choices.length + 1) await reexecAfterLogin();
-    const picked = Number.isInteger(n) ? choices[n - 1] : undefined;
+
+    if (chosen === choices.length) await reexecAfterLogin();
+    const picked = chosen >= 0 ? choices[chosen] : undefined;
     if (!picked) {
       console.error('nothing chosen — nothing started.');
       process.exit(1);

package/bin/lib/credentials.mjs

@@ -136,6 +136,40 @@ export function projectLabel(e) {
   return e?.name ?? (e?.projectId ? `project ${e.projectId.slice(0, 8)}…` : 'an unnamed project');
 }
 
+/** Collapse a name or slug for loose comparison: "My Project", "my-project"
+ *  and "myproject" all become "myproject". */
+function normalizeName(s) {
+  return String(s ?? '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '');
+}
+
+/**
+ * WHICH stored project most likely goes with this repo — a HINT for the
+ * picker's default, and DELIBERATELY not a licence to serve it. `resolveStored
+ * Credential` matches by repo PATH and refuses to guess past that, because
+ * serving a project the path did not name is the "it said skadooble in my
+ * calendar repo" surprise this whole file exists to prevent. A name that
+ * matches the repo's folder or its github repo-name is softer evidence — good
+ * enough to put the cursor on that row so the answer is one keypress, never
+ * good enough to skip the human. Two names can collide (a project "api" and a
+ * repo "api"), which is exactly why this only pre-selects.
+ *
+ * Returns the index of a UNIQUE match, or -1 when nothing matches or more than
+ * one does — an ambiguous hint is not a hint, and a default that is as likely
+ * wrong as right is worse than starting at the top.
+ */
+export function likelyChoiceIndex(choices, { repoBasename, repoSlugName } = {}) {
+  const wants = new Set([normalizeName(repoBasename), normalizeName(repoSlugName)].filter(Boolean));
+  if (wants.size === 0) return -1;
+  const hits = [];
+  choices.forEach((e, i) => {
+    const n = normalizeName(e?.name);
+    if (n && wants.has(n)) hits.push(i);
+  });
+  return hits.length === 1 ? hits[0] : -1;
+}
+
 function mutate(fn) {
   const f = readFile() ?? {};
   if (!f.projects || typeof f.projects !== 'object') f.projects = {};

package/bin/lib/tty.mjs

@@ -109,3 +109,126 @@ export async function askWithTimeout(query, timeoutMs) {
     process.off('SIGTTOU', noop);
   }
 }
+
+/**
+ * Can we draw an arrow-navigable menu? Raw mode is what turns ↑/↓ into
+ * keystrokes we receive one at a time; without `setRawMode` (a pipe, a
+ * terminal that refuses raw input) there is nothing to drive, and the caller
+ * falls back to the numeric prompt rather than drawing a menu nobody can move.
+ * `canPrompt()` still gates whether we ask AT ALL — this only decides HOW.
+ */
+export function menuSupported() {
+  return Boolean(
+    process.stdin.isTTY && process.stdout.isTTY && typeof process.stdin.setRawMode === 'function'
+  );
+}
+
+/**
+ * The menu's key handling, PURE so it can be tested without a terminal. Given a
+ * keypress and the current cursor, returns exactly one intent:
+ *   { index }   move the highlight (arrows wrap; k/j vim-style; g/G ends)
+ *   { choose }  take a row (Enter takes the highlight; 1–9 jump-and-take)
+ *   { cancel }  Esc, q, or Ctrl-C — nothing chosen
+ *   null        a key we ignore
+ * A number past the end is ignored, not clamped: pressing 9 in a 3-row list
+ * must not silently select row 3.
+ */
+export function menuKey(key, { index, count }) {
+  if (key === '\x03' || key === '\x1b' || key === 'q' || key === 'Q') return { cancel: true };
+  if (key === '\r' || key === '\n') return { choose: index };
+  if (key === '\x1b[A' || key === 'k') return { index: (index - 1 + count) % count };
+  if (key === '\x1b[B' || key === 'j') return { index: (index + 1) % count };
+  if (key === '\x1b[H' || key === 'g') return { index: 0 };
+  if (key === '\x1b[F' || key === 'G') return { index: count - 1 };
+  if (/^[1-9]$/.test(key)) {
+    const n = Number(key) - 1;
+    return n < count ? { choose: n } : null;
+  }
+  return null;
+}
+
+const MENU_FOOTER = '↑/↓ move · enter select · 1–9 jump · esc cancel';
+
+/**
+ * An arrow-navigable picker for the start path. Resolves one of:
+ *   { index }        the row taken
+ *   { cancelled }    Esc/q/Ctrl-C
+ *   { timedOut }     nobody drove it within timeoutMs
+ *   { unsupported }  no raw mode — the caller uses the numeric prompt instead
+ *
+ * Held to this file's one law — no start-path prompt may hang the daemon — the
+ * same way `askWithTimeout` is: it keeps the timeout, installs the
+ * SIGTTIN/SIGTTOU no-ops that keep that timer alive, restores the terminal in
+ * every exit, and refuses (returns `unsupported`) rather than half-drawing when
+ * raw mode is not really there. The caller still gates on `canPrompt()` before
+ * ever reaching here.
+ */
+export async function selectMenu({ options, defaultIndex = 0, timeoutMs }) {
+  if (!menuSupported()) return { unsupported: true };
+  const stdin = process.stdin;
+  const out = process.stdout;
+  const count = options.length;
+  if (count === 0) return { unsupported: true };
+  let index = Math.min(Math.max(defaultIndex | 0, 0), count - 1);
+
+  const width = Math.max(24, (out.columns || 80) - 2);
+  const clip = (s) => (s.length > width ? s.slice(0, width - 1) + '…' : s);
+  const frame = () =>
+    options
+      .map((o, i) => (i === index ? `\x1b[7m> ${clip(o)}\x1b[0m` : `  ${clip(o)}`))
+      .join('\n') +
+    '\n' +
+    `\x1b[2m  ${MENU_FOOTER}\x1b[0m`;
+  const lineCount = count + 1; // rows + footer
+
+  let rendered = false;
+  const draw = () => {
+    if (rendered) out.write(`\x1b[${lineCount}A`); // back to the top of our block
+    out.write('\r\x1b[0J'); // clear from here to the end of the screen
+    out.write(frame() + '\n');
+    rendered = true;
+  };
+
+  const noop = () => {};
+  return await new Promise((resolve) => {
+    let done = false;
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      stdin.removeListener('data', onData);
+      try {
+        stdin.setRawMode(false);
+      } catch {
+        /* already restored / gone */
+      }
+      stdin.pause();
+      process.off('SIGTTIN', noop);
+      process.off('SIGTTOU', noop);
+      out.write('\x1b[?25h'); // show the cursor again
+      resolve(result);
+    };
+    const onData = (buf) => {
+      const action = menuKey(buf.toString('utf8'), { index, count });
+      if (!action) return;
+      if (action.cancel) return finish({ cancelled: true });
+      if (action.choose !== undefined) return finish({ index: action.choose });
+      if (action.index !== undefined) {
+        index = action.index;
+        draw();
+      }
+    };
+    process.on('SIGTTIN', noop);
+    process.on('SIGTTOU', noop);
+    const timer = setTimeout(() => finish({ timedOut: true }), timeoutMs);
+    try {
+      stdin.setRawMode(true);
+    } catch {
+      return finish({ unsupported: true });
+    }
+    stdin.resume();
+    out.write('\x1b[?25l'); // hide the cursor while we own the block
+    draw();
+    stdin.on('data', onData);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.72.0",
+  "version": "0.73.0",
   "description": "Run your own coding CLIs as build agents for Flowviant — Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {