bitfab-cli 0.2.162 → 0.2.164

package/dist/index.js

@@ -9315,6 +9315,16 @@ function getSessionLogConsentValue() {
   }
   return null;
 }
+function getSessionLogConsent() {
+  return getSessionLogConsentValue();
+}
+function setSessionLogConsent(value) {
+  fs3.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+  const existing = readJsonFile(GLOBAL_CONFIG_FILE) ?? {};
+  existing.sessionLogConsent = value;
+  fs3.writeFileSync(GLOBAL_CONFIG_FILE, `${JSON.stringify(existing, null, 2)}
+`);
+}
 function getConfig() {
   return {
     serviceUrl: getServiceUrl(),
@@ -30739,7 +30749,7 @@ var tracePlanTreeShape = external_exports.object({
 });
 
 // src/claude.ts
-import { spawnSync } from "child_process";
+import { spawn as spawn5, spawnSync } from "child_process";
 import fs20 from "fs";
 import os15 from "os";
 import path17 from "path";
@@ -30748,6 +30758,7 @@ var REPO = "Project-White-Rabbit/bitfab-claude-plugin";
 var MARKETPLACE = "bitfab";
 var PLUGIN_KEY = "bitfab@bitfab";
 var SETUP_COMMAND = "/bitfab:setup";
+var ANALYZE_REPO_COMMAND = "/bitfab:setup analyze-repo";
 var ASSISTANT_COMMAND = "/bitfab:assistant";
 var UPDATE_COMMAND = "/bitfab:update";
 var SHELL_OPTS = process.platform === "win32" ? { shell: true } : {};
@@ -30797,6 +30808,171 @@ function runClaudeSetup(skipPermissions) {
     ...SHELL_OPTS
   });
 }
+async function runClaudeAnalyzeRepo(captureOverride, limit) {
+  const logPath = analyzeRepoLogPath();
+  const env = { ...process.env };
+  if (captureOverride !== void 0) {
+    env.BITFAB_CAPTURE_SESSIONS = captureOverride ? "1" : "0";
+  }
+  const command = limit === void 0 ? ANALYZE_REPO_COMMAND : `${ANALYZE_REPO_COMMAND} limit=${limit}`;
+  const out = fs20.createWriteStream(logPath);
+  const spinner3 = p.spinner();
+  spinner3.start("Analyzing repo and drafting trace plans");
+  const stdoutChunks = [];
+  try {
+    const exitCode = await new Promise((resolve2, reject) => {
+      const child = spawn5(
+        "claude",
+        [
+          "-p",
+          command,
+          "--output-format",
+          "stream-json",
+          "--verbose",
+          "--dangerously-skip-permissions"
+        ],
+        { stdio: ["ignore", "pipe", "pipe"], env, ...SHELL_OPTS }
+      );
+      child.stdout.on("data", (chunk2) => {
+        out.write(chunk2);
+        const text = chunk2.toString();
+        stdoutChunks.push(text);
+        const label = latestActivityLabel(text);
+        if (label) {
+          spinner3.message(label);
+        }
+      });
+      child.stderr.on("data", (chunk2) => out.write(chunk2));
+      child.on("error", reject);
+      child.on("close", (code) => resolve2(code ?? 0));
+    });
+    if (exitCode !== 0) {
+      throw new Error(
+        `analyze-repo exited with status ${exitCode}. See ${logPath}`
+      );
+    }
+    const uploaded = countUploadedTracePlans(stdoutChunks.join(""));
+    spinner3.stop(
+      uploaded === 0 ? "No AI workflows found - nothing to upload" : `Uploaded ${uploaded} draft trace plan${uploaded === 1 ? "" : "s"} to Bitfab`
+    );
+  } catch (err) {
+    spinner3.stop("analyze-repo failed");
+    throw err;
+  } finally {
+    out.end();
+  }
+  p.log.info(`Full run log: ${logPath}`);
+}
+function latestActivityLabel(chunk2) {
+  const lines = chunk2.split("\n").filter((l) => l.trim() !== "");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let event;
+    try {
+      event = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    const label = activityLabelFromEvent(event);
+    if (label) {
+      return label;
+    }
+  }
+  return null;
+}
+function activityLabelFromEvent(event) {
+  const content = eventMessageContent(event);
+  if (!content) {
+    return null;
+  }
+  for (const block of content) {
+    if (typeof block !== "object" || block === null) {
+      continue;
+    }
+    if (block.type !== "tool_use") {
+      continue;
+    }
+    const label = friendlyToolLabel(block);
+    if (label) {
+      return label;
+    }
+  }
+  return null;
+}
+function friendlyToolLabel(block) {
+  const name = typeof block.name === "string" ? block.name : "";
+  if (name.includes("create_trace_plan")) {
+    return "Uploading a draft trace plan";
+  }
+  if (name.includes("get_bitfab_api_key")) {
+    return "Checking authentication";
+  }
+  const input = typeof block.input === "object" && block.input !== null ? block.input : {};
+  switch (name) {
+    case "Read": {
+      const file2 = typeof input.file_path === "string" ? path17.basename(input.file_path) : "";
+      return file2 ? `Reading ${file2}` : "Reading files";
+    }
+    case "Grep":
+    case "Glob":
+      return "Searching the codebase";
+    case "WebFetch":
+      return "Reading SDK docs";
+    default:
+      return null;
+  }
+}
+function eventMessageContent(event) {
+  if (typeof event !== "object" || event === null) {
+    return null;
+  }
+  const message = event.message;
+  const content = typeof message === "object" && message !== null ? message.content : void 0;
+  return Array.isArray(content) ? content : null;
+}
+function countUploadedTracePlans(logText) {
+  const planToolUseIds = /* @__PURE__ */ new Set();
+  const nonErrorResultIds = /* @__PURE__ */ new Set();
+  for (const line of logText.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const content = eventMessageContent(event);
+    if (!content) {
+      continue;
+    }
+    for (const block of content) {
+      if (typeof block !== "object" || block === null) {
+        continue;
+      }
+      const b = block;
+      if (b.type === "tool_use" && typeof b.id === "string" && typeof b.name === "string" && b.name.includes("create_trace_plan")) {
+        planToolUseIds.add(b.id);
+      }
+      if (b.type === "tool_result" && typeof b.tool_use_id === "string" && b.is_error !== true) {
+        nonErrorResultIds.add(b.tool_use_id);
+      }
+    }
+  }
+  let count = 0;
+  for (const id of planToolUseIds) {
+    if (nonErrorResultIds.has(id)) {
+      count++;
+    }
+  }
+  return count;
+}
+function analyzeRepoLogPath() {
+  const dir = path17.join(process.cwd(), ".bitfab", "logs");
+  fs20.mkdirSync(dir, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return path17.join(dir, `analyze-repo-${stamp}.jsonl`);
+}
 function runClaudeAssistant(args, skipPermissions) {
   const cmd = [ASSISTANT_COMMAND, ...args].join(" ");
   p.log.info(`Launching ${cmd}...
@@ -30924,6 +31100,14 @@ function runCodexSetup(skipPermissions) {
     ...SHELL_OPTS2
   });
 }
+function runCodexAnalyzeRepo() {
+  p2.log.warn(
+    "Headless analyze-repo is currently supported for Claude Code only."
+  );
+  p2.log.info(
+    `To run it in Codex, launch ${SETUP_COMMAND2} analyze-repo interactively.`
+  );
+}
 function runCodexAssistant(args, skipPermissions) {
   const cmd = [ASSISTANT_COMMAND2, ...args].join(" ");
   p2.log.info(`Launching ${cmd}...
@@ -31002,7 +31186,7 @@ function escapeRegex2(s) {
 }
 
 // src/cursor.ts
-import { spawn as spawn5, spawnSync as spawnSync3 } from "child_process";
+import { spawn as spawn6, spawnSync as spawnSync3 } from "child_process";
 import os17 from "os";
 import * as p3 from "@clack/prompts";
 var REPO3 = "Project-White-Rabbit/bitfab-cursor-plugin";
@@ -31026,7 +31210,7 @@ function runCursorInstall() {
     "Finish setup in Cursor"
   );
   p3.log.info("Opening Cursor...");
-  const child = spawn5("cursor", ["."], {
+  const child = spawn6("cursor", ["."], {
     stdio: "ignore",
     detached: true,
     windowsHide: true,
@@ -31042,6 +31226,12 @@ function runCursorSetup(skipPermissions) {
   }
   p3.log.info(`To complete setup, run ${SETUP_COMMAND3} in Cursor.`);
 }
+function runCursorAnalyzeRepo() {
+  p3.log.warn(
+    "Headless analyze-repo is currently supported for Claude Code only."
+  );
+  p3.log.info(`To run it in Cursor, run ${SETUP_COMMAND3} analyze-repo manually.`);
+}
 function runCursorAssistant(args, skipPermissions) {
   if (skipPermissions) {
     p3.log.warn("--skip-permissions is not supported for Cursor");
@@ -31140,6 +31330,11 @@ var SETUP_FN = {
   codex: runCodexSetup,
   cursor: runCursorSetup
 };
+var ANALYZE_REPO_FN = {
+  claude: runClaudeAnalyzeRepo,
+  codex: runCodexAnalyzeRepo,
+  cursor: runCursorAnalyzeRepo
+};
 var ASSISTANT_FN = {
   claude: runClaudeAssistant,
   codex: runCodexAssistant,
@@ -31194,6 +31389,31 @@ async function resolveSkipPermissions(value) {
   }
   return answer;
 }
+async function resolveCaptureOverride(flag) {
+  if (flag !== void 0) {
+    return flag;
+  }
+  const existing = getSessionLogConsent();
+  if (existing !== null) {
+    p4.log.step(
+      existing ? "Session logs: enabled (saved preference)." : "Session logs: disabled (saved preference)."
+    );
+    return void 0;
+  }
+  if (!process.stdin.isTTY) {
+    return false;
+  }
+  const answer = await p4.confirm({
+    message: "Allow Bitfab to collect session logs? (used to diagnose issues and improve the product)",
+    initialValue: true
+  });
+  if (p4.isCancel(answer)) {
+    p4.cancel("Cancelled.");
+    process.exit(0);
+  }
+  setSessionLogConsent(answer);
+  return void 0;
+}
 async function resolveEditor({ editor }) {
   const detected = detectInstalledEditors();
   if (detected.length === 0) {
@@ -31265,6 +31485,27 @@ async function runInit(opts) {
   }
   p4.outro("Done!");
 }
+async function runAnalyzeRepo(opts) {
+  p4.intro("bitfab");
+  const chosen = await resolveEditor(opts);
+  p4.log.step(`Setting up Bitfab in ${EDITOR_LABEL[chosen]}`);
+  INSTALL_FN[chosen]();
+  if (chosen !== "claude") {
+    ANALYZE_REPO_FN[chosen]();
+    process.exit(1);
+  }
+  const loggedInEmail = await checkAuth();
+  if (!loggedInEmail) {
+    p4.cancel(
+      "Not authenticated. Run `bitfab login` (or set BITFAB_API_KEY) before `bitfab analyze-repo` - it is non-interactive and cannot open a browser."
+    );
+    process.exit(1);
+  }
+  p4.log.success(`Logged in as ${loggedInEmail}`);
+  const captureOverride = await resolveCaptureOverride(opts.uploadLogs);
+  await ANALYZE_REPO_FN[chosen](captureOverride, opts.limit);
+  p4.outro("Done!");
+}
 async function checkAuth() {
   const { apiKey, serviceUrl } = getConfig();
   if (!apiKey) {
@@ -31308,18 +31549,17 @@ function startUpdateCheck() {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
   const current = getVersion();
+  let notice = null;
   const done = fetch(NPM_REGISTRY_URL, { signal: controller.signal }).then(
     (res) => res.ok ? res.json() : null
   ).then((data) => {
     const latest = data?.version;
     if (latest && isNewer(latest, current)) {
-      process.stderr.write(
-        `
+      notice = `
   Update available: ${current} -> ${latest}
   Run \`npx bitfab-cli@latest\` to get the newest version.
 
-`
-      );
+`;
     }
   }).catch(() => {
   }).finally(() => clearTimeout(timer));
@@ -31327,6 +31567,9 @@ function startUpdateCheck() {
     controller.abort();
     done.catch(() => {
     });
+    if (notice) {
+      process.stderr.write(notice);
+    }
   };
 }
 
@@ -31339,6 +31582,7 @@ Commands:
   login                               Authenticate with Bitfab (opens browser)
   logout                              Remove stored credentials
   setup [--editor <name>]             Launch /bitfab:setup in the editor
+  analyze-repo [--editor <name>]      Headless scan: draft + upload trace plans (no prompts, no code edits)
   assistant [--editor <name>] [args]  Launch /bitfab:assistant in the editor
   update [--editor <name>] [mode]      Update plugin, then launch SDK update (mode: all|plugin|sdk)
   help                                Show this help
@@ -31347,14 +31591,26 @@ Options:
   --editor, -e <name>    Target editor: claude, codex, cursor
   --skip-permissions     Skip permission prompts (runs the agent autonomously)
   --no-skip-permissions  Keep permission prompts (default, skips the interactive question)
+  --upload-logs          analyze-repo: upload the run's session logs to Bitfab (skips the prompt)
+  --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)
 
 Examples:
   bitfab init                              Full setup (detect editor, install, login, setup)
   bitfab init --editor claude              Full setup for Claude Code
+  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 assistant investigate             Investigate traces
   bitfab setup --skip-permissions          Setup without permission prompts
   bitfab assistant --skip-permissions      Run assistant autonomously
 `;
+function parseLimit(raw) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1) {
+    throw new Error(`--limit must be a positive integer, got "${raw}"`);
+  }
+  return n;
+}
 function wantsHelp(argv) {
   const command = argv[0];
   return !command || command === "help" || argv.includes("-h") || argv.includes("--help");
@@ -31363,6 +31619,8 @@ function parseArgs2(argv) {
   const [command, ...tail] = argv;
   let editor;
   let skipPermissions;
+  let uploadLogs;
+  let limit;
   const rest = [];
   for (let i = 0; i < tail.length; i++) {
     const arg = tail[i];
@@ -31379,16 +31637,27 @@ function parseArgs2(argv) {
       skipPermissions = true;
     } else if (arg === "--no-skip-permissions") {
       skipPermissions = false;
+    } else if (arg === "--upload-logs") {
+      uploadLogs = true;
+    } else if (arg === "--no-upload-logs") {
+      uploadLogs = false;
+    } else if (arg === "--limit") {
+      if (i + 1 < tail.length) {
+        limit = parseLimit(tail[i + 1]);
+        i++;
+      } else {
+        throw new Error("--limit flag requires a value");
+      }
+    } else if (arg?.startsWith("--limit=")) {
+      limit = parseLimit(arg.slice("--limit=".length));
     } else if (arg !== void 0) {
       rest.push(arg);
     }
   }
-  return { command, editor, skipPermissions, rest };
+  return { command, editor, skipPermissions, uploadLogs, limit, rest };
 }
 async function main() {
-  const { command, editor, skipPermissions, rest } = parseArgs2(
-    process.argv.slice(2)
-  );
+  const { command, editor, skipPermissions, uploadLogs, limit, rest } = parseArgs2(process.argv.slice(2));
   const abortUpdateCheck = startUpdateCheck();
   if (wantsHelp(process.argv.slice(2))) {
     process.stdout.write(HELP_TEXT);
@@ -31420,6 +31689,11 @@ async function main() {
     abortUpdateCheck();
     return;
   }
+  if (command === "analyze-repo") {
+    await runAnalyzeRepo({ editor, skipPermissions, uploadLogs, limit });
+    abortUpdateCheck();
+    return;
+  }
   if (command === "assistant") {
     await runAssistant({ editor, skipPermissions }, rest);
     abortUpdateCheck();

package/package.json

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