bitfab-cli 0.2.185 → 0.2.187

package/dist/index.js

@@ -9566,6 +9566,40 @@ function updateActiveStudioSession(updates) {
   writeStateFile(sessionFilePath(), updated);
   return updated;
 }
+function clearActiveStudioSession(sessionId, opts = {}) {
+  try {
+    const current = readStateFile(sessionFilePath());
+    if (!current) {
+      return clearLegacySession(sessionId, opts);
+    }
+    if (current.sessionId !== sessionId) {
+      return false;
+    }
+    if (!opts.force && current.pollerPid != null && current.pollerPid !== process.pid && isProcessAlive(current.pollerPid)) {
+      return false;
+    }
+    fs7.unlinkSync(sessionFilePath());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearLegacySession(sessionId, opts = {}) {
+  try {
+    const raw = fs7.readFileSync(legacyFilePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.sessionId !== sessionId) {
+      return false;
+    }
+    if (!opts.force && typeof parsed.pid === "number" && parsed.pid !== process.pid && isProcessAlive(parsed.pid)) {
+      return false;
+    }
+    fs7.unlinkSync(legacyFilePath());
+    return true;
+  } catch {
+    return false;
+  }
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -11003,6 +11037,48 @@ async function resolveChannel(apiKey, serviceUrl) {
   return new DirectChannel(apiKey, serviceUrl);
 }
 
+// ../bitfab-plugin-lib/dist/studioTeardown.js
+function killStudioWindow(sessionId) {
+  const record2 = readActiveStudioSession();
+  if (record2?.sessionId !== sessionId || record2.windowPid == null) {
+    return;
+  }
+  try {
+    process.kill(record2.windowPid, "SIGTERM");
+  } catch {
+  }
+}
+function killPollerProcess(sessionId) {
+  const record2 = readActiveStudioSession();
+  if (record2?.sessionId !== sessionId || record2.pollerPid == null || record2.pollerPid === process.pid) {
+    return;
+  }
+  try {
+    process.kill(record2.pollerPid, "SIGTERM");
+  } catch {
+  }
+}
+
+// ../bitfab-plugin-lib/dist/commands/clearStudioSession.js
+async function clearStudioSessionById(sessionId, record2) {
+  killStudioWindow(sessionId);
+  const alreadyClosed = record2?.sessionId === sessionId && record2.windowState === "closed";
+  if (!alreadyClosed) {
+    closeStudioWindowsBySession(sessionId);
+  }
+  killPollerProcess(sessionId);
+  try {
+    const channel = await resolveChannel("", record2?.serviceUrl ?? "");
+    try {
+      await channel.clearSession(sessionId);
+    } finally {
+      channel.destroy();
+    }
+  } catch {
+  }
+  return clearActiveStudioSession(sessionId, { force: true });
+}
+
 // ../bitfab-plugin-lib/dist/replayCapabilities.js
 var semver = __toESM(require_semver2(), 1);
 
@@ -11451,6 +11527,13 @@ Already logged in as ${identity}${endpoint}. Run the login command with --force
       return;
     }
   }
+  if (force) {
+    const record2 = readActiveStudioSession();
+    if (record2) {
+      await clearStudioSessionById(record2.sessionId, record2).catch(() => {
+      });
+    }
+  }
   try {
     let printedSignInUrl = false;
     const result = await openStudioTo("/studio", {
@@ -11495,7 +11578,7 @@ ${greeting}`);
   } catch (err) {
     if (exitOnComplete) {
       if (err instanceof StudioNavigationError && err.staleSessionId) {
-        console.error("\nA Studio window is recorded as open but is not responding. Close it (or run the clearStudioSession command), then try again.");
+        console.error("\nA Studio window is recorded as open but is not responding. Close the Studio window and try again. To force-clear a stale session, a user can re-run with `bitfab login --force` (manual recovery - automated agents should not run it).");
       } else {
         console.error(`
 ${err.message}`);
@@ -30999,6 +31082,16 @@ var SETUP_COMMAND = "/bitfab:setup";
 var ANALYZE_REPO_COMMAND = "/bitfab:setup analyze-repo";
 var ASSISTANT_COMMAND = "/bitfab:assistant";
 var UPDATE_COMMAND = "/bitfab:update";
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  red: "\x1B[31m"
+};
 function isClaudeAuthStatusLoggedIn(output) {
   try {
     const status = JSON.parse(output);
@@ -31016,6 +31109,12 @@ var checkClaudeAuth = makeCliAuthCheck({
 });
 function runClaudeInstall() {
   const s = p3.spinner();
+  const localPluginKey = activeLocalClaudeBitfabPlugin();
+  if (localPluginKey !== null) {
+    p3.log.step(`Local Bitfab plugin already enabled (${localPluginKey})`);
+    p3.log.success("Bitfab plugin ready in Claude Code");
+    return;
+  }
   s.start("Adding bitfab marketplace");
   const marketplaceOut = runCli(CLI, ["plugin", "marketplace", "add", REPO]);
   if (marketplaceOut.includes("already")) {
@@ -31046,6 +31145,37 @@ function runClaudeInstall() {
   }
   p3.log.success("Bitfab plugin ready in Claude Code");
 }
+function activeLocalClaudeBitfabPlugin() {
+  const settingsPath = path17.join(
+    process.cwd(),
+    ".claude",
+    "settings.local.json"
+  );
+  if (!fs20.existsSync(settingsPath)) {
+    return null;
+  }
+  let settings;
+  try {
+    settings = JSON.parse(fs20.readFileSync(settingsPath, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (typeof settings !== "object" || settings === null) {
+    return null;
+  }
+  const enabledPlugins = settings.enabledPlugins;
+  if (typeof enabledPlugins !== "object" || enabledPlugins === null) {
+    return null;
+  }
+  for (const [key, enabled] of Object.entries(
+    enabledPlugins
+  )) {
+    if (key.startsWith("bitfab@") && key !== PLUGIN_KEY && enabled === true) {
+      return key;
+    }
+  }
+  return null;
+}
 function pullLatestClaudePlugin() {
   runCli(CLI, ["plugin", "marketplace", "update", MARKETPLACE]);
   return runCli(CLI, ["plugin", "update", PLUGIN_KEY, "--scope", "user"]);
@@ -31140,10 +31270,18 @@ async function runClaudeAnalyzeRepo(captureOverride, limit, prompt) {
         `analyze-repo exited with status ${exitCode}. See ${logPath}`
       );
     }
-    const uploaded = countUploadedTracePlans(stdoutChunks.join(""));
+    const logText = stdoutChunks.join("");
+    const uploaded = countUploadedTracePlans(logText);
     spinner6.stop(
       uploaded === 0 ? "No AI workflows found - nothing to upload" : `Uploaded ${uploaded} draft trace plan${uploaded === 1 ? "" : "s"} to Bitfab`
     );
+    const report = extractAnalyzeRepoReport(logText);
+    if (report !== null) {
+      process.stdout.write(`
+${formatAnalyzeRepoReport(report)}
+
+`);
+    }
   } catch (err) {
     spinner6.stop("analyze-repo failed");
     throw err;
@@ -31153,6 +31291,557 @@ async function runClaudeAnalyzeRepo(captureOverride, limit, prompt) {
   }
   p3.log.info(`Full run log: ${logPath}`);
 }
+function extractAnalyzeRepoReport(logText) {
+  let lastAssistantText = null;
+  let lastSubstantiveReport = null;
+  let lastResultText = null;
+  for (const line of logText.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    for (const assistantText of textCandidatesFromEvent(event)) {
+      if (uploadedHeadingFromLine(assistantText) === null) {
+        continue;
+      }
+      lastAssistantText = assistantText;
+      lastSubstantiveReport = extractSubstantiveAnalyzeRepoReport(assistantText) ?? lastSubstantiveReport;
+    }
+    const resultText = resultTextFromEvent(event);
+    if (resultText !== null && uploadedHeadingFromLine(resultText) !== null) {
+      lastResultText = resultText;
+    }
+  }
+  return lastSubstantiveReport ?? lastAssistantText ?? lastResultText;
+}
+function extractSubstantiveAnalyzeRepoReport(text) {
+  const lines = text.trim().split(/\r?\n/);
+  const tableStart = lines.findIndex((line, index) => {
+    const next = lines[index + 1];
+    return isMarkdownTableRow(line) && next !== void 0 && isTableDivider(next);
+  });
+  if (tableStart === -1) {
+    return null;
+  }
+  const headingIndex = lines.findIndex((line, index) => {
+    return index <= tableStart && uploadedHeadingFromLine(line) !== null;
+  });
+  if (headingIndex === -1) {
+    return null;
+  }
+  let tableEnd = tableStart + 2;
+  while (tableEnd < lines.length && isMarkdownTableRow(lines[tableEnd])) {
+    tableEnd++;
+  }
+  const heading = uploadedHeadingFromLine(lines[headingIndex]);
+  if (heading === null) {
+    return null;
+  }
+  const followUp = usefulAnalyzeRepoFollowUp(lines.slice(tableEnd));
+  return [heading, "", ...lines.slice(tableStart, tableEnd), ...followUp].join("\n").trim();
+}
+function formatAnalyzeRepoReport(report, options = {}) {
+  const style = createAnalyzeRepoReportStyle(options);
+  const lines = report.trim().split(/\r?\n/);
+  const tableStart = lines.findIndex((line, index) => {
+    const next = lines[index + 1];
+    return isMarkdownTableRow(line) && next !== void 0 && isTableDivider(next);
+  });
+  if (tableStart === -1) {
+    return styleNonTableReport(hideTracePlanLinks(report.trim()), style);
+  }
+  const headers = splitMarkdownTableRow(lines[tableStart]);
+  const fieldValuePlan = formatFieldValuePlanTable(lines, tableStart, style);
+  if (fieldValuePlan !== null) {
+    return fieldValuePlan;
+  }
+  const indexes = {
+    key: findColumnIndex(headers, ["trace function key", "function", "key"]),
+    boundary: findColumnIndex(headers, ["boundary"]),
+    description: findColumnIndex(headers, [
+      "description of workflow",
+      "workflow description",
+      "description"
+    ]),
+    frameworksUsed: findColumnIndex(headers, ["frameworks used", "frameworks"]),
+    refactorComplexity: findColumnIndex(headers, [
+      "refactor complexity to instrument",
+      "refactor complexity",
+      "complexity"
+    ]),
+    methodsToCapture: findColumnIndex(headers, [
+      "suggested methods to capture",
+      "suggested methods to captured",
+      "methods to capture",
+      "methods captured"
+    ]),
+    methodsToMock: findColumnIndex(headers, [
+      "number of methods that need to mocked",
+      "number of methods that need to be mocked",
+      "methods that need to be mocked",
+      "methods to mock",
+      "mocked methods"
+    ]),
+    realDataImprovement: findColumnIndex(headers, [
+      "real data",
+      "feature would improve",
+      "improvement",
+      "why",
+      "worth tracing",
+      "rationale"
+    ])
+  };
+  if (indexes.key === -1) {
+    return styleNonTableReport(hideTracePlanLinks(report.trim()), style);
+  }
+  let tableEnd = tableStart + 2;
+  while (tableEnd < lines.length && isMarkdownTableRow(lines[tableEnd])) {
+    tableEnd++;
+  }
+  const rows = lines.slice(tableStart + 2, tableEnd).map(splitMarkdownTableRow).filter((columns) => columns.length > indexes.key);
+  if (rows.length === 0) {
+    return styleNonTableReport(hideTracePlanLinks(report.trim()), style);
+  }
+  const before = lines.slice(0, tableStart).join("\n").trim();
+  const after = formatTrailingReportBlock(lines.slice(tableEnd), style);
+  const formattedRows = rows.map(
+    (columns, index) => formatPlanRow(style, index + 1, {
+      key: columns[indexes.key] ?? "",
+      boundary: indexes.boundary === -1 ? "" : columns[indexes.boundary] ?? "",
+      description: indexes.description === -1 ? "" : columns[indexes.description] ?? "",
+      frameworksUsed: indexes.frameworksUsed === -1 ? "" : columns[indexes.frameworksUsed] ?? "",
+      refactorComplexity: indexes.refactorComplexity === -1 ? "" : columns[indexes.refactorComplexity] ?? "",
+      methodsToCapture: indexes.methodsToCapture === -1 ? "" : columns[indexes.methodsToCapture] ?? "",
+      methodsToMock: indexes.methodsToMock === -1 ? "" : columns[indexes.methodsToMock] ?? "",
+      realDataImprovement: indexes.realDataImprovement === -1 ? "" : columns[indexes.realDataImprovement] ?? ""
+    })
+  ).join("\n\n");
+  return hideTracePlanLinks(
+    [styleReportBlock(before, style), formattedRows, after].filter((part) => part !== "").join("\n\n")
+  );
+}
+function formatPlanRow(style, number4, fields) {
+  const lines = [
+    `${number4}. ${style.bold(style.cyan(cleanInline(fields.key)))}`
+  ];
+  if (fields.description !== "") {
+    lines.push(formatLabeledLine(style, "Workflow", fields.description));
+  }
+  if (fields.boundary !== "") {
+    lines.push(formatLabeledLine(style, "Boundary", fields.boundary));
+  }
+  if (fields.frameworksUsed !== "") {
+    lines.push(formatLabeledLine(style, "Uses", fields.frameworksUsed));
+  }
+  const captureParts = [
+    fields.refactorComplexity === "" ? "" : instrumentationComplexityLabel(style, fields.refactorComplexity),
+    fields.methodsToCapture === "" ? "" : `Methods: ${fields.methodsToCapture}`
+  ].filter((part) => part !== "");
+  if (captureParts.length > 0) {
+    lines.push(
+      formatLabeledLine(style, "Instrumentation", captureParts.join(". "))
+    );
+  }
+  const replayParts = [
+    fields.methodsToMock === "" ? "" : mockReplayLabel(fields.methodsToMock)
+  ].filter((part) => part !== "");
+  if (replayParts.length > 0) {
+    lines.push(formatLabeledLine(style, "Mocks", replayParts.join(". ")));
+  }
+  if (fields.realDataImprovement !== "") {
+    lines.push(formatLabeledLine(style, "Value", fields.realDataImprovement));
+  }
+  return lines.join("\n");
+}
+function mockReplayLabel(value) {
+  const trimmed = value.trim();
+  const countWithNames = trimmed.match(/^(\d+)\s*\((.+)\)$/);
+  if (countWithNames) {
+    return `${mockCountLabel(countWithNames[1])}: ${countWithNames[2]}`;
+  }
+  const countWithDetails = trimmed.match(/^(\d+)\s*[:—-]\s*(.+)$/);
+  if (countWithDetails) {
+    return `${mockCountLabel(countWithDetails[1])}: ${countWithDetails[2]}`;
+  }
+  return /^\d+$/.test(trimmed) ? mockCountLabel(trimmed) : trimmed;
+}
+function mockCountLabel(count) {
+  return `${count} method${count === "1" ? "" : "s"} mocked on replay`;
+}
+function styleInlineValue(value, style) {
+  const parts = value.split(/(`[^`]+`)/g);
+  return parts.map((part) => {
+    if (part.startsWith("`") && part.endsWith("`")) {
+      return style.cyan(part.slice(1, -1));
+    }
+    return cleanInline(part);
+  }).join("");
+}
+function cleanInline(value) {
+  return value.replace(/[`*_]/g, "");
+}
+function formatFieldValuePlanTable(lines, tableStart, style) {
+  const headers = splitMarkdownTableRow(lines[tableStart]).map(
+    (header) => normalizeMarkdownText(header)
+  );
+  if (headers.length !== 2 || headers[0] !== "field" || headers[1] !== "value" && headers[1] !== "detail") {
+    return null;
+  }
+  let tableEnd = tableStart + 2;
+  while (tableEnd < lines.length && isMarkdownTableRow(lines[tableEnd])) {
+    tableEnd++;
+  }
+  const values = /* @__PURE__ */ new Map();
+  for (const row of lines.slice(tableStart + 2, tableEnd)) {
+    const [field, value] = splitMarkdownTableRow(row);
+    if (field === void 0 || value === void 0) {
+      continue;
+    }
+    values.set(normalizeMarkdownText(field), value);
+  }
+  const key = firstFieldValue(values, [
+    "trace function key",
+    "trace function",
+    "function",
+    "key"
+  ]);
+  if (key === "") {
+    return null;
+  }
+  return hideTracePlanLinks(
+    [
+      styleReportBlock(lines.slice(0, tableStart).join("\n").trim(), style),
+      formatPlanRow(style, 1, {
+        key,
+        boundary: firstFieldValue(values, ["boundary"]),
+        description: firstFieldValue(values, [
+          "workflow",
+          "description of workflow",
+          "workflow description",
+          "description"
+        ]),
+        frameworksUsed: firstFieldValue(values, [
+          "frameworks used",
+          "frameworks"
+        ]),
+        refactorComplexity: firstFieldValue(values, [
+          "refactor complexity to instrument",
+          "refactor complexity",
+          "complexity"
+        ]),
+        methodsToCapture: firstFieldValue(values, [
+          "suggested methods to capture",
+          "suggested methods to captured",
+          "methods to capture",
+          "methods captured"
+        ]),
+        methodsToMock: firstFieldValue(values, [
+          "methods to mock on replay",
+          "number of methods that need to mocked",
+          "number of methods that need to be mocked",
+          "methods that need to be mocked",
+          "methods to mock",
+          "mocked methods"
+        ]),
+        realDataImprovement: firstFieldValue(values, [
+          "how real data improves this",
+          "value of running real data through it",
+          "real data",
+          "feature would improve",
+          "improvement",
+          "why",
+          "worth tracing",
+          "rationale"
+        ])
+      }),
+      formatTrailingReportBlock(lines.slice(tableEnd), style)
+    ].filter((part) => part !== "").join("\n\n")
+  );
+}
+function firstFieldValue(values, fields) {
+  for (const field of fields) {
+    const value = values.get(field);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return "";
+}
+function createAnalyzeRepoReportStyle(options) {
+  const enabled = options.color ?? (process.stdout.isTTY === true && process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb");
+  const wrap = (code, text) => enabled ? `${code}${text}${ANSI.reset}` : text;
+  return {
+    enabled,
+    bold: (text) => wrap(ANSI.bold, text),
+    dim: (text) => wrap(ANSI.dim, text),
+    green: (text) => wrap(ANSI.green, text),
+    yellow: (text) => wrap(ANSI.yellow, text),
+    cyan: (text) => wrap(ANSI.cyan, text),
+    magenta: (text) => wrap(ANSI.magenta, text),
+    red: (text) => wrap(ANSI.red, text),
+    width: normalizeReportWidth(
+      options.width ?? (process.stdout.isTTY === true ? process.stdout.columns : void 0)
+    )
+  };
+}
+function formatLabeledLine(style, label, value) {
+  const prefix = `   - ${style.dim(`${label}:`)} `;
+  const continuationPrefix = "     ";
+  return wrapStyledLine(
+    `${prefix}${styleInlineValue(value, style)}`,
+    prefixVisibleLength(label),
+    continuationPrefix,
+    style.width
+  );
+}
+function prefixVisibleLength(label) {
+  return `   - ${label}: `.length;
+}
+function normalizeReportWidth(width) {
+  if (width === void 0 || !Number.isFinite(width) || width <= 0) {
+    return 1e4;
+  }
+  return Math.max(48, Math.min(110, Math.floor(width)));
+}
+function wrapStyledLine(line, firstPrefixLength, continuationPrefix, width) {
+  if (visibleLength(line) <= width) {
+    return line;
+  }
+  const segments = ansiSegments(line);
+  const out = [];
+  let current = "";
+  let currentVisible = 0;
+  let limit = width;
+  for (const segment of segments) {
+    if (segment.visible === 0) {
+      current += segment.text;
+      continue;
+    }
+    const words = segment.text.split(/(\s+)/);
+    for (const word of words) {
+      if (word === "") {
+        continue;
+      }
+      const wordVisible = visibleLength(word);
+      const isSpace = /^\s+$/.test(word);
+      if (currentVisible > firstPrefixLength && currentVisible + wordVisible > limit && !isSpace) {
+        out.push(current.trimEnd());
+        current = continuationPrefix;
+        currentVisible = continuationPrefix.length;
+        limit = width;
+      }
+      if (!(currentVisible === continuationPrefix.length && isSpace)) {
+        current += word;
+        currentVisible += wordVisible;
+      }
+    }
+  }
+  if (current.trim() !== "") {
+    out.push(current.trimEnd());
+  }
+  return out.join("\n");
+}
+function visibleLength(text) {
+  return ansiSegments(text).reduce((sum, segment) => sum + segment.visible, 0);
+}
+function ansiSegments(text) {
+  const segments = [];
+  let index = 0;
+  while (index < text.length) {
+    const escapeIndex = text.indexOf("\x1B[", index);
+    if (escapeIndex === -1) {
+      const plain = text.slice(index);
+      segments.push({ text: plain, visible: plain.length });
+      break;
+    }
+    if (escapeIndex > index) {
+      const plain = text.slice(index, escapeIndex);
+      segments.push({ text: plain, visible: plain.length });
+    }
+    const endIndex = text.indexOf("m", escapeIndex);
+    if (endIndex === -1) {
+      const plain = text.slice(escapeIndex);
+      segments.push({ text: plain, visible: plain.length });
+      break;
+    }
+    segments.push({ text: text.slice(escapeIndex, endIndex + 1), visible: 0 });
+    index = endIndex + 1;
+  }
+  return segments;
+}
+function usefulAnalyzeRepoFollowUp(lines) {
+  const useful = [];
+  let includeSkipped = false;
+  for (const rawLine of lines) {
+    const line = rawLine.trimEnd();
+    const normalized = normalizeMarkdownText(line);
+    if (line.trim() === "") {
+      if (useful.length > 0 && useful[useful.length - 1] !== "") {
+        useful.push("");
+      }
+      continue;
+    }
+    if (normalized === "skipped") {
+      useful.push(line);
+      includeSkipped = true;
+      continue;
+    }
+    if (includeSkipped && line.trim().startsWith("- ")) {
+      useful.push(line);
+      continue;
+    }
+    includeSkipped = false;
+  }
+  while (useful[useful.length - 1] === "") {
+    useful.pop();
+  }
+  return useful.length === 0 ? [] : ["", ...useful];
+}
+function formatTrailingReportBlock(lines, style) {
+  return styleReportBlock(
+    usefulAnalyzeRepoFollowUp(lines).join("\n").trim(),
+    style
+  );
+}
+function instrumentationComplexityLabel(style, raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "none" || normalized.startsWith("none ")) {
+    return `${style.green("no refactor")}${raw.trim().slice(4)}`;
+  }
+  if (normalized === "low" || normalized.startsWith("low ")) {
+    return `${style.green("low effort")}${raw.trim().slice(3)}`;
+  }
+  if (normalized === "med" || normalized === "medium") {
+    return style.yellow("medium effort");
+  }
+  if (normalized.startsWith("med ") || normalized.startsWith("medium ")) {
+    return `${style.yellow("medium effort")}${raw.trim().replace(/^medium|^med/i, "")}`;
+  }
+  if (normalized === "high" || normalized.startsWith("high ")) {
+    return `${style.red("high effort")}${raw.trim().slice(4)}`;
+  }
+  return raw;
+}
+function styleReportBlock(block, style) {
+  if (block === "") {
+    return "";
+  }
+  return block.split(/\r?\n/).map((line) => styleReportLine(line, style)).join("\n");
+}
+function styleNonTableReport(report, style) {
+  return report.split(/\r?\n/).map((line) => styleReportLine(line, style)).join("\n");
+}
+function styleReportLine(line, style) {
+  const heading = uploadedHeadingFromLine(line);
+  if (heading !== null) {
+    return style.bold(style.green(heading));
+  }
+  if (line.trim() === "Skipped") {
+    return style.bold(style.yellow(line));
+  }
+  if (line.startsWith("- ")) {
+    return style.yellow(styleInlineValue(line, style));
+  }
+  if (line.startsWith("These are draft")) {
+    return style.dim(styleInlineValue(line, style));
+  }
+  return styleInlineValue(line, style);
+}
+function uploadedHeadingFromLine(line) {
+  const normalized = line.replace(/[`*_]/g, "").trim();
+  const match = normalized.match(/Uploaded \d+ draft trace plans?/i);
+  return match?.[0] ?? null;
+}
+function hideTracePlanLinks(report) {
+  return report.split(/\r?\n/).map(
+    (line) => line.replace(
+      /\[([^\]]+)\]\(https:\/\/bitfab\.ai\/studio\/trace-plan\/[^\s)]+\)/g,
+      "$1"
+    ).replace(/https:\/\/bitfab\.ai\/studio\/trace-plan\/\S+/g, "").trimEnd()
+  ).filter((line) => !/^\s*(plan|plan url):\s*$/i.test(line)).join("\n").trim();
+}
+function findColumnIndex(headers, needles) {
+  return headers.findIndex((header) => {
+    const normalized = normalizeMarkdownText(header);
+    return needles.some((needle) => normalized.includes(needle));
+  });
+}
+function normalizeMarkdownText(text) {
+  return text.replace(/[`*_]/g, "").replace(/\s+/g, " ").trim().toLowerCase();
+}
+function isMarkdownTableRow(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|");
+}
+function isTableDivider(line) {
+  const cells = splitMarkdownTableRow(line);
+  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell.replace(/\s/g, "")));
+}
+function splitMarkdownTableRow(line) {
+  return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+}
+function assistantTextFromEvent(event) {
+  const content = eventMessageContent(event);
+  if (!content) {
+    return null;
+  }
+  const blocks = [];
+  for (const block of content) {
+    if (typeof block !== "object" || block === null) {
+      continue;
+    }
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      blocks.push(b.text);
+    }
+  }
+  const text = blocks.join("\n").trim();
+  return text === "" ? null : text;
+}
+function textCandidatesFromEvent(event) {
+  const candidates = [];
+  const assistantText = assistantTextFromEvent(event);
+  if (assistantText !== null) {
+    candidates.push(assistantText);
+  }
+  for (const text of stringValuesFromUnknown(event)) {
+    const trimmed = text.trim();
+    if (trimmed !== "" && !candidates.includes(trimmed) && !candidates.some((candidate) => candidate.includes(trimmed))) {
+      candidates.push(trimmed);
+    }
+  }
+  return candidates;
+}
+function stringValuesFromUnknown(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap(stringValuesFromUnknown);
+  }
+  if (typeof value !== "object" || value === null) {
+    return [];
+  }
+  return Object.values(value).flatMap(
+    stringValuesFromUnknown
+  );
+}
+function resultTextFromEvent(event) {
+  if (typeof event !== "object" || event === null) {
+    return null;
+  }
+  const e = event;
+  if (e.type !== "result" || typeof e.result !== "string") {
+    return null;
+  }
+  const text = e.result.trim();
+  return text === "" ? null : text;
+}
 function latestActivityLabel(chunk2) {
   const lines = chunk2.split("\n").filter((l) => l.trim() !== "");
   for (let i = lines.length - 1; i >= 0; i--) {
@@ -31463,10 +32152,18 @@ async function runCodexAnalyzeRepo(captureOverride, limit, prompt) {
         `analyze-repo exited with status ${exitCode}. See ${logPath}`
       );
     }
-    const uploaded = countUploadedTracePlans2(stdoutChunks.join(""));
+    const logText = stdoutChunks.join("");
+    const uploaded = countUploadedTracePlans2(logText);
     spinner6.stop(
       uploaded === 0 ? "No AI workflows found - nothing to upload" : `Uploaded ${uploaded} draft trace plan${uploaded === 1 ? "" : "s"} to Bitfab`
     );
+    const report = extractAnalyzeRepoReport(logText);
+    if (report !== null) {
+      process.stdout.write(`
+${formatAnalyzeRepoReport(report)}
+
+`);
+    }
   } catch (err) {
     spinner6.stop("analyze-repo failed");
     throw err;
@@ -31834,10 +32531,18 @@ async function runCursorAnalyzeRepo(captureOverride, limit, prompt) {
         `analyze-repo exited with status ${exitCode}. See ${logPath}`
       );
     }
-    const uploaded = countUploadedTracePlans3(stdoutChunks.join(""));
+    const logText = stdoutChunks.join("");
+    const uploaded = countUploadedTracePlans3(logText);
     spinner6.stop(
       uploaded === 0 ? "No AI workflows found - nothing to upload" : `Uploaded ${uploaded} draft trace plan${uploaded === 1 ? "" : "s"} to Bitfab`
     );
+    const report = extractAnalyzeRepoReport(logText);
+    if (report !== null) {
+      process.stdout.write(`
+${formatAnalyzeRepoReport(report)}
+
+`);
+    }
   } catch (err) {
     spinner6.stop("analyze-repo failed");
     throw err;
@@ -32382,7 +33087,7 @@ var GLOBAL_HELP_TEXT = `Usage: bitfab <command> [options]
 Commands:
   init [--editor <name>]              Full onboarding: plugin-install, login, and setup
   plugin-install [--editor <name>]    Install the Bitfab plugin in one editor
-  login                               Authenticate with Bitfab (opens browser)
+  login [--force]                     Authenticate with Bitfab (opens browser)
   logout                              Remove stored credentials
   session-logs [status|enable|disable] Read or update session log collection
   setup [--editor <name>]             Launch /bitfab:setup in the editor
@@ -32399,6 +33104,7 @@ Options:
   --no-upload-logs       analyze-repo: keep session logs local (skips the prompt)
   --limit <n>            analyze-repo: cap how many draft trace plans to upload (default 5)
   --prompt, -p <text>    analyze-repo: free-text guidance steering what to focus on
+  --force                login: re-authenticate and clear any stale Studio session first
 
 Examples:
   bitfab init                              Full setup (detect editor, install, login, setup)
@@ -32406,6 +33112,7 @@ Examples:
   bitfab analyze-repo                      Scan the repo and upload draft trace plans (headless)
   bitfab analyze-repo --limit 3            Scan the repo and upload at most 3 draft trace plans
   bitfab analyze-repo "focus on billing"   Scan with free-text guidance on what to prioritize
+  bitfab login --force                     Re-authenticate and clear a stale Studio session
   bitfab session-logs enable               Enable session log collection
   bitfab session-logs disable              Disable session log collection
   bitfab assistant investigate             Investigate traces
@@ -32438,15 +33145,16 @@ Examples:
   bitfab plugin-install
   bitfab plugin-install --editor cursor
 `,
-  login: `Usage: bitfab login
+  login: `Usage: bitfab login [--force]
 
 Authenticate with Bitfab in the browser and save credentials locally.
 
 Options:
-  This command has no options.
+  --force    Re-authenticate even when already signed in, and clear any stale Studio session first
 
 Examples:
   bitfab login
+  bitfab login --force
 `,
   logout: `Usage: bitfab logout
 
@@ -32608,7 +33316,7 @@ function wantsHelp(argv) {
 var COMMAND_SPECS = {
   init: { flags: ["editor", "skipPermissions"], unknownOption: "error" },
   "plugin-install": { flags: ["editor"], unknownOption: "error" },
-  login: { flags: [], unknownOption: "error" },
+  login: { flags: ["force"], unknownOption: "error" },
   logout: { flags: [], unknownOption: "error" },
   "session-logs": { flags: [], unknownOption: "error" },
   setup: { flags: ["editor", "skipPermissions"], unknownOption: "error" },
@@ -32682,6 +33390,12 @@ function applyFlag(key, token, next, values) {
         return 1;
       }
       return null;
+    case "force":
+      if (token === "--force") {
+        values.force = true;
+        return 1;
+      }
+      return null;
   }
 }
 function parseArgs2(argv) {
@@ -32728,6 +33442,7 @@ function parseArgs2(argv) {
     uploadLogs: values.uploadLogs,
     limit: values.limit,
     prompt: values.prompt,
+    force: values.force,
     rest
   };
 }
@@ -32747,7 +33462,16 @@ ${GLOBAL_HELP_TEXT}`
     process.stdout.write(helpText);
     return;
   }
-  const { command, editor, skipPermissions, uploadLogs, limit, prompt, rest } = parseArgs2(argv);
+  const {
+    command,
+    editor,
+    skipPermissions,
+    uploadLogs,
+    limit,
+    prompt,
+    force,
+    rest
+  } = parseArgs2(argv);
   const abortUpdateCheck = startUpdateCheck();
   if (command === "init") {
     await runInit({ editor, skipPermissions });
@@ -32760,7 +33484,7 @@ ${GLOBAL_HELP_TEXT}`
     return;
   }
   if (command === "login") {
-    await runLoginCommand();
+    await runLoginCommand({ force });
     abortUpdateCheck();
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bitfab-cli",
-  "version": "0.2.185",
+  "version": "0.2.187",
   "description": "Install and configure the Bitfab plugin in Claude Code, Codex, or Cursor.",
   "type": "module",
   "main": "dist/index.js",