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

package/dist/chunk-J6ZBI6TI.js

@@ -1,1079 +0,0 @@
-#!/usr/bin/env node
-import {
-  ChatModels
-} from "./chunk-JW3JRHH7.js";
-import {
-  DEFAULT_SANDBOX_CONFIG
-} from "./chunk-4BIBE3J7.js";
-
-// src/utils/Logger.ts
-import fs from "fs/promises";
-import path from "path";
-import os from "os";
-var Logger = class _Logger {
-  constructor() {
-    this.logFilePath = null;
-    this.sessionId = null;
-    this.fileLoggingEnabled = true;
-    this.consoleVerbose = false;
-  }
-  static {
-    this.instance = null;
-  }
-  static getInstance() {
-    if (!_Logger.instance) {
-      _Logger.instance = new _Logger();
-    }
-    return _Logger.instance;
-  }
-  /**
-   * Initialize the logger with a session ID
-   */
-  async initialize(sessionId) {
-    this.sessionId = sessionId;
-    const debugDir = path.join(os.homedir(), ".bike4mind", "debug");
-    await fs.mkdir(debugDir, { recursive: true });
-    this.logFilePath = path.join(debugDir, `${sessionId}.txt`);
-    await this.writeToFile("INFO", "=== CLI SESSION START ===");
-  }
-  /**
-   * Set whether verbose console logging is enabled
-   */
-  setVerbose(enabled) {
-    this.consoleVerbose = enabled;
-  }
-  /**
-   * Set whether file logging is enabled
-   */
-  setFileLoggingEnabled(enabled) {
-    this.fileLoggingEnabled = enabled;
-  }
-  /**
-   * DEBUG level - verbose-only console, always file
-   */
-  debug(message) {
-    this.writeToFile("DEBUG", message).catch(() => {
-    });
-    if (this.consoleVerbose) {
-      console.log(message);
-    }
-  }
-  /**
-   * INFO level - always shown to user
-   */
-  info(message) {
-    this.writeToFile("INFO", message).catch(() => {
-    });
-    console.log(message);
-  }
-  /**
-   * WARN level - always shown to user
-   */
-  warn(message) {
-    this.writeToFile("WARN", message).catch(() => {
-    });
-    console.warn(message);
-  }
-  /**
-   * ERROR level - always shown to user
-   */
-  error(message, err) {
-    this.writeToFile("ERROR", message).catch(() => {
-    });
-    if (err) {
-      this.logErrorDetailsToFile(err).catch(() => {
-      });
-    }
-    console.error(message);
-  }
-  /**
-   * Write log entry to file
-   */
-  async writeToFile(level, message) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").substring(0, 19);
-      const logEntry = `[${timestamp}] [${level}] ${message}
-`;
-      await fs.appendFile(this.logFilePath, logEntry, "utf-8");
-    } catch (error) {
-      console.error("File logging failed:", error);
-    }
-  }
-  /**
-   * Log error details to file
-   */
-  async logErrorDetailsToFile(err) {
-    if (!this.fileLoggingEnabled || !this.logFilePath) {
-      return;
-    }
-    try {
-      if (err && typeof err === "object" && "response" in err && err.response) {
-        const response = err.response;
-        const config = err && typeof err === "object" && "config" in err ? err.config : void 0;
-        await this.writeToFile("ERROR", `  Status: ${response.status} ${response.statusText || ""}`);
-        await this.writeToFile("ERROR", `  URL: ${config?.url || "unknown"}`);
-        await this.writeToFile("ERROR", `  Headers: ${this.safeStringify(response.headers)}`);
-        if (response.data) {
-          const errorText = this.extractErrorMessage(response.data);
-          if (errorText.trim().startsWith("<!DOCTYPE") || errorText.trim().startsWith("<html")) {
-            await this.writeToFile("ERROR", `  Response Type: HTML Error Page`);
-            const parsedError = this.parseHtmlError(errorText);
-            if (parsedError) {
-              await this.writeToFile("ERROR", `  Error Message: ${parsedError}`);
-            }
-            await this.writeToFile("ERROR", `  Raw HTML: ${this.truncate(errorText, 1e3)}`);
-          } else {
-            const preview = this.truncate(errorText, 500);
-            await this.writeToFile("ERROR", `  Response: ${preview}`);
-          }
-        } else {
-          await this.writeToFile("ERROR", `  Response: (no data)`);
-        }
-      }
-      if (err && typeof err === "object" && "stack" in err && typeof err.stack === "string") {
-        const stackLines = err.stack.split("\n").slice(0, 5).join("\n    ");
-        await this.writeToFile("ERROR", `  Stack: ${stackLines}`);
-      } else if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
-        await this.writeToFile("ERROR", `  Message: ${err.message}`);
-      }
-    } catch (error) {
-    }
-  }
-  /**
-   * Safely stringify object, handling circular references
-   */
-  safeStringify(obj) {
-    try {
-      return JSON.stringify(obj);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("circular")) {
-        try {
-          const seen = /* @__PURE__ */ new WeakSet();
-          return JSON.stringify(obj, (key, value) => {
-            if (typeof value === "object" && value !== null) {
-              if (seen.has(value)) {
-                return "[Circular]";
-              }
-              seen.add(value);
-            }
-            return value;
-          });
-        } catch {
-          return "[Unable to stringify]";
-        }
-      }
-      return "[Stringify error]";
-    }
-  }
-  /**
-   * Extract readable text from error response data
-   */
-  extractErrorMessage(data) {
-    if (Buffer.isBuffer(data)) {
-      return data.toString("utf-8");
-    }
-    if (typeof data === "string") {
-      return data;
-    }
-    if (data && typeof data === "object" && "_readableState" in data && data._readableState && typeof data._readableState === "object" && "buffer" in data._readableState && Array.isArray(data._readableState.buffer) && data._readableState.buffer.length > 0) {
-      const chunks = [];
-      for (const chunk of data._readableState.buffer) {
-        if (chunk && typeof chunk === "object" && "type" in chunk && chunk.type === "Buffer" && "data" in chunk && Array.isArray(chunk.data)) {
-          chunks.push(Buffer.from(chunk.data));
-        } else if (Buffer.isBuffer(chunk)) {
-          chunks.push(chunk);
-        } else if (chunk && typeof chunk === "object" && "data" in chunk) {
-          if (Buffer.isBuffer(chunk.data)) {
-            chunks.push(chunk.data);
-          } else if (Array.isArray(chunk.data)) {
-            chunks.push(Buffer.from(chunk.data));
-          }
-        }
-      }
-      if (chunks.length > 0) {
-        return Buffer.concat(chunks).toString("utf-8");
-      }
-    }
-    return this.safeStringify(data);
-  }
-  /**
-   * Parse HTML error page to extract error message
-   */
-  parseHtmlError(html) {
-    const titleMatch = html.match(/<title>(.*?)<\/title>/i);
-    const h1Match = html.match(/<h1>(.*?)<\/h1>/i);
-    const bodyMatch = html.match(/<body[^>]*>(.*?)<\/body>/is);
-    if (titleMatch && titleMatch[1] !== "Error") {
-      return titleMatch[1].trim();
-    }
-    if (h1Match) {
-      return h1Match[1].trim();
-    }
-    if (bodyMatch) {
-      const text = bodyMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
-      return text.substring(0, 200);
-    }
-    return null;
-  }
-  /**
-   * Truncate string to max length with ellipsis
-   */
-  truncate(str, maxLength) {
-    if (str.length <= maxLength) {
-      return str;
-    }
-    return str.substring(0, maxLength) + "... [truncated]";
-  }
-  /**
-   * Format bytes to human-readable size
-   */
-  formatBytes(bytes) {
-    if (bytes === 0) return "0 B";
-    const k = 1024;
-    const sizes = ["B", "KB", "MB", "GB"];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
-  }
-  /**
-   * Clean up old debug logs (older than 30 days)
-   */
-  async cleanupOldLogs() {
-    if (!this.fileLoggingEnabled) return;
-    try {
-      const debugDir = path.join(os.homedir(), ".bike4mind", "debug");
-      const files = await fs.readdir(debugDir);
-      const now = Date.now();
-      const thirtyDaysAgo = now - 30 * 24 * 60 * 60 * 1e3;
-      for (const file of files) {
-        const filePath = path.join(debugDir, file);
-        const stats = await fs.stat(filePath);
-        if (stats.mtime.getTime() < thirtyDaysAgo) {
-          await fs.unlink(filePath);
-        }
-      }
-    } catch (error) {
-      console.error("Failed to cleanup old logs:", error);
-    }
-  }
-};
-var logger = Logger.getInstance();
-logger.setVerbose(process.env.B4M_VERBOSE === "1");
-
-// src/storage/ConfigStore.ts
-import { promises as fs2, existsSync } from "fs";
-import path2 from "path";
-import { homedir } from "os";
-import { v4 as uuidv4 } from "uuid";
-import { z } from "zod";
-var SandboxFilesystemSchema = z.object({
-  allowedReadPaths: z.array(z.string()).default(DEFAULT_SANDBOX_CONFIG.filesystem.allowedReadPaths),
-  deniedPaths: z.array(z.string()).default(DEFAULT_SANDBOX_CONFIG.filesystem.deniedPaths),
-  writeOnlyToWorkingDir: z.boolean().default(true)
-});
-var SandboxNetworkSchema = z.object({
-  enabled: z.boolean().default(false),
-  allowedDomains: z.array(z.string()).default(DEFAULT_SANDBOX_CONFIG.network.allowedDomains)
-});
-var SandboxPlatformSchema = z.object({
-  linux: z.object({
-    runtime: z.literal("bubblewrap").default("bubblewrap"),
-    seccompProfile: z.string().optional()
-  }).default({ runtime: "bubblewrap" }),
-  macos: z.object({
-    runtime: z.literal("seatbelt").default("seatbelt"),
-    profileTemplate: z.string().default("default")
-  }).default({ runtime: "seatbelt", profileTemplate: "default" })
-});
-var SandboxConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  mode: z.enum(["disabled", "auto-allow", "permissions"]).default("disabled"),
-  filesystem: SandboxFilesystemSchema.default(DEFAULT_SANDBOX_CONFIG.filesystem),
-  network: SandboxNetworkSchema.default(DEFAULT_SANDBOX_CONFIG.network),
-  excludedCommands: z.array(z.string()).default(DEFAULT_SANDBOX_CONFIG.excludedCommands),
-  allowUnsandboxedCommands: z.boolean().default(true),
-  platform: SandboxPlatformSchema.default(DEFAULT_SANDBOX_CONFIG.platform)
-}).refine(
-  (config) => {
-    if (config.enabled && config.mode === "disabled") return false;
-    if (!config.enabled && config.mode !== "disabled") return false;
-    return true;
-  },
-  {
-    message: 'Sandbox config inconsistency: enabled and mode must agree. If enabled=true, mode must be "auto-allow" or "permissions". If mode="disabled", enabled must be false.'
-  }
-);
-var PartialSandboxConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  mode: z.enum(["disabled", "auto-allow", "permissions"]).optional(),
-  filesystem: z.object({
-    allowedReadPaths: z.array(z.string()).optional(),
-    deniedPaths: z.array(z.string()).optional(),
-    writeOnlyToWorkingDir: z.boolean().optional()
-  }).optional(),
-  network: z.object({
-    enabled: z.boolean().optional(),
-    allowedDomains: z.array(z.string()).optional()
-  }).optional(),
-  excludedCommands: z.array(z.string()).optional(),
-  allowUnsandboxedCommands: z.boolean().optional(),
-  platform: SandboxPlatformSchema.optional()
-}).optional();
-var AuthTokensSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string(),
-  expiresAt: z.string(),
-  userId: z.string()
-});
-var ApiConfigSchema = z.object({
-  customUrl: z.url().optional()
-});
-var McpServerSchema = z.object({
-  name: z.string(),
-  command: z.string().optional(),
-  args: z.array(z.string()).optional(),
-  env: z.record(z.string(), z.string()).prefault({}),
-  enabled: z.boolean().prefault(true)
-});
-var McpServersSchema = z.union([
-  // Array format (B4M native)
-  z.array(McpServerSchema),
-  // Object format (portable - compatible with Claude Code)
-  z.record(
-    z.string(),
-    z.object({
-      command: z.string().optional(),
-      args: z.array(z.string()).optional(),
-      env: z.record(z.string(), z.string()).optional(),
-      enabled: z.boolean().optional()
-    })
-  )
-]);
-function normalizeMcpServers(servers) {
-  if (Array.isArray(servers)) {
-    return servers.map((server) => ({
-      name: server.name,
-      command: server.command,
-      args: server.args,
-      env: server.env || {},
-      enabled: server.enabled ?? true
-    }));
-  } else {
-    return Object.entries(servers).map(([name, config]) => ({
-      name,
-      command: config.command,
-      args: config.args,
-      env: config.env || {},
-      enabled: config.enabled ?? true
-    }));
-  }
-}
-var CliConfigSchema = z.object({
-  version: z.string(),
-  userId: z.string(),
-  auth: AuthTokensSchema.optional(),
-  defaultModel: z.string(),
-  apiConfig: ApiConfigSchema.optional(),
-  toolApiKeys: z.object({
-    openweather: z.string().optional(),
-    serper: z.string().optional()
-  }).optional(),
-  mcpServers: McpServersSchema,
-  preferences: z.object({
-    maxTokens: z.number(),
-    temperature: z.number(),
-    autoSave: z.boolean(),
-    autoCompact: z.boolean().optional().prefault(true),
-    theme: z.enum(["light", "dark"]),
-    exportFormat: z.enum(["markdown", "json"]),
-    maxIterations: z.number().nullable().prefault(10),
-    enableSkillTool: z.boolean().optional().prefault(true),
-    enableDynamicAgentCreation: z.boolean().optional().prefault(false)
-  }),
-  tools: z.object({
-    enabled: z.array(z.string()),
-    disabled: z.array(z.string()),
-    config: z.record(z.string(), z.any())
-  }),
-  features: z.object({
-    tavern: z.boolean().optional()
-  }).optional().prefault({}),
-  trustedTools: z.array(z.string()).optional().prefault([]),
-  sandbox: SandboxConfigSchema.optional(),
-  additionalDirectories: z.array(z.string()).optional().prefault([])
-});
-var ProjectConfigSchema = z.object({
-  tools: z.object({
-    enabled: z.array(z.string()).optional(),
-    denied: z.array(z.string()).optional(),
-    config: z.record(z.string(), z.any()).optional()
-  }).optional(),
-  defaultModel: z.string().optional(),
-  mcpServers: McpServersSchema.optional(),
-  preferences: z.object({
-    maxTokens: z.number().optional(),
-    temperature: z.number().optional(),
-    autoSave: z.boolean().optional(),
-    autoCompact: z.boolean().optional(),
-    theme: z.enum(["light", "dark"]).optional(),
-    exportFormat: z.enum(["markdown", "json"]).optional(),
-    enableSkillTool: z.boolean().optional(),
-    enableDynamicAgentCreation: z.boolean().optional()
-  }).optional(),
-  sandbox: PartialSandboxConfigSchema,
-  additionalDirectories: z.array(z.string()).optional()
-});
-var ProjectLocalConfigSchema = z.object({
-  trustedTools: z.array(z.string()).optional(),
-  toolApiKeys: z.object({
-    openweather: z.string().optional(),
-    serper: z.string().optional()
-  }).optional(),
-  preferences: z.object({
-    maxTokens: z.number().optional(),
-    temperature: z.number().optional(),
-    autoSave: z.boolean().optional(),
-    autoCompact: z.boolean().optional(),
-    theme: z.enum(["light", "dark"]).optional(),
-    exportFormat: z.enum(["markdown", "json"]).optional(),
-    enableSkillTool: z.boolean().optional(),
-    enableDynamicAgentCreation: z.boolean().optional()
-  }).optional(),
-  mcpServers: McpServersSchema.optional(),
-  sandbox: PartialSandboxConfigSchema
-});
-var DEFAULT_CONFIG = {
-  version: "0.1.0",
-  userId: uuidv4(),
-  defaultModel: ChatModels.CLAUDE_4_5_SONNET,
-  toolApiKeys: {
-    openweather: void 0,
-    serper: void 0
-  },
-  mcpServers: [],
-  preferences: {
-    maxTokens: 4096,
-    temperature: 0.7,
-    autoSave: true,
-    autoCompact: true,
-    theme: "dark",
-    exportFormat: "markdown",
-    maxIterations: 10,
-    enableSkillTool: true,
-    enableDynamicAgentCreation: false
-  },
-  tools: {
-    enabled: [],
-    disabled: ["blog_publish", "blog_edit", "blog_draft"],
-    // Web-only tools
-    config: {}
-  },
-  trustedTools: [],
-  // No tools trusted by default
-  additionalDirectories: []
-  // No additional directories by default
-};
-function findProjectConfigDir(startDir = process.cwd()) {
-  let currentDir = startDir;
-  const { root } = path2.parse(currentDir);
-  while (currentDir !== root) {
-    const gitPath = path2.join(currentDir, ".git");
-    try {
-      if (existsSync(gitPath)) {
-        return currentDir;
-      }
-    } catch {
-    }
-    currentDir = path2.dirname(currentDir);
-  }
-  return process.cwd();
-}
-async function loadProjectConfig(projectDir) {
-  const configPath = path2.join(projectDir, ".bike4mind", "config.json");
-  try {
-    const data = await fs2.readFile(configPath, "utf-8");
-    const rawConfig = JSON.parse(data);
-    const validated = ProjectConfigSchema.parse(rawConfig);
-    const result = {
-      ...validated,
-      mcpServers: validated.mcpServers ? normalizeMcpServers(validated.mcpServers) : void 0
-    };
-    return result;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    if (error instanceof z.ZodError) {
-      console.error("Project config validation error:", error.issues);
-      return null;
-    }
-    console.error("Failed to load project config:", error);
-    return null;
-  }
-}
-async function loadProjectLocalConfig(projectDir) {
-  const configPath = path2.join(projectDir, ".bike4mind", "local.json");
-  try {
-    const data = await fs2.readFile(configPath, "utf-8");
-    const rawConfig = JSON.parse(data);
-    const validated = ProjectLocalConfigSchema.parse(rawConfig);
-    const result = {
-      ...validated,
-      mcpServers: validated.mcpServers ? normalizeMcpServers(validated.mcpServers) : void 0
-    };
-    return result;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    if (error instanceof z.ZodError) {
-      console.error("Project local config validation error:", error.issues);
-      return null;
-    }
-    console.error("Failed to load project local config:", error);
-    return null;
-  }
-}
-var McpJsonConfigSchema = z.object({
-  mcpServers: McpServersSchema
-});
-async function loadMcpJsonConfig(projectDir) {
-  const mcpConfigPath = path2.join(projectDir, ".mcp.json");
-  try {
-    const data = await fs2.readFile(mcpConfigPath, "utf-8");
-    const rawConfig = JSON.parse(data);
-    const validated = McpJsonConfigSchema.parse(rawConfig);
-    const servers = normalizeMcpServers(validated.mcpServers);
-    return servers;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    if (error instanceof z.ZodError) {
-      console.error(".mcp.json validation error:", error.issues);
-      return null;
-    }
-    console.error("Failed to load .mcp.json:", error);
-    return null;
-  }
-}
-function mergeMcpServers(...serverArrays) {
-  const serverMap = /* @__PURE__ */ new Map();
-  for (const servers of serverArrays) {
-    if (servers) {
-      for (const server of servers) {
-        serverMap.set(server.name, server);
-      }
-    }
-  }
-  return Array.from(serverMap.values());
-}
-function mergeSandboxConfig(base, override) {
-  const resolved = base ?? DEFAULT_SANDBOX_CONFIG;
-  if (!override) return resolved;
-  return {
-    enabled: override.enabled ?? resolved.enabled,
-    mode: override.mode ?? resolved.mode,
-    filesystem: {
-      ...resolved.filesystem,
-      ...override.filesystem ?? {}
-    },
-    network: {
-      ...resolved.network,
-      ...override.network ?? {}
-    },
-    excludedCommands: override.excludedCommands ?? resolved.excludedCommands,
-    allowUnsandboxedCommands: override.allowUnsandboxedCommands ?? resolved.allowUnsandboxedCommands,
-    platform: override.platform ?? resolved.platform
-  };
-}
-function mergeConfigs(global, project, local) {
-  const merged = { ...global };
-  if (project) {
-    if (project.defaultModel) {
-      merged.defaultModel = project.defaultModel;
-    }
-    if (project.preferences) {
-      merged.preferences = {
-        ...merged.preferences,
-        ...project.preferences
-      };
-    }
-    if (project.tools) {
-      merged.tools = {
-        ...merged.tools,
-        enabled: [...merged.tools.enabled || [], ...project.tools.enabled || []],
-        disabled: [...merged.tools.disabled, ...project.tools.denied || []],
-        config: {
-          ...merged.tools.config,
-          ...project.tools.config
-        }
-      };
-    }
-    if (project.mcpServers) {
-      merged.mcpServers = mergeMcpServers(merged.mcpServers, project.mcpServers);
-    }
-    if (project.sandbox) {
-      merged.sandbox = mergeSandboxConfig(merged.sandbox, project.sandbox);
-    }
-  }
-  if (local) {
-    if (local.trustedTools) {
-      const trustedSet = /* @__PURE__ */ new Set([...merged.trustedTools || [], ...local.trustedTools]);
-      merged.trustedTools = Array.from(trustedSet);
-    }
-    if (local.toolApiKeys) {
-      merged.toolApiKeys = {
-        ...merged.toolApiKeys,
-        ...local.toolApiKeys
-      };
-    }
-    if (local.preferences) {
-      merged.preferences = {
-        ...merged.preferences,
-        ...local.preferences
-      };
-    }
-    if (local.mcpServers) {
-      merged.mcpServers = mergeMcpServers(merged.mcpServers, local.mcpServers);
-    }
-    if (local.sandbox) {
-      merged.sandbox = mergeSandboxConfig(merged.sandbox, local.sandbox);
-    }
-  }
-  return merged;
-}
-var ConfigStore = class {
-  constructor(configPath) {
-    this.config = null;
-    this.projectConfigDir = null;
-    this.configPath = configPath || path2.join(homedir(), ".bike4mind", "config.json");
-  }
-  /**
-   * Initialize config directory
-   */
-  async init() {
-    const dir = path2.dirname(this.configPath);
-    try {
-      await fs2.mkdir(dir, { recursive: true });
-    } catch (error) {
-      console.error("Failed to initialize config directory:", error);
-      throw error;
-    }
-  }
-  /**
-   * Load configuration from disk with Zod validation
-   * Merges global → project → local configs
-   */
-  async load() {
-    if (this.config) {
-      return this.config;
-    }
-    try {
-      let globalConfig;
-      try {
-        try {
-          const stats = await fs2.stat(this.configPath);
-          const mode = stats.mode & 511;
-          if (mode !== 384) {
-            console.warn(`\u26A0\uFE0F  Config file has insecure permissions (${mode.toString(8)}). Setting to 0600...`);
-            await fs2.chmod(this.configPath, 384);
-          }
-        } catch (statError) {
-        }
-        const data = await fs2.readFile(this.configPath, "utf-8");
-        const rawConfig = JSON.parse(data);
-        if (rawConfig.apiConfig && "environment" in rawConfig.apiConfig) {
-          const oldApiConfig = rawConfig.apiConfig;
-          if (oldApiConfig.environment === "custom" && oldApiConfig.customUrl) {
-            rawConfig.apiConfig = { customUrl: oldApiConfig.customUrl };
-          } else {
-            rawConfig.apiConfig = {};
-          }
-        }
-        const validated = CliConfigSchema.parse(rawConfig);
-        const normalizedMcpServers = normalizeMcpServers(validated.mcpServers);
-        globalConfig = {
-          ...DEFAULT_CONFIG,
-          ...validated,
-          auth: validated.auth,
-          // Explicitly preserve auth field
-          mcpServers: normalizedMcpServers,
-          preferences: {
-            ...DEFAULT_CONFIG.preferences,
-            ...validated.preferences
-          },
-          tools: {
-            ...DEFAULT_CONFIG.tools,
-            ...validated.tools
-          },
-          toolApiKeys: {
-            ...DEFAULT_CONFIG.toolApiKeys,
-            ...validated.toolApiKeys || {}
-          },
-          trustedTools: validated.trustedTools || []
-        };
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          globalConfig = { ...DEFAULT_CONFIG };
-        } else if (error instanceof z.ZodError) {
-          console.error("Global config validation error:", error.issues);
-          console.error("Using default configuration");
-          globalConfig = { ...DEFAULT_CONFIG };
-        } else {
-          throw error;
-        }
-      }
-      let projectConfig = null;
-      let projectLocalConfig = null;
-      let mcpJsonServers = null;
-      if (process.env.B4M_NO_PROJECT_CONFIG !== "1") {
-        this.projectConfigDir = findProjectConfigDir();
-        if (this.projectConfigDir) {
-          projectConfig = await loadProjectConfig(this.projectConfigDir);
-          projectLocalConfig = await loadProjectLocalConfig(this.projectConfigDir);
-          mcpJsonServers = await loadMcpJsonConfig(this.projectConfigDir);
-          if (projectConfig) {
-            logger.debug(`\u{1F4C1} Project config loaded from: ${this.projectConfigDir}/.bike4mind/`);
-          }
-          if (mcpJsonServers && mcpJsonServers.length > 0) {
-            logger.debug(`\u{1F4C1} Project MCP config loaded from: ${this.projectConfigDir}/.mcp.json`);
-          }
-        }
-      } else {
-        this.projectConfigDir = null;
-      }
-      const mergedConfig = mergeConfigs(globalConfig, projectConfig, projectLocalConfig);
-      if (mcpJsonServers && mcpJsonServers.length > 0) {
-        mergedConfig.mcpServers = mergeMcpServers(mcpJsonServers, mergedConfig.mcpServers);
-      }
-      this.config = mergedConfig;
-      return this.config;
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return this.reset();
-      }
-      if (error instanceof z.ZodError) {
-        console.error("Config validation error:", error.issues);
-        console.error("Resetting to default configuration");
-        return this.reset();
-      }
-      console.error("Failed to load config:", error);
-      throw error;
-    }
-  }
-  /**
-   * Save configuration to disk
-   */
-  async save(config) {
-    await this.init();
-    if (config) {
-      const existingConfig = await this.load();
-      this.config = {
-        ...existingConfig,
-        ...config,
-        auth: config.auth !== void 0 ? config.auth : existingConfig.auth,
-        preferences: {
-          ...existingConfig.preferences,
-          ...config.preferences || {}
-        },
-        tools: {
-          ...existingConfig.tools,
-          ...config.tools || {}
-        },
-        toolApiKeys: {
-          ...existingConfig.toolApiKeys,
-          ...config.toolApiKeys || {}
-        }
-      };
-    }
-    if (!this.config) {
-      throw new Error("No configuration to save");
-    }
-    try {
-      await fs2.writeFile(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
-      await fs2.chmod(this.configPath, 384);
-    } catch (error) {
-      console.error("Failed to save config:", error);
-      throw error;
-    }
-  }
-  /**
-   * Reset configuration to defaults
-   */
-  async reset() {
-    this.config = { ...DEFAULT_CONFIG, userId: uuidv4() };
-    await this.save();
-    return this.config;
-  }
-  /**
-   * Get current configuration
-   */
-  async get() {
-    return this.load();
-  }
-  /**
-   * Update a specific configuration value
-   */
-  async update(updates) {
-    await this.save(updates);
-  }
-  /**
-   * Add MCP server configuration
-   */
-  async addMcpServer(server) {
-    const config = await this.load();
-    config.mcpServers = config.mcpServers.filter((s) => s.name !== server.name);
-    config.mcpServers.push(server);
-    await this.save(config);
-  }
-  /**
-   * Remove MCP server configuration
-   */
-  async removeMcpServer(name) {
-    const config = await this.load();
-    config.mcpServers = config.mcpServers.filter((s) => s.name !== name);
-    await this.save(config);
-  }
-  /**
-   * Enable/disable MCP server
-   */
-  async toggleMcpServer(name, enabled) {
-    const config = await this.load();
-    const server = config.mcpServers.find((s) => s.name === name);
-    if (server) {
-      server.enabled = enabled;
-      await this.save(config);
-    }
-  }
-  /**
-   * Add a tool to trusted tools list
-   */
-  async trustTool(toolName) {
-    const config = await this.load();
-    if (!config.trustedTools) {
-      config.trustedTools = [];
-    }
-    if (!config.trustedTools.includes(toolName)) {
-      config.trustedTools.push(toolName);
-      await this.save(config);
-    }
-  }
-  /**
-   * Remove a tool from trusted tools list
-   */
-  async untrustTool(toolName) {
-    const config = await this.load();
-    if (config.trustedTools) {
-      config.trustedTools = config.trustedTools.filter((t) => t !== toolName);
-      await this.save(config);
-    }
-  }
-  /**
-   * Get list of trusted tools
-   */
-  async getTrustedTools() {
-    const config = await this.load();
-    return config.trustedTools || [];
-  }
-  /**
-   * Clear all trusted tools
-   */
-  async clearTrustedTools() {
-    const config = await this.load();
-    config.trustedTools = [];
-    await this.save(config);
-  }
-  /**
-   * Get authentication tokens
-   */
-  async getAuthTokens() {
-    const config = await this.load();
-    return config.auth || null;
-  }
-  /**
-   * Set authentication tokens
-   */
-  async setAuthTokens(tokens) {
-    const config = await this.load();
-    config.auth = tokens;
-    await this.save(config);
-  }
-  /**
-   * Clear authentication tokens (logout)
-   */
-  async clearAuthTokens() {
-    const config = await this.load();
-    config.auth = void 0;
-    await this.save(config);
-  }
-  /**
-   * Check if user is authenticated
-   */
-  async isAuthenticated() {
-    const tokens = await this.getAuthTokens();
-    if (!tokens) return false;
-    const expiresAt = new Date(tokens.expiresAt);
-    return expiresAt > /* @__PURE__ */ new Date();
-  }
-  /**
-   * Get API configuration
-   */
-  async getApiConfig() {
-    const config = await this.load();
-    return config.apiConfig;
-  }
-  /**
-   * Set custom API URL for self-hosted Bike4Mind instance
-   * Pass null to reset to Bike4Mind main service
-   */
-  async setCustomApiUrl(url) {
-    const config = await this.load();
-    if (url === null) {
-      config.apiConfig = void 0;
-    } else {
-      config.apiConfig = { customUrl: url };
-    }
-    await this.save(config);
-  }
-  /**
-   * Get project config directory (if any)
-   */
-  getProjectConfigDir() {
-    return this.projectConfigDir;
-  }
-  /**
-   * Initialize project config directory
-   * Creates .bike4mind/ directory and ensures local.json is gitignored
-   * Does NOT auto-create config.json (user creates that manually)
-   */
-  async initProjectConfig() {
-    const projectDir = this.projectConfigDir || findProjectConfigDir();
-    if (!projectDir) {
-      return;
-    }
-    const configDir = path2.join(projectDir, ".bike4mind");
-    await fs2.mkdir(configDir, { recursive: true });
-    await this.ensureGitignore(projectDir);
-  }
-  /**
-   * Ensure .gitignore includes .bike4mind/local.json
-   */
-  async ensureGitignore(projectDir) {
-    const gitignorePath = path2.join(projectDir, ".gitignore");
-    const entryToAdd = ".bike4mind/local.json";
-    try {
-      let gitignoreContent = "";
-      try {
-        gitignoreContent = await fs2.readFile(gitignorePath, "utf-8");
-      } catch {
-      }
-      if (gitignoreContent.includes(entryToAdd)) {
-        return;
-      }
-      const newContent = gitignoreContent.trim() + (gitignoreContent ? "\n" : "") + `
-# Bike4Mind local config (developer-specific)
-${entryToAdd}
-`;
-      await fs2.writeFile(gitignorePath, newContent, "utf-8");
-      console.log(`\u2705 Added ${entryToAdd} to .gitignore`);
-    } catch (error) {
-      console.warn(`\u26A0\uFE0F  Failed to update .gitignore:`, error);
-    }
-  }
-  /**
-   * Save project config to .bike4mind/config.json
-   */
-  async saveProjectConfig(config, projectDir) {
-    const targetDir = projectDir || this.projectConfigDir || process.cwd();
-    const configPath = path2.join(targetDir, ".bike4mind", "config.json");
-    await fs2.mkdir(path2.dirname(configPath), { recursive: true });
-    const validated = ProjectConfigSchema.parse(config);
-    await fs2.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
-    console.log(`\u2705 Saved project config to: ${configPath}`);
-  }
-  /**
-   * Save project-local config to .bike4mind/local.json
-   */
-  async saveProjectLocalConfig(config, projectDir) {
-    const targetDir = projectDir || this.projectConfigDir || process.cwd();
-    const configPath = path2.join(targetDir, ".bike4mind", "local.json");
-    await fs2.mkdir(path2.dirname(configPath), { recursive: true });
-    const validated = ProjectLocalConfigSchema.parse(config);
-    await fs2.writeFile(configPath, JSON.stringify(validated, null, 2), "utf-8");
-    await fs2.chmod(configPath, 384);
-    console.log(`\u2705 Saved project-local config to: ${configPath}`);
-  }
-  /**
-   * Load raw project config (without merging)
-   */
-  async loadRawProjectConfig() {
-    if (!this.projectConfigDir) {
-      return null;
-    }
-    return loadProjectConfig(this.projectConfigDir);
-  }
-  /**
-   * Load raw project-local config (without merging)
-   */
-  async loadRawProjectLocalConfig() {
-    if (!this.projectConfigDir) {
-      return null;
-    }
-    return loadProjectLocalConfig(this.projectConfigDir);
-  }
-  /**
-   * Add a directory to the allowed directories list
-   * Persists to global config
-   */
-  async addDirectory(dirPath) {
-    const config = await this.load();
-    if (!config.additionalDirectories) {
-      config.additionalDirectories = [];
-    }
-    const resolvedPath = path2.resolve(dirPath);
-    if (!config.additionalDirectories.includes(resolvedPath)) {
-      config.additionalDirectories.push(resolvedPath);
-      await this.save(config);
-    }
-  }
-  /**
-   * Remove a directory from the allowed directories list
-   */
-  async removeDirectory(dirPath) {
-    const config = await this.load();
-    if (config.additionalDirectories) {
-      const resolvedPath = path2.resolve(dirPath);
-      config.additionalDirectories = config.additionalDirectories.filter((d) => path2.resolve(d) !== resolvedPath);
-      await this.save(config);
-    }
-  }
-  /**
-   * Get all additional directories (merged from global + project configs)
-   * Returns resolved absolute paths
-   */
-  async getAdditionalDirectories() {
-    const config = await this.load();
-    const dirs = /* @__PURE__ */ new Set();
-    if (config.additionalDirectories) {
-      for (const dir of config.additionalDirectories) {
-        dirs.add(path2.resolve(dir));
-      }
-    }
-    const projectConfig = await this.loadRawProjectConfig();
-    if (projectConfig?.additionalDirectories) {
-      const projectRoot = this.projectConfigDir || process.cwd();
-      for (const dir of projectConfig.additionalDirectories) {
-        dirs.add(path2.resolve(projectRoot, dir));
-      }
-    }
-    return Array.from(dirs);
-  }
-};
-
-export {
-  logger,
-  ConfigStore
-};