@within-7/minto 0.0.5-dev.1

package/dist/utils/config.js

@@ -0,0 +1,651 @@
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve, join } from "path";
+import { cloneDeep, memoize, pick } from "lodash-es";
+import { homedir } from "os";
+import { GLOBAL_CONFIG_FILE } from "./env.js";
+import { getCwd } from "./state.js";
+import { randomBytes } from "crypto";
+import { safeParseJSON } from "./json.js";
+import { ConfigParseError } from "./errors.js";
+import { debug as debugLogger } from "./debugLogger.js";
+const DEFAULT_PROJECT_CONFIG = {
+  allowedTools: [],
+  context: {},
+  history: [],
+  dontCrawlDirectory: false,
+  enableArchitectTool: false,
+  mcpContextUris: [],
+  mcpServers: {},
+  approvedMcprcServers: [],
+  rejectedMcprcServers: [],
+  hasTrustDialogAccepted: false
+};
+function defaultConfigForProject(projectPath) {
+  const config = { ...DEFAULT_PROJECT_CONFIG };
+  if (projectPath === homedir()) {
+    config.dontCrawlDirectory = true;
+  }
+  return config;
+}
+function isAutoUpdaterStatus(value) {
+  return ["disabled", "enabled", "no_permissions", "not_configured"].includes(
+    value
+  );
+}
+const DEFAULT_GLOBAL_CONFIG = {
+  numStartups: 0,
+  autoUpdaterStatus: "not_configured",
+  theme: "dark",
+  preferredNotifChannel: "iterm2",
+  verbose: false,
+  primaryProvider: "anthropic",
+  customApiKeyResponses: {
+    approved: [],
+    rejected: []
+  },
+  stream: true,
+  // New model system defaults
+  modelProfiles: [],
+  modelPointers: {
+    main: "",
+    task: "",
+    reasoning: "",
+    quick: ""
+  },
+  lastDismissedUpdateVersion: void 0,
+  compressionMode: "business",
+  // Default to business consulting compression
+  thinking: false
+  // Default to thinking mode off (Phase 4.2)
+};
+const GLOBAL_CONFIG_KEYS = [
+  "autoUpdaterStatus",
+  "theme",
+  "hasCompletedOnboarding",
+  "lastOnboardingVersion",
+  "lastReleaseNotesSeen",
+  "verbose",
+  "customApiKeyResponses",
+  "primaryProvider",
+  "preferredNotifChannel",
+  "shiftEnterKeyBindingInstalled",
+  "maxTokens",
+  "compressionMode"
+];
+function isGlobalConfigKey(key) {
+  return GLOBAL_CONFIG_KEYS.includes(key);
+}
+const PROJECT_CONFIG_KEYS = [
+  "dontCrawlDirectory",
+  "enableArchitectTool",
+  "hasTrustDialogAccepted",
+  "hasCompletedProjectOnboarding"
+];
+function checkHasTrustDialogAccepted() {
+  let currentPath = getCwd();
+  const config = getConfig(GLOBAL_CONFIG_FILE, DEFAULT_GLOBAL_CONFIG);
+  while (true) {
+    const projectConfig = config.projects?.[currentPath];
+    if (projectConfig?.hasTrustDialogAccepted) {
+      return true;
+    }
+    const parentPath = resolve(currentPath, "..");
+    if (parentPath === currentPath) {
+      break;
+    }
+    currentPath = parentPath;
+  }
+  return false;
+}
+const TEST_GLOBAL_CONFIG_FOR_TESTING = {
+  ...DEFAULT_GLOBAL_CONFIG,
+  autoUpdaterStatus: "disabled"
+};
+const TEST_PROJECT_CONFIG_FOR_TESTING = {
+  ...DEFAULT_PROJECT_CONFIG
+};
+function isProjectConfigKey(key) {
+  return PROJECT_CONFIG_KEYS.includes(key);
+}
+function saveGlobalConfig(config) {
+  if (process.env.NODE_ENV === "test") {
+    for (const key in config) {
+      TEST_GLOBAL_CONFIG_FOR_TESTING[key] = config[key];
+    }
+    return;
+  }
+  saveConfig(
+    GLOBAL_CONFIG_FILE,
+    {
+      ...config,
+      projects: getConfig(GLOBAL_CONFIG_FILE, DEFAULT_GLOBAL_CONFIG).projects
+    },
+    DEFAULT_GLOBAL_CONFIG
+  );
+}
+function getGlobalConfig() {
+  if (process.env.NODE_ENV === "test") {
+    return TEST_GLOBAL_CONFIG_FOR_TESTING;
+  }
+  const config = getConfig(GLOBAL_CONFIG_FILE, DEFAULT_GLOBAL_CONFIG);
+  return migrateModelProfilesRemoveId(config);
+}
+function getAnthropicApiKey() {
+  return process.env.ANTHROPIC_API_KEY || null;
+}
+function normalizeApiKeyForConfig(apiKey) {
+  return apiKey?.slice(-20) ?? "";
+}
+function getCustomApiKeyStatus(truncatedApiKey) {
+  const config = getGlobalConfig();
+  if (config.customApiKeyResponses?.approved?.includes(truncatedApiKey)) {
+    return "approved";
+  }
+  if (config.customApiKeyResponses?.rejected?.includes(truncatedApiKey)) {
+    return "rejected";
+  }
+  return "new";
+}
+function saveConfig(file, config, defaultConfig) {
+  const filteredConfig = Object.fromEntries(
+    Object.entries(config).filter(
+      ([key, value]) => JSON.stringify(value) !== JSON.stringify(defaultConfig[key])
+    )
+  );
+  try {
+    writeFileSync(file, JSON.stringify(filteredConfig, null, 2), "utf-8");
+  } catch (error) {
+    const err = error;
+    if (err?.code === "EACCES" || err?.code === "EPERM" || err?.code === "EROFS") {
+      debugLogger.state("CONFIG_SAVE_SKIPPED", {
+        file,
+        reason: String(err.code)
+      });
+      return;
+    }
+    throw error;
+  }
+}
+let configReadingAllowed = false;
+function enableConfigs() {
+  configReadingAllowed = true;
+  getConfig(
+    GLOBAL_CONFIG_FILE,
+    DEFAULT_GLOBAL_CONFIG,
+    true
+  );
+}
+function getConfig(file, defaultConfig, throwOnInvalid) {
+  debugLogger.state("CONFIG_LOAD_START", {
+    file,
+    fileExists: String(existsSync(file)),
+    throwOnInvalid: String(!!throwOnInvalid)
+  });
+  if (!existsSync(file)) {
+    debugLogger.state("CONFIG_LOAD_DEFAULT", {
+      file,
+      reason: "file_not_exists",
+      defaultConfigKeys: Object.keys(defaultConfig).join(", ")
+    });
+    return cloneDeep(defaultConfig);
+  }
+  try {
+    const fileContent = readFileSync(file, "utf-8");
+    debugLogger.state("CONFIG_FILE_READ", {
+      file,
+      contentLength: String(fileContent.length),
+      contentPreview: fileContent.substring(0, 100) + (fileContent.length > 100 ? "..." : "")
+    });
+    try {
+      const parsedConfig = JSON.parse(fileContent);
+      debugLogger.state("CONFIG_JSON_PARSED", {
+        file,
+        parsedKeys: Object.keys(parsedConfig).join(", ")
+      });
+      const finalConfig = {
+        ...cloneDeep(defaultConfig),
+        ...parsedConfig
+      };
+      debugLogger.state("CONFIG_LOAD_SUCCESS", {
+        file,
+        finalConfigKeys: Object.keys(finalConfig).join(", ")
+      });
+      return finalConfig;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      debugLogger.error("CONFIG_JSON_PARSE_ERROR", {
+        file,
+        errorMessage,
+        errorType: error instanceof Error ? error.constructor.name : typeof error,
+        contentLength: String(fileContent.length)
+      });
+      throw new ConfigParseError(errorMessage, file, defaultConfig);
+    }
+  } catch (error) {
+    if (error instanceof ConfigParseError && throwOnInvalid) {
+      debugLogger.error("CONFIG_PARSE_ERROR_RETHROWN", {
+        file,
+        throwOnInvalid: String(throwOnInvalid),
+        errorMessage: error.message
+      });
+      throw error;
+    }
+    debugLogger.warn("CONFIG_FALLBACK_TO_DEFAULT", {
+      file,
+      errorType: error instanceof Error ? error.constructor.name : typeof error,
+      errorMessage: error instanceof Error ? error.message : String(error),
+      action: "using_default_config"
+    });
+    return cloneDeep(defaultConfig);
+  }
+}
+function getCurrentProjectConfig() {
+  if (process.env.NODE_ENV === "test") {
+    return TEST_PROJECT_CONFIG_FOR_TESTING;
+  }
+  const absolutePath = resolve(getCwd());
+  const config = getConfig(GLOBAL_CONFIG_FILE, DEFAULT_GLOBAL_CONFIG);
+  if (!config.projects) {
+    return defaultConfigForProject(absolutePath);
+  }
+  const projectConfig = config.projects[absolutePath] ?? defaultConfigForProject(absolutePath);
+  if (typeof projectConfig.allowedTools === "string") {
+    projectConfig.allowedTools = safeParseJSON(projectConfig.allowedTools) ?? [];
+  }
+  return projectConfig;
+}
+function saveCurrentProjectConfig(projectConfig) {
+  if (process.env.NODE_ENV === "test") {
+    for (const key in projectConfig) {
+      TEST_PROJECT_CONFIG_FOR_TESTING[key] = projectConfig[key];
+    }
+    return;
+  }
+  const config = getConfig(GLOBAL_CONFIG_FILE, DEFAULT_GLOBAL_CONFIG);
+  saveConfig(
+    GLOBAL_CONFIG_FILE,
+    {
+      ...config,
+      projects: {
+        ...config.projects,
+        [resolve(getCwd())]: projectConfig
+      }
+    },
+    DEFAULT_GLOBAL_CONFIG
+  );
+}
+async function isAutoUpdaterDisabled() {
+  return getGlobalConfig().autoUpdaterStatus === "disabled";
+}
+const TEST_MCPRC_CONFIG_FOR_TESTING = {};
+function clearMcprcConfigForTesting() {
+  if (process.env.NODE_ENV === "test") {
+    Object.keys(TEST_MCPRC_CONFIG_FOR_TESTING).forEach((key) => {
+      delete TEST_MCPRC_CONFIG_FOR_TESTING[key];
+    });
+  }
+}
+function addMcprcServerForTesting(name, server) {
+  if (process.env.NODE_ENV === "test") {
+    TEST_MCPRC_CONFIG_FOR_TESTING[name] = server;
+  }
+}
+function removeMcprcServerForTesting(name) {
+  if (process.env.NODE_ENV === "test") {
+    if (!TEST_MCPRC_CONFIG_FOR_TESTING[name]) {
+      throw new Error(`No MCP server found with name: ${name} in .mcprc`);
+    }
+    delete TEST_MCPRC_CONFIG_FOR_TESTING[name];
+  }
+}
+const getMcprcConfig = memoize(
+  () => {
+    if (process.env.NODE_ENV === "test") {
+      return TEST_MCPRC_CONFIG_FOR_TESTING;
+    }
+    const mcprcPath = join(getCwd(), ".mcprc");
+    if (!existsSync(mcprcPath)) {
+      return {};
+    }
+    try {
+      const mcprcContent = readFileSync(mcprcPath, "utf-8");
+      const config = safeParseJSON(mcprcContent);
+      if (config && typeof config === "object") {
+        return config;
+      }
+    } catch {
+    }
+    return {};
+  },
+  // This function returns the same value as long as the cwd and mcprc file content remain the same
+  () => {
+    const cwd = getCwd();
+    const mcprcPath = join(cwd, ".mcprc");
+    if (existsSync(mcprcPath)) {
+      try {
+        const stat = readFileSync(mcprcPath, "utf-8");
+        return `${cwd}:${stat}`;
+      } catch {
+        return cwd;
+      }
+    }
+    return cwd;
+  }
+);
+function getOrCreateUserID() {
+  const config = getGlobalConfig();
+  if (config.userID) {
+    return config.userID;
+  }
+  const userID = randomBytes(32).toString("hex");
+  saveGlobalConfig({ ...config, userID });
+  return userID;
+}
+function getConfigForCLI(key, global) {
+  if (global) {
+    if (!isGlobalConfigKey(key)) {
+      console.error(
+        `Error: '${key}' is not a valid config key. Valid keys are: ${GLOBAL_CONFIG_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    return getGlobalConfig()[key];
+  } else {
+    if (!isProjectConfigKey(key)) {
+      console.error(
+        `Error: '${key}' is not a valid config key. Valid keys are: ${PROJECT_CONFIG_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    return getCurrentProjectConfig()[key];
+  }
+}
+function setConfigForCLI(key, value, global) {
+  if (global) {
+    if (!isGlobalConfigKey(key)) {
+      console.error(
+        `Error: Cannot set '${key}'. Only these keys can be modified: ${GLOBAL_CONFIG_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    if (key === "autoUpdaterStatus" && !isAutoUpdaterStatus(value)) {
+      console.error(
+        `Error: Invalid value for autoUpdaterStatus. Must be one of: disabled, enabled, no_permissions, not_configured`
+      );
+      process.exit(1);
+    }
+    const currentConfig = getGlobalConfig();
+    saveGlobalConfig({
+      ...currentConfig,
+      [key]: value
+    });
+  } else {
+    if (!isProjectConfigKey(key)) {
+      console.error(
+        `Error: Cannot set '${key}'. Only these keys can be modified: ${PROJECT_CONFIG_KEYS.join(", ")}. Did you mean --global?`
+      );
+      process.exit(1);
+    }
+    const currentConfig = getCurrentProjectConfig();
+    saveCurrentProjectConfig({
+      ...currentConfig,
+      [key]: value
+    });
+  }
+  setTimeout(() => {
+    process.exit(0);
+  }, 100);
+}
+function deleteConfigForCLI(key, global) {
+  if (global) {
+    if (!isGlobalConfigKey(key)) {
+      console.error(
+        `Error: Cannot delete '${key}'. Only these keys can be modified: ${GLOBAL_CONFIG_KEYS.join(", ")}`
+      );
+      process.exit(1);
+    }
+    const currentConfig = getGlobalConfig();
+    delete currentConfig[key];
+    saveGlobalConfig(currentConfig);
+  } else {
+    if (!isProjectConfigKey(key)) {
+      console.error(
+        `Error: Cannot delete '${key}'. Only these keys can be modified: ${PROJECT_CONFIG_KEYS.join(", ")}. Did you mean --global?`
+      );
+      process.exit(1);
+    }
+    const currentConfig = getCurrentProjectConfig();
+    delete currentConfig[key];
+    saveCurrentProjectConfig(currentConfig);
+  }
+}
+function listConfigForCLI(global) {
+  if (global) {
+    const currentConfig = pick(getGlobalConfig(), GLOBAL_CONFIG_KEYS);
+    return currentConfig;
+  } else {
+    return pick(getCurrentProjectConfig(), PROJECT_CONFIG_KEYS);
+  }
+}
+function getOpenAIApiKey() {
+  return process.env.OPENAI_API_KEY;
+}
+function migrateModelProfilesRemoveId(config) {
+  if (!config.modelProfiles) return config;
+  const idToModelNameMap = /* @__PURE__ */ new Map();
+  const migratedProfiles = config.modelProfiles.map((profile) => {
+    if (profile.id && profile.modelName) {
+      idToModelNameMap.set(profile.id, profile.modelName);
+    }
+    const { id, ...profileWithoutId } = profile;
+    return profileWithoutId;
+  });
+  const migratedPointers = {
+    main: "",
+    task: "",
+    reasoning: "",
+    quick: ""
+  };
+  if (config.modelPointers) {
+    Object.entries(config.modelPointers).forEach(([pointer, value]) => {
+      if (value) {
+        const modelName = idToModelNameMap.get(value) || value;
+        migratedPointers[pointer] = modelName;
+      }
+    });
+  }
+  let defaultModelName;
+  if (config.defaultModelId) {
+    defaultModelName = idToModelNameMap.get(config.defaultModelId) || config.defaultModelId;
+  } else if (config.defaultModelName) {
+    defaultModelName = config.defaultModelName;
+  }
+  const migratedConfig = { ...config };
+  delete migratedConfig.defaultModelId;
+  delete migratedConfig.currentSelectedModelId;
+  delete migratedConfig.mainAgentModelId;
+  delete migratedConfig.taskToolModelId;
+  return {
+    ...migratedConfig,
+    modelProfiles: migratedProfiles,
+    modelPointers: migratedPointers,
+    defaultModelName
+  };
+}
+function setAllPointersToModel(modelName) {
+  const config = getGlobalConfig();
+  const updatedConfig = {
+    ...config,
+    modelPointers: {
+      main: modelName,
+      task: modelName,
+      reasoning: modelName,
+      quick: modelName
+    },
+    defaultModelName: modelName
+  };
+  saveGlobalConfig(updatedConfig);
+}
+function setModelPointer(pointer, modelName) {
+  const config = getGlobalConfig();
+  const updatedConfig = {
+    ...config,
+    modelPointers: {
+      ...config.modelPointers,
+      [pointer]: modelName
+    }
+  };
+  saveGlobalConfig(updatedConfig);
+  import("./model.js").then(({ reloadModelManager }) => {
+    reloadModelManager();
+  });
+}
+function isGPT5ModelName(modelName) {
+  if (!modelName || typeof modelName !== "string") return false;
+  const lowerName = modelName.toLowerCase();
+  return lowerName.startsWith("gpt-5") || lowerName.includes("gpt-5");
+}
+function validateAndRepairGPT5Profile(profile) {
+  const isGPT5 = isGPT5ModelName(profile.modelName);
+  const now = Date.now();
+  const repairedProfile = { ...profile };
+  let wasRepaired = false;
+  if (isGPT5 !== profile.isGPT5) {
+    repairedProfile.isGPT5 = isGPT5;
+    wasRepaired = true;
+  }
+  if (isGPT5) {
+    const validReasoningEfforts = ["minimal", "low", "medium", "high"];
+    if (!profile.reasoningEffort || !validReasoningEfforts.includes(profile.reasoningEffort)) {
+      repairedProfile.reasoningEffort = "medium";
+      wasRepaired = true;
+      console.log(`\u{1F527} GPT-5 Config: Set reasoning effort to 'medium' for ${profile.modelName}`);
+    }
+    if (profile.contextLength < 128e3) {
+      repairedProfile.contextLength = 128e3;
+      wasRepaired = true;
+      console.log(`\u{1F527} GPT-5 Config: Updated context length to 128k for ${profile.modelName}`);
+    }
+    if (profile.maxTokens < 4e3) {
+      repairedProfile.maxTokens = 8192;
+      wasRepaired = true;
+      console.log(`\u{1F527} GPT-5 Config: Updated max tokens to 8192 for ${profile.modelName}`);
+    }
+    if (profile.provider !== "openai" && profile.provider !== "custom-openai" && profile.provider !== "azure") {
+      console.warn(`\u26A0\uFE0F  GPT-5 Config: Unexpected provider '${profile.provider}' for GPT-5 model ${profile.modelName}. Consider using 'openai' or 'custom-openai'.`);
+    }
+    if (profile.modelName.includes("gpt-5") && !profile.baseURL) {
+      repairedProfile.baseURL = "https://api.openai.com/v1";
+      wasRepaired = true;
+      console.log(`\u{1F527} GPT-5 Config: Set default base URL for ${profile.modelName}`);
+    }
+  }
+  repairedProfile.validationStatus = wasRepaired ? "auto_repaired" : "valid";
+  repairedProfile.lastValidation = now;
+  if (wasRepaired) {
+    console.log(`\u2705 GPT-5 Config: Auto-repaired configuration for ${profile.modelName}`);
+  }
+  return repairedProfile;
+}
+function validateAndRepairAllGPT5Profiles() {
+  const config = getGlobalConfig();
+  if (!config.modelProfiles) {
+    return { repaired: 0, total: 0 };
+  }
+  let repairCount = 0;
+  const repairedProfiles = config.modelProfiles.map((profile) => {
+    const repairedProfile = validateAndRepairGPT5Profile(profile);
+    if (repairedProfile.validationStatus === "auto_repaired") {
+      repairCount++;
+    }
+    return repairedProfile;
+  });
+  if (repairCount > 0) {
+    const updatedConfig = {
+      ...config,
+      modelProfiles: repairedProfiles
+    };
+    saveGlobalConfig(updatedConfig);
+    console.log(`\u{1F527} GPT-5 Config: Auto-repaired ${repairCount} model profiles`);
+  }
+  return { repaired: repairCount, total: config.modelProfiles.length };
+}
+function getGPT5ConfigRecommendations(modelName) {
+  if (!isGPT5ModelName(modelName)) {
+    return {};
+  }
+  const recommendations = {
+    contextLength: 128e3,
+    // GPT-5 standard context length
+    maxTokens: 8192,
+    // Good default for coding tasks
+    reasoningEffort: "medium",
+    // Balanced for most coding tasks
+    isGPT5: true
+  };
+  if (modelName.includes("gpt-5-mini")) {
+    recommendations.maxTokens = 4096;
+    recommendations.reasoningEffort = "low";
+  } else if (modelName.includes("gpt-5-nano")) {
+    recommendations.maxTokens = 2048;
+    recommendations.reasoningEffort = "minimal";
+  }
+  return recommendations;
+}
+function createGPT5ModelProfile(name, modelName, apiKey, baseURL, provider = "openai") {
+  const recommendations = getGPT5ConfigRecommendations(modelName);
+  const profile = {
+    name,
+    provider,
+    modelName,
+    baseURL: baseURL || "https://api.openai.com/v1",
+    apiKey,
+    maxTokens: recommendations.maxTokens || 8192,
+    contextLength: recommendations.contextLength || 128e3,
+    reasoningEffort: recommendations.reasoningEffort || "medium",
+    isActive: true,
+    createdAt: Date.now(),
+    isGPT5: true,
+    validationStatus: "valid",
+    lastValidation: Date.now()
+  };
+  console.log(`\u2705 Created GPT-5 model profile: ${name} (${modelName})`);
+  return profile;
+}
+export {
+  DEFAULT_GLOBAL_CONFIG,
+  GLOBAL_CONFIG_KEYS,
+  PROJECT_CONFIG_KEYS,
+  TEST_MCPRC_CONFIG_FOR_TESTING,
+  addMcprcServerForTesting,
+  checkHasTrustDialogAccepted,
+  clearMcprcConfigForTesting,
+  createGPT5ModelProfile,
+  deleteConfigForCLI,
+  enableConfigs,
+  getAnthropicApiKey,
+  getConfigForCLI,
+  getCurrentProjectConfig,
+  getCustomApiKeyStatus,
+  getGPT5ConfigRecommendations,
+  getGlobalConfig,
+  getMcprcConfig,
+  getOpenAIApiKey,
+  getOrCreateUserID,
+  isAutoUpdaterDisabled,
+  isAutoUpdaterStatus,
+  isGPT5ModelName,
+  isGlobalConfigKey,
+  isProjectConfigKey,
+  listConfigForCLI,
+  normalizeApiKeyForConfig,
+  removeMcprcServerForTesting,
+  saveCurrentProjectConfig,
+  saveGlobalConfig,
+  setAllPointersToModel,
+  setConfigForCLI,
+  setModelPointer,
+  validateAndRepairAllGPT5Profiles,
+  validateAndRepairGPT5Profile
+};
+//# sourceMappingURL=config.js.map