flowviant 0.20.0 → 0.22.0

package/bin/lib/claude.mjs

@@ -199,13 +199,100 @@ export function mcpConfigFor(token, mcpUrl) {
   return { dir, path: p };
 }
 
+// Shorten an absolute tool path to a repo-relative one for legible output.
+const shortPath = (p, cwd) => {
+  if (typeof p !== 'string') return '';
+  let s = p;
+  if (cwd && s.startsWith(cwd)) s = s.slice(cwd.length).replace(/^\/+/, '');
+  return s;
+};
+
+// Turn one Claude tool_use into a compact activity {kind, label}, or null for
+// tools not worth surfacing. `kind:'read'` is what the file counter counts;
+// an emit_wiki_node flips the phase to "writing". Used by wiki turns to stream
+// exactly which files Claude is touching (daemon console + app cover).
+export function humanizeToolUse(name, input = {}, cwd = '') {
+  switch (name) {
+    case 'Read':
+      return { kind: 'read', label: `read ${shortPath(input.file_path, cwd)}` };
+    case 'Grep':
+      return {
+        kind: 'search',
+        label: `grep ${JSON.stringify(input.pattern ?? '')}${input.path ? ` in ${shortPath(input.path, cwd)}` : ''}`,
+      };
+    case 'Glob':
+      return { kind: 'glob', label: `glob ${input.pattern ?? ''}` };
+    case 'LS':
+      return { kind: 'list', label: `ls ${shortPath(input.path ?? '.', cwd)}` };
+    case 'Bash':
+      return { kind: 'bash', label: `$ ${String(input.command ?? '').replace(/\s+/g, ' ').slice(0, 60)}` };
+    default:
+      if (typeof name !== 'string') return null;
+      if (name.includes('emit_wiki_node')) return { kind: 'write', label: `+ node ${input.id ?? ''}` };
+      if (name.includes('finish_wiki_generation')) return { kind: 'write', label: 'finalize wiki' };
+      if (name.includes('list_wiki_nodes')) return { kind: 'mcp', label: 'list wiki nodes' };
+      return null; // other tools: silent
+  }
+}
+
+// Collapse whitespace + clip so a narration/thinking snippet is one tidy feed line.
+const oneLine = (s, n = 160) => String(s).replace(/\s+/g, ' ').trim().slice(0, n);
+
+// Parse ONE line of `--output-format stream-json` NDJSON into feed activities.
+// Surfaces the WHOLE turn — thinking, narration, AND every tool — so neither the
+// daemon console nor the app cover goes dark while Claude reasons (Opus thinks in
+// bursts before/between tools; emitting only tools left long silent gaps).
+// Assistant text is also folded into `out` so the WIKI_DONE/REGROUND_DONE
+// sentinels still match. A non-JSON line (a stray warning) is kept as raw text.
+function handleStreamLine(line, { cwd, emit, onActivity, appendText }) {
+  let ev;
+  try {
+    ev = JSON.parse(line);
+  } catch {
+    appendText(line + '\n');
+    emit(line + '\n');
+    return;
+  }
+  const push = (a) => {
+    if (!a || !a.label) return;
+    emit(a.label + '\n');
+    onActivity?.(a);
+  };
+  if (ev.type === 'assistant' && Array.isArray(ev.message?.content)) {
+    for (const b of ev.message.content) {
+      if (b.type === 'thinking' || b.type === 'redacted_thinking') {
+        // The `thinking` text is usually redacted (signature only), so emit a
+        // marker — enough to show Claude is actively reasoning, not hung.
+        push({ kind: 'think', label: b.thinking ? `thinking: ${oneLine(b.thinking)}` : 'thinking…' });
+      } else if (b.type === 'text' && b.text?.trim()) {
+        appendText(b.text + '\n');
+        push({ kind: 'say', label: oneLine(b.text) });
+      } else if (b.type === 'tool_use') {
+        push(humanizeToolUse(b.name, b.input || {}, cwd));
+      }
+    }
+  } else if (ev.type === 'result' && typeof ev.result === 'string') {
+    // The final assistant text (carries WIKI_DONE / REGROUND_DONE).
+    appendText(ev.result + '\n');
+  }
+}
+
 // One Claude Code turn. Output is captured (for sentinel detection) and streamed
 // through, line-prefixed with the worker label so a fleet stays legible.
-export function runTurn({ prompt, resume, system, cwd, mcpConfig, label, onSpawn }) {
+//
+// `streamJson` switches to `--output-format stream-json` and parses the event
+// stream: only the humanized tool activity reaches the console (a legible
+// stream of `read …`, `grep …`, `+ node …`), assistant text is folded into the
+// returned string for sentinel detection, and each activity is handed to
+// `onActivity` so the caller can forward progress. Build-agent turns leave it
+// off and keep the raw text passthrough + line sentinels.
+export function runTurn({ prompt, resume, system, cwd, mcpConfig, label, onSpawn, streamJson, onActivity }) {
   return new Promise((resolve) => {
     const args = [];
     if (resume) args.push('--continue');
-    args.push('-p', prompt, '--mcp-config', mcpConfig, '--append-system-prompt', system, ...PERM);
+    args.push('-p', prompt, '--mcp-config', mcpConfig, '--append-system-prompt', system);
+    if (streamJson) args.push('--output-format', 'stream-json', '--verbose');
+    args.push(...PERM);
     // Force the user's Claude Code subscription — never the API. A key exported in
     // the shell would otherwise silently bill every poll-mode turn as raw API
     // usage (same invariant live mode enforces on its SDK session env).
@@ -216,10 +303,47 @@ export function runTurn({ prompt, resume, system, cwd, mcpConfig, label, onSpawn
     onSpawn?.(child);
     let out = '';
     const pfx = label ? `${label} ` : '';
+    const emit = (s) => process.stdout.write(pfx ? s.replace(/\n/g, `\n${pfx}`) : s);
+
+    if (streamJson) {
+      let buf = '';
+      const appendText = (t) => {
+        out += t;
+      };
+      child.stdout.on('data', (d) => {
+        buf += d.toString();
+        let nl;
+        while ((nl = buf.indexOf('\n')) >= 0) {
+          const line = buf.slice(0, nl);
+          buf = buf.slice(nl + 1);
+          if (line.trim()) handleStreamLine(line, { cwd, emit, onActivity, appendText });
+        }
+      });
+      // stderr is not JSON (warnings/errors) — pass through and keep for sentinels.
+      child.stderr.on('data', (d) => {
+        const s = d.toString();
+        out += s;
+        emit(s);
+      });
+      child.on('error', (e) => {
+        if (e.code === 'ENOENT') {
+          console.error("\nerror: 'claude' CLI not found on PATH. Install Claude Code first.");
+          process.exit(1);
+        }
+        console.error(e);
+        resolve(out);
+      });
+      child.on('close', () => {
+        if (buf.trim()) handleStreamLine(buf, { cwd, emit, onActivity, appendText });
+        resolve(out);
+      });
+      return;
+    }
+
     const onChunk = (d) => {
       const s = d.toString();
       out += s;
-      process.stdout.write(pfx ? s.replace(/\n/g, `\n${pfx}`) : s);
+      emit(s);
     };
     child.stdout.on('data', onChunk);
     child.stderr.on('data', onChunk);

package/bin/lib/config.mjs

@@ -4,7 +4,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-export const VERSION = '0.20.0';
+export const VERSION = '0.22.0';
 
 // Credential stored by `flowviant login` (device auth) — the no-token,
 // no-env-var path. An explicit --fleet flag or FLOWVIANT_FLEET env still wins.

package/bin/lib/fleet.mjs

@@ -400,6 +400,7 @@ export async function runFleetDaemon() {
   const wikiWt = join(baseDir, 'wiki');
   const REGROUND_DONE_URL = FLEET_URL.replace(/\/agents\/?$/, '/reground-done');
   const WIKI_TOKEN_URL = FLEET_URL.replace(/\/agents\/?$/, '/wiki-token');
+  const WIKI_PROGRESS_URL = FLEET_URL.replace(/\/agents\/?$/, '/wiki-progress');
   const wikiQueue = [];
   let wikiBusy = false;
   let lastSweepAt = null; // dedup: run each Regenerate request once
@@ -419,6 +420,30 @@ export async function runFleetDaemon() {
     }
   };
 
+  // Stream what the wiki turn is doing to the app (the canvas renders the read
+  // phase). Throttled to ~1/s — the FIRST activity of a run and the terminal
+  // `done` frame force-send so the cover appears fast and clears cleanly.
+  let lastProgressAt = 0;
+  const postWikiProgress = async (body, force = false) => {
+    const now = Date.now();
+    if (!force && now - lastProgressAt < 600) return;
+    lastProgressAt = now;
+    try {
+      await fetch(WIKI_PROGRESS_URL, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${FLEET_TOKEN}`,
+          'User-Agent': USER_AGENT,
+          'Content-Type': 'application/json',
+        },
+        signal: AbortSignal.timeout(15_000),
+        body: JSON.stringify(body),
+      });
+    } catch {
+      /* best-effort — a dropped frame is harmless, the next one supersedes it */
+    }
+  };
+
   const enqueueSweep = (job) => {
     if (!job || job.requestedAt === lastSweepAt) return;
     lastSweepAt = job.requestedAt;
@@ -461,7 +486,40 @@ export async function runFleetDaemon() {
         }
         const task = wikiQueue.shift();
         const { dir, path: mcpConfig } = mcpConfigFor(token, mcpUrl);
+        // Live progress for this turn: a rolling FEED of everything Claude does
+        // (thinking, narration, reads, node writes), the file count, and the
+        // phase — streamed to the app (throttled; each frame carries the whole
+        // recent tail so a dropped POST loses nothing). elapsedSec is the
+        // daemon's own clock.
+        const mode = task.type === 'sweep' ? 'sweep' : 'reground';
+        const startedAt = Date.now();
+        let filesRead = 0;
+        let phase = 'reading';
+        const feed = [];
+        const frame = (extra) => ({
+          mode,
+          phase,
+          activity: feed[feed.length - 1] ?? '',
+          recent: feed.slice(-24),
+          filesRead,
+          elapsedSec: Math.round((Date.now() - startedAt) / 1000),
+          ...extra,
+        });
+        const onActivity = (a) => {
+          if (a.kind === 'read') filesRead++;
+          if (a.kind === 'write') phase = 'writing';
+          // Collapse runs of bare "thinking…" so the feed doesn't fill with it.
+          if (!(a.label === 'thinking…' && feed[feed.length - 1] === 'thinking…')) {
+            feed.push(a.label);
+            if (feed.length > 48) feed.shift();
+          }
+          void postWikiProgress(frame());
+        };
         try {
+          // Immediate frame so the cover shows the daemon feed right away (the
+          // "reading your code" phase), not a static message, while Claude warms up.
+          feed.push('starting…');
+          await postWikiProgress(frame(), true);
           if (!existsSync(wikiWt)) {
             try {
               git(['worktree', 'add', '--detach', wikiWt, baseRef], repoRoot);
@@ -486,6 +544,8 @@ export async function runFleetDaemon() {
               cwd: wikiWt,
               mcpConfig,
               label: c.cyan('[wiki]'),
+              streamJson: true,
+              onActivity,
             });
             if (sawSentinel(out, 'WIKI_DONE'))
               ok(`${c.cyan('wiki')} ${c.dim('— regenerated from your code.')}`);
@@ -504,6 +564,8 @@ export async function runFleetDaemon() {
                 cwd: wikiWt,
                 mcpConfig,
                 label: c.cyan('[wiki]'),
+                streamJson: true,
+                onActivity,
               });
               if (sawSentinel(out, 'REGROUND_DONE'))
                 ok(`${c.cyan('wiki')} ${c.dim(`— wiki updated for "${task.title}".`)}`);
@@ -518,6 +580,9 @@ export async function runFleetDaemon() {
         } catch (e) {
           warn(`wiki ${task.type} failed: ${e.message}`);
         } finally {
+          // Terminal frame so the app cover clears promptly (don't wait for the
+          // freshness window to lapse). force-sent past the throttle.
+          await postWikiProgress(frame({ done: true }), true);
           rmSync(dir, { recursive: true, force: true });
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Run your own Claude Code as headless build agents for Flowviant — on your own credentials. Claims dispatched work, opens PRs, captures review evidence, and routes questions back to you.",
   "type": "module",
   "bin": {