autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-46C73ZKK.cjs

@@ -0,0 +1,663 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkMXVIDIC6cjs = require('./chunk-MXVIDIC6.cjs');
+
+
+
+
+var _chunkYWTIXHU6cjs = require('./chunk-YWTIXHU6.cjs');
+
+
+var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
+
+// src/config.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _yaml = require('yaml'); var _yaml2 = _interopRequireDefault(_yaml);
+var DEFAULT_CONFIG_PATH = _chunkE26KKI46cjs.AUTOHAND_FILES.configJson;
+var TOML_CONFIG_PATH = _chunkE26KKI46cjs.AUTOHAND_FILES.configToml;
+var YAML_CONFIG_PATH = _chunkE26KKI46cjs.AUTOHAND_FILES.configYaml;
+var YML_CONFIG_PATH = _chunkE26KKI46cjs.AUTOHAND_FILES.configYml;
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_LLAMACPP_URL = "http://localhost:8080";
+var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
+var DEFAULT_MLX_URL = "http://localhost:8080";
+var DEFAULT_LLMGATEWAY_URL = "https://api.llmgateway.io/v1";
+var DEFAULT_ZAI_URL = "https://api.z.ai/api/paas/v4";
+var DEFAULT_DEEPSEEK_URL = "https://api.deepseek.com";
+function normalizeProviderName(provider) {
+  if (provider === void 0) {
+    return void 0;
+  }
+  if (provider === "vertex") {
+    return "vertexai";
+  }
+  const validProviders = [
+    "openrouter",
+    "ollama",
+    "llamacpp",
+    "openai",
+    "mlx",
+    "llmgateway",
+    "azure",
+    "zai",
+    "vertexai",
+    "xai",
+    "cerebras",
+    "nvidia",
+    "deepseek"
+  ];
+  if (typeof provider === "string" && validProviders.includes(provider)) {
+    return provider;
+  }
+  return void 0;
+}
+function getDefaultConfigPath() {
+  return DEFAULT_CONFIG_PATH;
+}
+async function detectConfigPath(customPath) {
+  if (customPath) {
+    return _path2.default.resolve(customPath);
+  }
+  const envPath = process.env.AUTOHAND_CONFIG;
+  if (envPath) {
+    return _path2.default.resolve(envPath);
+  }
+  if (await _fsextra2.default.pathExists(TOML_CONFIG_PATH)) {
+    return TOML_CONFIG_PATH;
+  }
+  if (await _fsextra2.default.pathExists(YAML_CONFIG_PATH)) {
+    return YAML_CONFIG_PATH;
+  }
+  if (await _fsextra2.default.pathExists(YML_CONFIG_PATH)) {
+    return YML_CONFIG_PATH;
+  }
+  return DEFAULT_CONFIG_PATH;
+}
+async function checkConfigFilesExist(dir) {
+  const files = [];
+  for (const filename of ["config.json", "config.toml", "config.yaml", "config.yml"]) {
+    const candidate = _path2.default.join(dir, filename);
+    if (await _fsextra2.default.pathExists(candidate)) {
+      files.push(filename);
+    }
+  }
+  return files.sort();
+}
+function isYamlFile(filePath) {
+  const ext = _path2.default.extname(filePath).toLowerCase();
+  return ext === ".yaml" || ext === ".yml";
+}
+function isTomlFile(filePath) {
+  return _path2.default.extname(filePath).toLowerCase() === ".toml";
+}
+function stripTomlComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inDouble && char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (!inDouble && char === "'") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (!inSingle && char === '"') {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && char === "#") {
+      return line.slice(0, i).trim();
+    }
+  }
+  return line.trim();
+}
+function splitTomlPath(input) {
+  return input.split(".").map((part) => part.trim().replace(/^"(.*)"$/, "$1")).filter(Boolean);
+}
+function parseTomlValue(raw) {
+  const value = raw.trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    if (value.startsWith('"')) {
+      try {
+        return JSON.parse(value);
+      } catch (e) {
+        return value.slice(1, -1);
+      }
+    }
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((entry) => parseTomlValue(entry.trim())).filter((entry) => typeof entry !== "object");
+  }
+  return value;
+}
+function getOrCreateTomlSection(root, pathParts) {
+  let current = root;
+  for (const part of pathParts) {
+    const existing = current[part];
+    if (Array.isArray(existing)) {
+      const last = existing[existing.length - 1];
+      if (last && typeof last === "object" && !Array.isArray(last)) {
+        current = last;
+        continue;
+      }
+    }
+    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  return current;
+}
+function getOrCreateTomlArraySection(root, pathParts) {
+  const parent = getOrCreateTomlSection(root, pathParts.slice(0, -1));
+  const key = pathParts[pathParts.length - 1];
+  const existing = parent[key];
+  if (!Array.isArray(existing)) {
+    parent[key] = [];
+  }
+  const section = {};
+  parent[key].push(section);
+  return section;
+}
+function parseTomlConfig(content) {
+  const root = {};
+  let current = root;
+  let hasData = false;
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = stripTomlComment(rawLine);
+    if (!line) continue;
+    const arraySection = line.match(/^\[\[([^\]]+)]]$/);
+    if (arraySection) {
+      current = getOrCreateTomlArraySection(root, splitTomlPath(arraySection[1]));
+      hasData = true;
+      continue;
+    }
+    const section = line.match(/^\[([^\]]+)]$/);
+    if (section) {
+      current = getOrCreateTomlSection(root, splitTomlPath(section[1]));
+      hasData = true;
+      continue;
+    }
+    const kv = line.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+    if (!kv) {
+      throw new Error(`Invalid TOML line: ${rawLine.trim()}`);
+    }
+    current[kv[1]] = parseTomlValue(kv[2]);
+    hasData = true;
+  }
+  if (!hasData) {
+    throw new Error(
+      `Config file is empty or contains no valid data. You can fix this by editing the file, or delete it and run 'autohand --setup' to recreate.`
+    );
+  }
+  return root;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function formatTomlKey(key) {
+  return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
+}
+function formatTomlValue(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value) && value.every((entry) => !isPlainObject(entry) && !Array.isArray(entry))) {
+    return `[${value.map((entry) => formatTomlValue(entry)).filter((entry) => entry !== null).join(", ")}]`;
+  }
+  return null;
+}
+function stringifyTomlObject(data) {
+  const lines = [];
+  const writeSection = (sectionPath, section) => {
+    const scalarEntries = Object.entries(section).filter(([, value]) => formatTomlValue(value) !== null);
+    if (sectionPath.length > 0) {
+      if (lines.length > 0) lines.push("");
+      lines.push(`[${sectionPath.map(formatTomlKey).join(".")}]`);
+    }
+    for (const [key, value] of scalarEntries) {
+      const formatted = formatTomlValue(value);
+      if (formatted !== null) {
+        lines.push(`${formatTomlKey(key)} = ${formatted}`);
+      }
+    }
+    for (const [key, value] of Object.entries(section)) {
+      if (isPlainObject(value)) {
+        writeSection([...sectionPath, key], value);
+      } else if (Array.isArray(value) && value.every(isPlainObject)) {
+        for (const item of value) {
+          if (lines.length > 0) lines.push("");
+          const childPath = [...sectionPath, key];
+          lines.push(`[[${childPath.map(formatTomlKey).join(".")}]]`);
+          for (const [childKey, childValue] of Object.entries(item)) {
+            const formatted = formatTomlValue(childValue);
+            if (formatted !== null) {
+              lines.push(`${formatTomlKey(childKey)} = ${formatted}`);
+            }
+          }
+          for (const [childKey, childValue] of Object.entries(item)) {
+            if (isPlainObject(childValue)) {
+              writeSection([...childPath, childKey], childValue);
+            }
+          }
+        }
+      }
+    }
+  };
+  writeSection([], data);
+  return `${lines.join("\n")}
+`;
+}
+async function parseConfigFile(configPath) {
+  const rawContent = await _fsextra2.default.readFile(configPath, "utf8");
+  const content = rawContent.charCodeAt(0) === 65279 ? rawContent.slice(1) : rawContent;
+  if (isYamlFile(configPath)) {
+    const parsed = _yaml2.default.parse(content);
+    if (parsed === null || parsed === void 0) {
+      throw new Error(
+        `Config file is empty or contains no valid data. You can fix this by editing ${configPath}, or delete it and run 'autohand --setup' to recreate.`
+      );
+    }
+    return parsed;
+  }
+  if (isTomlFile(configPath)) {
+    return parseTomlConfig(content);
+  }
+  return JSON.parse(content);
+}
+async function loadConfig(customPath, workspaceRoot) {
+  const configPath = await detectConfigPath(customPath);
+  const configDir = _path2.default.dirname(configPath);
+  const configFiles = await checkConfigFilesExist(configDir);
+  if (configFiles.length > 1) {
+    throw new Error(
+      `Multiple config files found in ${configDir} (${configFiles.join(", ")}). Only one config file is allowed. Please review and remove the duplicate, or set the AUTOHAND_CONFIG environment variable to specify which one to use.`
+    );
+  }
+  await _fsextra2.default.ensureDir(_path2.default.dirname(configPath));
+  let isNewConfig = false;
+  if (!await _fsextra2.default.pathExists(configPath)) {
+    const defaultConfig = {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: "",
+        baseUrl: "https://openrouter.ai/api/v1",
+        model: "openrouter/auto"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        theme: "dark",
+        autoConfirm: false,
+        promptSuggestions: true
+      },
+      telemetry: {
+        enabled: false
+      },
+      autoReport: {
+        enabled: true
+      },
+      agent: {
+        toolSelectionCache: true
+      }
+    };
+    await _fsextra2.default.writeJson(configPath, defaultConfig, { spaces: 2 });
+    isNewConfig = true;
+  }
+  let parsed;
+  try {
+    parsed = await parseConfigFile(configPath);
+  } catch (error) {
+    const originalMessage = error.message;
+    const alreadyHasSuggestion = originalMessage.includes("autohand --setup");
+    const suggestion = alreadyHasSuggestion ? "" : ` You can fix this by editing ${configPath}, or delete it and run 'autohand --setup' to recreate.`;
+    throw new Error(
+      `Failed to parse config at ${configPath}: ${originalMessage}${suggestion}`
+    );
+  }
+  const normalized = normalizeConfig(parsed);
+  let workspaceSettings = null;
+  if (workspaceRoot) {
+    workspaceSettings = await _chunkMXVIDIC6cjs.loadLocalProjectSettings.call(void 0, workspaceRoot);
+  }
+  const withWorkspace = mergeWorkspaceSettings(normalized, workspaceSettings);
+  const withEnv = mergeEnvVariables(withWorkspace);
+  _chunkYWTIXHU6cjs.configureThemeSources.call(void 0, { inlineThemes: _optionalChain([withEnv, 'access', _ => _.ui, 'optionalAccess', _2 => _2.customThemes]) });
+  validateConfig(withEnv, configPath);
+  const themeName = _optionalChain([withEnv, 'access', _3 => _3.ui, 'optionalAccess', _4 => _4.theme]) || "dark";
+  _chunkYWTIXHU6cjs.autoInitTheme.call(void 0, themeName);
+  return { ...withEnv, configPath, isNewConfig };
+}
+function mergeWorkspaceSettings(globalConfig, workspaceSettings) {
+  if (!workspaceSettings) {
+    return globalConfig;
+  }
+  const merged = { ...globalConfig };
+  if (workspaceSettings.provider !== void 0) {
+    merged.provider = workspaceSettings.provider;
+  }
+  if (workspaceSettings.model !== void 0) {
+    const provider = workspaceSettings.provider || merged.provider;
+    if (provider && merged[provider]) {
+      merged[provider].model = workspaceSettings.model;
+    }
+  }
+  if (workspaceSettings.agent) {
+    merged.agent = {
+      ...merged.agent,
+      ...workspaceSettings.agent
+    };
+  }
+  if (workspaceSettings.network) {
+    merged.network = {
+      ...merged.network,
+      ...workspaceSettings.network
+    };
+  }
+  if (workspaceSettings.telemetry) {
+    merged.telemetry = {
+      ...merged.telemetry,
+      ...workspaceSettings.telemetry
+    };
+  }
+  if (workspaceSettings.permissions) {
+    merged.permissions = {
+      ...merged.permissions,
+      ...workspaceSettings.permissions
+    };
+  }
+  return merged;
+}
+function mergeEnvVariables(config) {
+  config = {
+    ...config,
+    api: {
+      baseUrl: process.env.AUTOHAND_API_URL || _optionalChain([config, 'access', _5 => _5.api, 'optionalAccess', _6 => _6.baseUrl]) || "https://api.autohand.ai",
+      companySecret: process.env.AUTOHAND_SECRET || _optionalChain([config, 'access', _7 => _7.api, 'optionalAccess', _8 => _8.companySecret]) || ""
+    }
+  };
+  if (process.env.AZURE_OPENAI_KEY || process.env.AZURE_OPENAI_ENDPOINT || process.env.AZURE_OPENAI_DEPLOYMENT) {
+    const azureEnv = {
+      apiKey: process.env.AZURE_OPENAI_KEY,
+      baseUrl: process.env.AZURE_OPENAI_ENDPOINT,
+      deploymentName: process.env.AZURE_OPENAI_DEPLOYMENT,
+      apiVersion: process.env.AZURE_OPENAI_API_VERSION,
+      tenantId: process.env.AZURE_TENANT_ID,
+      clientId: process.env.AZURE_CLIENT_ID,
+      clientSecret: process.env.AZURE_CLIENT_SECRET
+    };
+    const existing = _nullishCoalesce(config.azure, () => ( {
+      model: _nullishCoalesce(azureEnv.deploymentName, () => ( "gpt-4o"))
+    }));
+    config = {
+      ...config,
+      azure: {
+        ...existing,
+        ...azureEnv.apiKey && { apiKey: azureEnv.apiKey },
+        ...azureEnv.baseUrl && { baseUrl: azureEnv.baseUrl },
+        ...azureEnv.deploymentName && {
+          deploymentName: azureEnv.deploymentName
+        },
+        ...azureEnv.apiVersion && { apiVersion: azureEnv.apiVersion },
+        ...azureEnv.tenantId && { tenantId: azureEnv.tenantId },
+        ...azureEnv.clientId && { clientId: azureEnv.clientId },
+        ...azureEnv.clientSecret && { clientSecret: azureEnv.clientSecret }
+      }
+    };
+  }
+  return config;
+}
+function normalizeConfig(config) {
+  if (config === null || config === void 0 || typeof config !== "object") {
+    throw new Error(
+      `Config file produced an invalid value (got ${config === null ? "null" : typeof config}). Delete the config file and run 'autohand --setup' to recreate it.`
+    );
+  }
+  if (isModernConfig(config)) {
+    const provider = _nullishCoalesce(normalizeProviderName(config.provider), () => ( "openrouter"));
+    return { ...config, provider };
+  }
+  if (isLegacyConfig(config)) {
+    return {
+      provider: "openrouter",
+      openrouter: {
+        apiKey: _nullishCoalesce(config.api_key, () => ( "replace-me")),
+        baseUrl: _nullishCoalesce(config.base_url, () => ( DEFAULT_BASE_URL)),
+        model: "anthropic/claude-4-sonnet"
+      },
+      workspace: {
+        defaultRoot: process.cwd(),
+        allowDangerousOps: false
+      },
+      ui: {
+        autoConfirm: _nullishCoalesce(config.dry_run, () => ( false)),
+        theme: "dark",
+        promptSuggestions: true
+      }
+    };
+  }
+  return config;
+}
+function isModernConfig(config) {
+  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object" || typeof config.azure === "object" || typeof config.zai === "object" || typeof config.vertexai === "object" || typeof config.xai === "object" || typeof config.cerebras === "object" || typeof config.nvidia === "object" || typeof config.deepseek === "object";
+}
+function isLegacyConfig(config) {
+  return typeof config.api_key === "string";
+}
+function validateConfig(config, configPath) {
+  if (config.workspace) {
+    if (config.workspace.defaultRoot && typeof config.workspace.defaultRoot !== "string") {
+      throw new Error(
+        `workspace.defaultRoot must be a string in ${configPath}`
+      );
+    }
+    if (config.workspace.allowDangerousOps !== void 0 && typeof config.workspace.allowDangerousOps !== "boolean") {
+      throw new Error(
+        `workspace.allowDangerousOps must be boolean in ${configPath}`
+      );
+    }
+  }
+  if (config.ui) {
+    if (config.ui.theme && typeof config.ui.theme !== "string") {
+      throw new Error(`ui.theme must be a string in ${configPath}`);
+    }
+    if (config.ui.theme && typeof config.ui.theme === "string" && !_chunkYWTIXHU6cjs.themeExists.call(void 0, config.ui.theme)) {
+      console.warn(
+        `Theme '${config.ui.theme}' not found \u2014 falling back to default.`
+      );
+    }
+    if (config.ui.autoConfirm !== void 0 && typeof config.ui.autoConfirm !== "boolean") {
+      throw new Error(`ui.autoConfirm must be boolean in ${configPath}`);
+    }
+    if (config.ui.promptSuggestions !== void 0 && typeof config.ui.promptSuggestions !== "boolean") {
+      throw new Error(`ui.promptSuggestions must be boolean in ${configPath}`);
+    }
+  }
+  if (config.agent) {
+    if (config.agent.toolSelectionCache !== void 0 && typeof config.agent.toolSelectionCache !== "boolean") {
+      throw new Error(`agent.toolSelectionCache must be boolean in ${configPath}`);
+    }
+  }
+  if (config.mcp) {
+    if (config.mcp.enabled !== void 0 && typeof config.mcp.enabled !== "boolean") {
+      throw new Error(`mcp.enabled must be boolean in ${configPath}`);
+    }
+    if (config.mcp.servers !== void 0) {
+      if (!Array.isArray(config.mcp.servers)) {
+        throw new Error(`mcp.servers must be an array in ${configPath}`);
+      }
+      for (const server of config.mcp.servers) {
+        if (!server.name || typeof server.name !== "string") {
+          throw new Error(
+            `mcp.servers[].name must be a non-empty string in ${configPath}`
+          );
+        }
+        if (!["stdio", "sse", "http"].includes(server.transport)) {
+          throw new Error(
+            `mcp.servers[].transport must be 'stdio', 'sse', or 'http' in ${configPath}`
+          );
+        }
+        if (server.transport === "stdio" && (!server.command || typeof server.command !== "string")) {
+          throw new Error(
+            `mcp.servers[].command is required for stdio transport in ${configPath}`
+          );
+        }
+        if ((server.transport === "sse" || server.transport === "http") && (!server.url || typeof server.url !== "string")) {
+          throw new Error(
+            `mcp.servers[].url is required for ${server.transport} transport in ${configPath}`
+          );
+        }
+      }
+    }
+  }
+  if (config.externalAgents) {
+    if (config.externalAgents.enabled !== void 0 && typeof config.externalAgents.enabled !== "boolean") {
+      throw new Error(
+        `externalAgents.enabled must be boolean in ${configPath}`
+      );
+    }
+    if (config.externalAgents.paths !== void 0) {
+      if (!Array.isArray(config.externalAgents.paths)) {
+        throw new Error(
+          `externalAgents.paths must be an array in ${configPath}`
+        );
+      }
+      for (const p of config.externalAgents.paths) {
+        if (typeof p !== "string") {
+          throw new Error(
+            `externalAgents.paths must contain only strings in ${configPath}`
+          );
+        }
+      }
+    }
+  }
+}
+function resolveWorkspaceRoot(config, requestedPath) {
+  const candidate = _nullishCoalesce(_nullishCoalesce(requestedPath, () => ( process.cwd())), () => ( _optionalChain([config, 'access', _9 => _9.workspace, 'optionalAccess', _10 => _10.defaultRoot])));
+  return _path2.default.resolve(candidate);
+}
+function getProviderConfig(config, provider) {
+  const chosen = _nullishCoalesce(_nullishCoalesce(provider, () => ( config.provider)), () => ( "openrouter"));
+  const configByProvider = {
+    openrouter: config.openrouter,
+    ollama: config.ollama,
+    llamacpp: config.llamacpp,
+    openai: config.openai,
+    mlx: config.mlx,
+    llmgateway: config.llmgateway,
+    azure: config.azure,
+    zai: config.zai,
+    vertexai: config.vertexai,
+    xai: config.xai,
+    cerebras: config.cerebras,
+    nvidia: config.nvidia,
+    deepseek: config.deepseek
+  };
+  const entry = configByProvider[chosen];
+  if (!entry) {
+    return null;
+  }
+  if (chosen === "openai") {
+    const openAIEntry = entry;
+    if (!openAIEntry.model) {
+      return null;
+    }
+    if (openAIEntry.authMode === "chatgpt") {
+      if (!_optionalChain([openAIEntry, 'access', _11 => _11.chatgptAuth, 'optionalAccess', _12 => _12.accessToken]) || !_optionalChain([openAIEntry, 'access', _13 => _13.chatgptAuth, 'optionalAccess', _14 => _14.accountId])) {
+        return null;
+      }
+    } else {
+      if (!openAIEntry.apiKey || openAIEntry.apiKey === "replace-me") {
+        return null;
+      }
+    }
+  } else if (chosen === "openrouter" || chosen === "llmgateway" || chosen === "zai" || chosen === "nvidia" || chosen === "deepseek") {
+    const { apiKey, model } = entry;
+    if (!apiKey || apiKey === "replace-me" || !model) {
+      return null;
+    }
+  } else if (chosen === "vertexai") {
+    const { authToken, projectId, model } = entry;
+    if (!authToken || !projectId || !model) {
+      return null;
+    }
+  } else {
+    if (chosen === "llamacpp") {
+      return {
+        ...entry,
+        model: _nullishCoalesce(entry.model, () => ( "local")),
+        baseUrl: _nullishCoalesce(entry.baseUrl, () => ( defaultBaseUrlFor(chosen, entry.port)))
+      };
+    }
+    if (!entry.model) {
+      return null;
+    }
+  }
+  return {
+    ...entry,
+    baseUrl: _nullishCoalesce(entry.baseUrl, () => ( defaultBaseUrlFor(chosen, entry.port)))
+  };
+}
+function defaultBaseUrlFor(provider, port) {
+  if (provider === "openrouter") return DEFAULT_BASE_URL;
+  if (provider === "llmgateway") return DEFAULT_LLMGATEWAY_URL;
+  if (provider === "zai") return DEFAULT_ZAI_URL;
+  if (provider === "deepseek") return DEFAULT_DEEPSEEK_URL;
+  const p = port ? port.toString() : void 0;
+  switch (provider) {
+    case "ollama":
+      return p ? `http://localhost:${p}` : DEFAULT_OLLAMA_URL;
+    case "llamacpp":
+      return p ? `http://localhost:${p}` : DEFAULT_LLAMACPP_URL;
+    case "openai":
+      return DEFAULT_OPENAI_URL;
+    case "mlx":
+      return p ? `http://localhost:${p}` : DEFAULT_MLX_URL;
+    case "nvidia":
+      return "https://integrate.api.nvidia.com/v1";
+    default:
+      return void 0;
+  }
+}
+async function saveConfig(config) {
+  const { configPath, ...data } = config;
+  delete data.isNewConfig;
+  if (isYamlFile(configPath)) {
+    const yamlContent = _yaml2.default.stringify(data, { indent: 2 });
+    await _fsextra2.default.writeFile(configPath, yamlContent, "utf8");
+  } else if (isTomlFile(configPath)) {
+    await _fsextra2.default.writeFile(configPath, stringifyTomlObject(data), "utf8");
+  } else {
+    await _fsextra2.default.writeJson(configPath, data, { spaces: 2 });
+  }
+}
+
+
+
+
+
+
+
+exports.getDefaultConfigPath = getDefaultConfigPath; exports.loadConfig = loadConfig; exports.resolveWorkspaceRoot = resolveWorkspaceRoot; exports.getProviderConfig = getProviderConfig; exports.saveConfig = saveConfig;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunk-46MTALKD.js

@@ -0,0 +1,44 @@
+import {
+  getTheme,
+  isThemeInitialized
+} from "./chunk-JAQO6XDB.js";
+
+// src/commands/commandTheme.ts
+import chalk from "chalk";
+function createCommandTheme() {
+  const theme = isThemeInitialized() ? getTheme() : null;
+  const fg = (token, fallback) => {
+    return (value) => theme ? theme.fg(token, value) : fallback(value);
+  };
+  const accent = fg("accent", chalk.cyan);
+  const muted = fg("muted", chalk.gray);
+  const text = fg("text", chalk.white);
+  const success = fg("success", chalk.green);
+  const warning = fg("warning", chalk.yellow);
+  const error = fg("error", chalk.red);
+  const bold = (value) => theme ? theme.bold(value) : chalk.bold(value);
+  return {
+    accent,
+    muted,
+    text,
+    success,
+    warning,
+    error,
+    bold,
+    heading: (value) => bold(accent(value)),
+    link: (value) => theme ? theme.underline(accent(value)) : chalk.cyan.underline(value),
+    tab: (value) => muted(` ${value} `),
+    selectedTab: (value) => theme ? theme.fgBg("userMessageText", "accent", ` ${value} `) : chalk.bgWhite.black(` ${value} `),
+    progressFilled: accent,
+    progressEmpty: muted
+  };
+}
+
+export {
+  createCommandTheme
+};
+/**
+ * @license
+ * Copyright 2026 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */