@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/chunk-Y4WOJJM3.js

@@ -1,147 +0,0 @@
-#!/usr/bin/env node
-
-// src/store/index.ts
-import { create } from "zustand";
-var ACTIVE_STATUSES = /* @__PURE__ */ new Set(["running", "queued"]);
-function isActiveStatus(status) {
-  return ACTIVE_STATUSES.has(status);
-}
-var useCliStore = create((set) => ({
-  // Session state
-  session: null,
-  setSession: (session) => set({ session }),
-  addMessage: (message) => set((state) => {
-    if (!state.session) return state;
-    return {
-      session: {
-        ...state.session,
-        messages: [...state.session.messages, message],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }),
-  // Pending messages
-  pendingMessages: [],
-  addPendingMessage: (message) => set((state) => ({ pendingMessages: [...state.pendingMessages, message] })),
-  updatePendingMessage: (index, message) => set((state) => {
-    const updated = [...state.pendingMessages];
-    updated[index] = message;
-    return { pendingMessages: updated };
-  }),
-  clearPendingMessages: () => set({ pendingMessages: [] }),
-  completePendingMessage: (index, finalMessage) => set((state) => {
-    const pending = [...state.pendingMessages];
-    pending.splice(index, 1);
-    const session = state.session;
-    if (!session) return { pendingMessages: pending };
-    return {
-      pendingMessages: pending,
-      session: {
-        ...session,
-        messages: [...session.messages, finalMessage],
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }),
-  // UI state
-  isThinking: false,
-  setIsThinking: (thinking) => set({ isThinking: thinking }),
-  // Input state (for Ctrl+C clearing)
-  inputValue: "",
-  setInputValue: (value) => set({ inputValue: value }),
-  clearInput: () => set({ inputValue: "", pastedContent: null, pastedLineCount: 0 }),
-  // Paste state
-  pastedContent: null,
-  pastedLineCount: 0,
-  setPastedContent: (content, lineCount) => set({
-    pastedContent: content,
-    pastedLineCount: lineCount,
-    inputValue: content
-  }),
-  clearPaste: () => set({ pastedContent: null, pastedLineCount: 0, inputValue: "" }),
-  // Permission prompt queue
-  permissionPrompt: null,
-  permissionQueue: [],
-  enqueuePermissionPrompt: (prompt) => set((state) => {
-    if (!state.permissionPrompt) {
-      return { permissionPrompt: prompt };
-    }
-    return { permissionQueue: [...state.permissionQueue, prompt] };
-  }),
-  dequeuePermissionPrompt: () => set((state) => {
-    const [next, ...rest] = state.permissionQueue;
-    return {
-      permissionPrompt: next ?? null,
-      permissionQueue: rest
-    };
-  }),
-  // User question prompt queue
-  userQuestionPrompt: null,
-  userQuestionQueue: [],
-  enqueueUserQuestionPrompt: (prompt) => set((state) => {
-    if (!state.userQuestionPrompt) {
-      return { userQuestionPrompt: prompt };
-    }
-    return { userQuestionQueue: [...state.userQuestionQueue, prompt] };
-  }),
-  dequeueUserQuestionPrompt: () => set((state) => {
-    const [next, ...rest] = state.userQuestionQueue;
-    return {
-      userQuestionPrompt: next ?? null,
-      userQuestionQueue: rest
-    };
-  }),
-  // Config editor
-  showConfigEditor: false,
-  setShowConfigEditor: (show) => set({ showConfigEditor: show }),
-  // MCP viewer
-  showMcpViewer: false,
-  setShowMcpViewer: (show) => set({ showMcpViewer: show }),
-  // Auto-accept edits toggle (Shift+Tab)
-  autoAcceptEdits: false,
-  toggleAutoAcceptEdits: () => set((state) => ({ autoAcceptEdits: !state.autoAcceptEdits })),
-  // Exit handling
-  exitRequested: false,
-  setExitRequested: (requested) => set({ exitRequested: requested }),
-  // Background agents
-  backgroundAgents: [],
-  upsertBackgroundAgent: (job) => set((state) => {
-    const existing = state.backgroundAgents.findIndex((j) => j.id === job.id);
-    if (existing >= 0) {
-      const updated = [...state.backgroundAgents];
-      updated[existing] = job;
-      return { backgroundAgents: updated };
-    }
-    return { backgroundAgents: [...state.backgroundAgents, job] };
-  }),
-  cleanupCompletedBackgroundAgents: () => set((state) => ({
-    backgroundAgents: state.backgroundAgents.filter((j) => isActiveStatus(j.status))
-  })),
-  // Completed group notifications
-  completedGroupNotifications: [],
-  addCompletedGroupNotification: (notification, groupDescription) => set((state) => ({
-    completedGroupNotifications: [
-      ...state.completedGroupNotifications,
-      { notification, groupDescription, timestamp: Date.now() }
-    ]
-  })),
-  clearCompletedGroupNotifications: () => set({ completedGroupNotifications: [] }),
-  // Pending background trigger
-  pendingBackgroundTrigger: false,
-  setPendingBackgroundTrigger: (pending) => set({ pendingBackgroundTrigger: pending }),
-  // Tavern activity log (capped at 200 entries)
-  tavernActivityLog: [],
-  addTavernLogEntry: (entry) => set((state) => {
-    const log = [...state.tavernActivityLog, entry];
-    return { tavernActivityLog: log.length > 200 ? log.slice(-200) : log };
-  }),
-  clearTavernActivityLog: () => set({ tavernActivityLog: [] })
-}));
-var selectActiveBackgroundAgents = (state) => state.backgroundAgents.filter((j) => isActiveStatus(j.status));
-var selectCompletedBackgroundAgents = (state) => state.backgroundAgents.filter((j) => !isActiveStatus(j.status));
-
-export {
-  useCliStore,
-  selectActiveBackgroundAgents,
-  selectCompletedBackgroundAgents
-};

package/dist/commands/doctorCommand.js

@@ -1,87 +0,0 @@
-#!/usr/bin/env node
-import {
-  fetchLatestVersion,
-  forceCheckForUpdate,
-  package_default
-} from "../chunk-SGPRXN4C.js";
-
-// src/commands/doctorCommand.ts
-import { execSync } from "child_process";
-import { existsSync, constants } from "fs";
-import { promises as fsPromises } from "fs";
-import path from "path";
-import { homedir } from "os";
-async function handleDoctorCommand() {
-  console.log("B4M CLI Doctor\n");
-  console.log("Running diagnostics...\n");
-  const results = [];
-  const nodeVersion = process.version;
-  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
-  if (nodeMajor >= 18) {
-    results.push({ name: "Node.js version", status: "pass", message: `${nodeVersion} (>= 18 required)` });
-  } else {
-    results.push({
-      name: "Node.js version",
-      status: "fail",
-      message: `${nodeVersion} (>= 18 required, please upgrade)`
-    });
-  }
-  const latestVersion = await fetchLatestVersion();
-  if (latestVersion) {
-    results.push({ name: "NPM registry", status: "pass", message: `Accessible (latest: v${latestVersion})` });
-  } else {
-    results.push({ name: "NPM registry", status: "fail", message: "Not accessible \u2014 check your internet connection" });
-  }
-  const currentVersion = package_default.version;
-  const updateResult = await forceCheckForUpdate(currentVersion);
-  if (updateResult) {
-    if (updateResult.updateAvailable) {
-      results.push({
-        name: "Version",
-        status: "warn",
-        message: `v${currentVersion} installed, v${updateResult.latestVersion} available. Run: b4m update`
-      });
-    } else {
-      results.push({ name: "Version", status: "pass", message: `v${currentVersion} (latest)` });
-    }
-  }
-  try {
-    const npmPrefix = execSync("npm config get prefix", { encoding: "utf-8", timeout: 1e4 }).trim();
-    try {
-      await fsPromises.access(npmPrefix, constants.W_OK);
-      results.push({ name: "Global npm path", status: "pass", message: `${npmPrefix} (writable)` });
-    } catch {
-      results.push({
-        name: "Global npm path",
-        status: "warn",
-        message: `${npmPrefix} (not writable \u2014 may need sudo for updates)`
-      });
-    }
-  } catch {
-    results.push({ name: "Global npm path", status: "warn", message: "Could not determine npm prefix" });
-  }
-  const configFile = path.join(homedir(), ".bike4mind", "config.json");
-  if (existsSync(configFile)) {
-    results.push({ name: "Config file", status: "pass", message: configFile });
-  } else {
-    results.push({ name: "Config file", status: "warn", message: `Not found at ${configFile}` });
-  }
-  console.log("Results:\n");
-  for (const result of results) {
-    const icon = result.status === "pass" ? "\x1B[32m\u2713\x1B[0m" : result.status === "warn" ? "\x1B[33m!\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
-    console.log(`  ${icon} ${result.name}: ${result.message}`);
-  }
-  const failures = results.filter((r) => r.status === "fail");
-  const warnings = results.filter((r) => r.status === "warn");
-  console.log("");
-  if (failures.length > 0) {
-    console.log(`${failures.length} issue(s) found.`);
-  } else if (warnings.length > 0) {
-    console.log(`All checks passed with ${warnings.length} warning(s).`);
-  } else {
-    console.log("All checks passed.");
-  }
-}
-export {
-  handleDoctorCommand
-};

package/dist/commands/headlessCommand.js

@@ -1,380 +0,0 @@
-#!/usr/bin/env node
-import {
-  createSandboxRuntime
-} from "../chunk-QWB6ZYY4.js";
-import {
-  SandboxOrchestrator
-} from "../chunk-KQAMBXAW.js";
-import {
-  ProxyManager
-} from "../chunk-G4ZGEQFT.js";
-import {
-  AgentStore,
-  ApiClient,
-  BackgroundAgentManager,
-  CheckpointStore,
-  CustomCommandStore,
-  McpManager,
-  PermissionManager,
-  ReActAgent,
-  ServerLlmBackend,
-  SessionStore,
-  SubagentOrchestrator,
-  WebSocketConnectionManager,
-  WebSocketLlmBackend,
-  WebSocketToolExecutor,
-  buildCoreSystemPrompt,
-  createAgentDelegateTool,
-  createBackgroundAgentTools,
-  createFindDefinitionTool,
-  createGetFileStructureTool,
-  createSkillTool,
-  createTodoStore,
-  createWriteTodosTool,
-  generateCliTools,
-  getApiUrl,
-  isReadOnlyTool,
-  loadContextFiles,
-  setWebSocketToolExecutor
-} from "../chunk-KUVV2NAB.js";
-import "../chunk-BDQBOLYG.js";
-import "../chunk-WBE7SQUB.js";
-import "../chunk-GQGOWACU.js";
-import "../chunk-LTLJRF6I.js";
-import "../chunk-5LZS5CVJ.js";
-import "../chunk-UZUHPHZC.js";
-import "../chunk-EPIYC3LA.js";
-import "../chunk-PFBYGCOW.js";
-import "../chunk-BPFEGDC7.js";
-import {
-  ConfigStore,
-  logger
-} from "../chunk-J6ZBI6TI.js";
-import "../chunk-JW3JRHH7.js";
-import {
-  DEFAULT_SANDBOX_CONFIG
-} from "../chunk-4BIBE3J7.js";
-
-// src/commands/headlessCommand.ts
-import { randomBytes } from "crypto";
-import { v4 as uuidv4 } from "uuid";
-async function readStdin() {
-  if (process.stdin.isTTY) {
-    return "";
-  }
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8").trim()));
-    process.stdin.on("error", reject);
-  });
-}
-var silentLogger = {
-  log: () => {
-  },
-  info: () => {
-  },
-  warn: () => {
-  },
-  error: () => {
-  },
-  debug: () => {
-  }
-};
-async function handleHeadlessCommand(options) {
-  const { prompt, outputFormat, dangerouslySkipPermissions, addDirs } = options;
-  logger.setVerbose(options.verbose);
-  const stdinContent = await readStdin();
-  const fullPrompt = stdinContent ? `${prompt}
-
-<stdin>
-${stdinContent}
-</stdin>` : prompt;
-  const configStore = new ConfigStore();
-  const sessionStore = new SessionStore();
-  const customCommandStore = new CustomCommandStore();
-  try {
-    const config = await configStore.load();
-    const configDirs = await configStore.getAdditionalDirectories();
-    const flagDirs = process.env.B4M_ADDITIONAL_DIRS ? JSON.parse(process.env.B4M_ADDITIONAL_DIRS) : [];
-    const additionalDirectories = [.../* @__PURE__ */ new Set([...configDirs, ...flagDirs, ...addDirs])];
-    try {
-      await customCommandStore.loadCommands();
-    } catch {
-    }
-    const authTokens = await configStore.getAuthTokens();
-    if (!authTokens) {
-      process.stderr.write("Error: Not authenticated. Run `b4m /login` to authenticate.\n");
-      process.exit(1);
-    }
-    if (new Date(authTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
-      await configStore.clearAuthTokens();
-      process.stderr.write("Error: Authentication token expired. Run `b4m /login` to re-authenticate.\n");
-      process.exit(1);
-    }
-    const apiBaseURL = getApiUrl(config.apiConfig);
-    const apiClient = new ApiClient(apiBaseURL, configStore);
-    const tokenGetter = async () => {
-      const tokens = await configStore.getAuthTokens();
-      return tokens?.accessToken ?? null;
-    };
-    let wsManager = null;
-    let llm;
-    try {
-      const serverConfig = await apiClient.get(
-        "/api/settings/serverConfig"
-      );
-      const wsUrl = serverConfig?.websocketUrl;
-      const wsCompletionUrl = serverConfig?.wsCompletionUrl;
-      if (wsUrl && wsCompletionUrl) {
-        wsManager = new WebSocketConnectionManager(wsUrl, tokenGetter);
-        await wsManager.connect();
-        const wsToolExecutor = new WebSocketToolExecutor(wsManager, tokenGetter);
-        setWebSocketToolExecutor(wsToolExecutor);
-        llm = new WebSocketLlmBackend({
-          wsManager,
-          apiClient,
-          model: config.defaultModel,
-          tokenGetter,
-          wsCompletionUrl
-        });
-        logger.debug("[headless] Using WebSocket transport");
-      } else {
-        throw new Error("No websocketUrl or wsCompletionUrl in server config");
-      }
-    } catch {
-      wsManager = null;
-      setWebSocketToolExecutor(null);
-      llm = new ServerLlmBackend({ apiClient, model: config.defaultModel });
-      logger.debug("[headless] Using SSE transport fallback");
-    }
-    const models = await llm.getModelInfo();
-    if (models.length === 0) {
-      throw new Error("No models available from server.");
-    }
-    const modelInfo = models.find((m) => m.id === config.defaultModel) ?? models[0];
-    llm.currentModel = modelInfo.id;
-    const session = {
-      id: uuidv4(),
-      name: `Headless ${(/* @__PURE__ */ new Date()).toISOString()}`,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      model: modelInfo.id,
-      messages: [],
-      metadata: { totalTokens: 0, totalCost: 0, toolCallCount: 0 }
-    };
-    await logger.initialize(session.id);
-    const permissionManager = new PermissionManager(config.trustedTools ?? [], void 0, config.tools.disabled);
-    const promptFn = (toolName, _args, _preview) => {
-      if (dangerouslySkipPermissions) {
-        logger.debug(`[headless] Auto-allowing tool: ${toolName}`);
-        return Promise.resolve({ action: "allow-once" });
-      }
-      process.stderr.write(
-        `Warning: Tool "${toolName}" requires permission and was denied. Use --dangerously-skip-permissions to auto-allow tools in headless mode.
-`
-      );
-      return Promise.resolve({ action: "deny" });
-    };
-    const userQuestionFn = (_payload) => {
-      process.stderr.write(
-        "Warning: Agent requested user input; headless mode cannot respond interactively. Answering with empty response.\n"
-      );
-      return Promise.resolve({ answers: [] });
-    };
-    const sandboxConfig = config.sandbox ?? DEFAULT_SANDBOX_CONFIG;
-    const checkpointProjectDir = configStore.getProjectConfigDir() ?? process.cwd();
-    const checkpointStore = new CheckpointStore(checkpointProjectDir);
-    const [sandboxRuntime] = await Promise.all([
-      createSandboxRuntime(),
-      checkpointStore.init(session.id).catch(() => {
-      })
-    ]);
-    const proxyManager = new ProxyManager(sandboxConfig.network);
-    const sandboxOrchestrator = new SandboxOrchestrator(sandboxConfig, sandboxRuntime, proxyManager);
-    permissionManager.setSandboxState(sandboxConfig.mode, sandboxOrchestrator.isActive());
-    const agentContext = {
-      currentAgent: null,
-      observationQueue: []
-    };
-    const { tools: b4mTools } = await generateCliTools(
-      config.userId,
-      llm,
-      modelInfo.id,
-      permissionManager,
-      promptFn,
-      agentContext,
-      configStore,
-      apiClient,
-      void 0,
-      userQuestionFn,
-      checkpointStore,
-      sandboxOrchestrator,
-      additionalDirectories
-    );
-    const mcpManager = new McpManager(config);
-    const projectConfigDir = configStore.getProjectConfigDir();
-    const builtinAgentsDir = new URL("../agents/defaults/", import.meta.url).pathname;
-    const agentStore = new AgentStore(builtinAgentsDir, projectConfigDir ?? process.cwd());
-    const [, , contextResult] = await Promise.all([
-      mcpManager.initialize(),
-      agentStore.loadAgents(),
-      loadContextFiles(projectConfigDir)
-    ]);
-    const mcpTools = mcpManager.getTools();
-    const orchestrator = new SubagentOrchestrator({
-      userId: config.userId,
-      llm,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      logger: silentLogger,
-      // silentLogger satisfies Logger structurally but lacks full type metadata
-      permissionManager,
-      showPermissionPrompt: promptFn,
-      configStore,
-      apiClient,
-      agentStore,
-      customCommandStore,
-      enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
-      showUserQuestion: userQuestionFn,
-      checkpointStore
-    });
-    const backgroundManager = new BackgroundAgentManager(orchestrator);
-    const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, session.id, backgroundManager);
-    const backgroundTools = createBackgroundAgentTools(backgroundManager);
-    const todoStore = createTodoStore();
-    const writeTodosTool = createWriteTodosTool(todoStore);
-    const findDefinitionTool = createFindDefinitionTool();
-    const getFileStructureTool = createGetFileStructureTool();
-    const enableSkillTool = config.preferences.enableSkillTool !== false;
-    const skillTool = enableSkillTool ? createSkillTool({ customCommandStore, subagentOrchestrator: orchestrator, sessionId: session.id }) : null;
-    const cliTools = [agentDelegateTool, ...backgroundTools, writeTodosTool, findDefinitionTool, getFileStructureTool];
-    if (skillTool) cliTools.push(skillTool);
-    const allTools = [...b4mTools, ...mcpTools, ...cliTools];
-    const systemPrompt = buildCoreSystemPrompt({
-      contextContent: contextResult.mergedContent,
-      agentStore,
-      customCommands: customCommandStore.getAllCommands(),
-      enableSkillTool,
-      enableDynamicAgentCreation: false,
-      additionalDirectories
-    });
-    const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
-    const agent = new ReActAgent({
-      userId: config.userId,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      logger: silentLogger,
-      // silentLogger satisfies Logger structurally but lacks full type metadata
-      llm,
-      model: modelInfo.id,
-      tools: allTools,
-      maxIterations,
-      maxTokens: config.preferences.maxTokens,
-      temperature: config.preferences.temperature,
-      systemPrompt
-    });
-    agentContext.currentAgent = agent;
-    agent.observationQueue = agentContext.observationQueue;
-    if (outputFormat === "stream-json") {
-      const emitNdjson = (obj) => process.stdout.write(JSON.stringify(obj) + "\n");
-      agent.on("thought", (step) => {
-        emitNdjson({ type: "thought", content: step.content });
-      });
-      agent.on("action", (step) => {
-        emitNdjson({
-          type: "action",
-          content: step.content,
-          toolName: step.metadata?.toolName,
-          toolInput: step.metadata?.toolInput
-        });
-      });
-      agent.on("observation", (step) => {
-        emitNdjson({ type: "observation", content: step.content, toolName: step.metadata?.toolName });
-      });
-    }
-    const turnId = `turn-${randomBytes(4).toString("hex")}`;
-    backgroundManager.setCurrentTurn(turnId);
-    let result;
-    try {
-      result = await agent.run(fullPrompt, {
-        parallelExecution: config.preferences.enableParallelToolExecution === true,
-        isReadOnlyTool
-      });
-    } finally {
-      backgroundManager.setCurrentTurn(null);
-    }
-    const finalSession = {
-      ...session,
-      messages: [
-        { id: uuidv4(), role: "user", content: fullPrompt, timestamp: (/* @__PURE__ */ new Date()).toISOString() },
-        { id: uuidv4(), role: "assistant", content: result.finalAnswer, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
-      ],
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      metadata: {
-        totalTokens: result.completionInfo.totalTokens,
-        totalCost: 0,
-        toolCallCount: result.completionInfo.toolCalls
-      }
-    };
-    await sessionStore.save(finalSession);
-    switch (outputFormat) {
-      case "text":
-        process.stdout.write(result.finalAnswer + "\n");
-        break;
-      case "json": {
-        const jsonResult = {
-          result: result.finalAnswer,
-          steps: result.steps.map((s) => ({
-            type: s.type,
-            content: s.content,
-            toolName: s.metadata?.toolName,
-            toolInput: s.metadata?.toolInput
-          })),
-          tokenUsage: {
-            totalTokens: result.completionInfo.totalTokens,
-            inputTokens: result.completionInfo.totalInputTokens,
-            outputTokens: result.completionInfo.totalOutputTokens
-          },
-          iterations: result.completionInfo.iterations,
-          toolCalls: result.completionInfo.toolCalls
-        };
-        process.stdout.write(JSON.stringify(jsonResult, null, 2) + "\n");
-        break;
-      }
-      case "stream-json":
-        process.stdout.write(
-          JSON.stringify({
-            type: "result",
-            content: result.finalAnswer,
-            tokenUsage: {
-              totalTokens: result.completionInfo.totalTokens,
-              inputTokens: result.completionInfo.totalInputTokens,
-              outputTokens: result.completionInfo.totalOutputTokens
-            },
-            iterations: result.completionInfo.iterations,
-            toolCalls: result.completionInfo.toolCalls
-          }) + "\n"
-        );
-        break;
-    }
-    await mcpManager.disconnect().catch(() => {
-    });
-    if (wsManager) wsManager.disconnect();
-    setWebSocketToolExecutor(null);
-    agent.removeAllListeners();
-    process.exit(0);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (outputFormat === "json") {
-      process.stdout.write(JSON.stringify({ error: message }) + "\n");
-    } else if (outputFormat === "stream-json") {
-      process.stdout.write(JSON.stringify({ type: "error", error: message }) + "\n");
-    } else {
-      process.stderr.write(`Error: ${message}
-`);
-    }
-    process.exit(1);
-  }
-}
-export {
-  handleHeadlessCommand
-};