@shareai-lab/kode 2.0.1 → 2.0.3

package/dist/chunks/chunk-6ZWEOSEI.js

@@ -0,0 +1,666 @@
+import {
+  debug
+} from "./chunk-YIO5EBMQ.js";
+import {
+  logError
+} from "./chunk-3OEJVB5A.js";
+import {
+  DEFAULT_GLOBAL_CONFIG,
+  getGlobalConfig,
+  saveGlobalConfig
+} from "./chunk-XR2W3MAM.js";
+
+// packages/core/src/model/flags.ts
+var USE_BEDROCK = !!(process.env.KODE_USE_BEDROCK ?? process.env.CLAUDE_CODE_USE_BEDROCK);
+var USE_VERTEX = !!(process.env.KODE_USE_VERTEX ?? process.env.CLAUDE_CODE_USE_VERTEX);
+
+// packages/core/src/model/capabilities.ts
+function getVertexRegionForModel(model) {
+  if (model?.startsWith("claude-3-5-haiku")) {
+    return process.env.VERTEX_REGION_CLAUDE_3_5_HAIKU;
+  }
+  if (model?.startsWith("claude-3-5-sonnet")) {
+    return process.env.VERTEX_REGION_CLAUDE_3_5_SONNET;
+  }
+  if (model?.startsWith("claude-3-7-sonnet")) {
+    return process.env.VERTEX_REGION_CLAUDE_3_7_SONNET;
+  }
+}
+function analyzeContextCompatibility(model, contextTokens) {
+  const usableContext = Math.floor(model.contextLength * 0.8);
+  const usagePercentage = contextTokens / usableContext * 100;
+  if (usagePercentage <= 70) {
+    return {
+      compatible: true,
+      severity: "safe",
+      usagePercentage,
+      recommendation: "Full context preserved"
+    };
+  }
+  if (usagePercentage <= 90) {
+    return {
+      compatible: true,
+      severity: "warning",
+      usagePercentage,
+      recommendation: "Context usage high, consider compression"
+    };
+  }
+  return {
+    compatible: false,
+    severity: "critical",
+    usagePercentage,
+    recommendation: "Auto-compression or message truncation required"
+  };
+}
+function canModelHandleContext(model, contextTokens) {
+  const analysis = analyzeContextCompatibility(model, contextTokens);
+  return analysis.compatible;
+}
+function findModelWithSufficientContext(models, contextTokens) {
+  return models.find((model) => canModelHandleContext(model, contextTokens)) || null;
+}
+
+// packages/core/src/model/defaults.ts
+var DEFAULT_MODEL_CONFIG = {
+  bedrock: "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
+  vertex: "claude-3-7-sonnet@20250219",
+  firstParty: "claude-sonnet-4-20250514"
+};
+async function getModelConfig() {
+  return DEFAULT_MODEL_CONFIG;
+}
+
+// packages/core/src/model/resolution.ts
+var POINTERS = ["main", "task", "compact", "quick"];
+function getDefaultModelProfile(config, modelProfiles) {
+  if (config.defaultModelId) {
+    const profile = modelProfiles.find((p) => p.modelName === config.defaultModelId) || null;
+    if (profile && profile.isActive) return profile;
+  }
+  return modelProfiles.find((p) => p.isActive) || null;
+}
+function resolveProviderQualifiedModel(modelProfiles, input) {
+  const trimmed = input.trim();
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex <= 0 || colonIndex >= trimmed.length - 1) return null;
+  const provider = trimmed.slice(0, colonIndex).trim().toLowerCase();
+  const modelOrName = trimmed.slice(colonIndex + 1).trim();
+  if (!provider || !modelOrName) return null;
+  const providerProfiles = modelProfiles.filter(
+    (p) => String(p.provider).trim().toLowerCase() === provider
+  );
+  if (providerProfiles.length === 0) return null;
+  const byModelName = providerProfiles.find((p) => p.modelName === modelOrName);
+  if (byModelName) return byModelName;
+  const byName = providerProfiles.find((p) => p.name === modelOrName);
+  if (byName) return byName;
+  return null;
+}
+function findByModelName(modelProfiles, modelName) {
+  return modelProfiles.find((p) => p.modelName === modelName) || null;
+}
+function findByName(modelProfiles, name) {
+  return modelProfiles.find((p) => p.name === name) || null;
+}
+function resolveModel(config, modelProfiles, modelParam) {
+  if (typeof modelParam === "string" && POINTERS.includes(modelParam)) {
+    const pointerId = config.modelPointers?.[modelParam];
+    if (pointerId) {
+      const profile2 = findByModelName(modelProfiles, pointerId);
+      if (profile2 && profile2.isActive) return profile2;
+    }
+    return getDefaultModelProfile(config, modelProfiles);
+  }
+  const raw = String(modelParam);
+  let profile = findByModelName(modelProfiles, raw);
+  if (profile && profile.isActive) return profile;
+  profile = findByName(modelProfiles, raw);
+  if (profile && profile.isActive) return profile;
+  const qualified = resolveProviderQualifiedModel(modelProfiles, raw);
+  if (qualified && qualified.isActive) return qualified;
+  return getDefaultModelProfile(config, modelProfiles);
+}
+function resolveModelWithInfo(config, modelProfiles, modelParam) {
+  const isPointer = typeof modelParam === "string" && POINTERS.includes(modelParam);
+  if (isPointer) {
+    const pointerId = config.modelPointers?.[modelParam];
+    if (!pointerId) {
+      return {
+        success: false,
+        profile: null,
+        error: `Model pointer '${modelParam}' is not configured. Use /model to set up models.`
+      };
+    }
+    const profile2 = findByModelName(modelProfiles, pointerId);
+    if (!profile2) {
+      return {
+        success: false,
+        profile: null,
+        error: `Model pointer '${modelParam}' points to invalid model '${pointerId}'. Use /model to reconfigure.`
+      };
+    }
+    if (!profile2.isActive) {
+      return {
+        success: false,
+        profile: null,
+        error: `Model '${profile2.name}' (pointed by '${modelParam}') is inactive. Use /model to activate it.`
+      };
+    }
+    return { success: true, profile: profile2 };
+  }
+  const raw = String(modelParam);
+  let profile = findByModelName(modelProfiles, raw);
+  if (!profile) profile = findByName(modelProfiles, raw);
+  if (!profile && typeof modelParam === "string") {
+    profile = resolveProviderQualifiedModel(modelProfiles, modelParam);
+  }
+  if (!profile) {
+    return {
+      success: false,
+      profile: null,
+      error: `Model '${raw}' not found. Use /model to add models, or run 'kode models list' to see configured profiles.`
+    };
+  }
+  if (!profile.isActive) {
+    return {
+      success: false,
+      profile: null,
+      error: `Model '${profile.name}' is inactive. Use /model to activate it.`
+    };
+  }
+  return { success: true, profile };
+}
+
+// packages/core/src/model/switching.ts
+function budgetForModel(model, currentContextTokens) {
+  const contextLength = Number(model.contextLength);
+  if (!Number.isFinite(contextLength) || contextLength <= 0) {
+    return { budgetTokens: null, usagePercentage: 0, compatible: true };
+  }
+  const budgetTokens = Math.floor(contextLength * 0.9);
+  const usagePercentage = budgetTokens > 0 ? currentContextTokens / budgetTokens * 100 : 0;
+  return {
+    budgetTokens,
+    usagePercentage,
+    compatible: budgetTokens > 0 ? currentContextTokens <= budgetTokens : true
+  };
+}
+function formatTokens(tokens) {
+  if (!Number.isFinite(tokens)) return "unknown";
+  if (tokens >= 1e3) return `${Math.round(tokens / 1e3)}k`;
+  return String(Math.round(tokens));
+}
+function chooseNextModelWithContextCheck(args) {
+  const allProfiles = [...args.modelProfiles];
+  const currentContextTokens = args.currentContextTokens;
+  if (allProfiles.length === 0) {
+    return {
+      selected: null,
+      result: {
+        success: false,
+        modelName: null,
+        previousModelName: null,
+        contextOverflow: false,
+        usagePercentage: 0,
+        currentContextTokens
+      }
+    };
+  }
+  allProfiles.sort((a, b) => a.createdAt - b.createdAt);
+  const currentModel = args.currentMainModelName ? allProfiles.find((p) => p.modelName === args.currentMainModelName) ?? null : null;
+  const previousModelName = currentModel?.name || null;
+  if (allProfiles.length === 1) {
+    return {
+      selected: null,
+      result: {
+        success: false,
+        modelName: null,
+        previousModelName,
+        contextOverflow: false,
+        usagePercentage: 0,
+        currentContextTokens
+      }
+    };
+  }
+  const currentIndex = args.currentMainModelName !== void 0 ? allProfiles.findIndex((p) => p.modelName === args.currentMainModelName) : -1;
+  const startIndex = currentIndex >= 0 ? currentIndex : -1;
+  const maxOffsets = startIndex === -1 ? allProfiles.length : allProfiles.length - 1;
+  const skippedModels = [];
+  let selected = null;
+  let selectedUsagePercentage = 0;
+  for (let offset = 1; offset <= maxOffsets; offset++) {
+    const candidateIndex = (startIndex + offset + allProfiles.length) % allProfiles.length;
+    const candidate = allProfiles[candidateIndex];
+    if (!candidate) continue;
+    const { budgetTokens, usagePercentage, compatible } = budgetForModel(
+      candidate,
+      currentContextTokens
+    );
+    if (compatible) {
+      selected = candidate;
+      selectedUsagePercentage = usagePercentage;
+      break;
+    }
+    skippedModels.push({
+      name: candidate.name,
+      provider: candidate.provider,
+      contextLength: candidate.contextLength,
+      budgetTokens,
+      usagePercentage
+    });
+  }
+  if (!selected) {
+    const firstSkipped = skippedModels[0];
+    return {
+      selected: null,
+      result: {
+        success: false,
+        modelName: null,
+        previousModelName,
+        contextOverflow: true,
+        usagePercentage: firstSkipped?.usagePercentage ?? 0,
+        currentContextTokens,
+        skippedModels
+      }
+    };
+  }
+  return {
+    selected,
+    result: {
+      success: true,
+      modelName: selected.name,
+      previousModelName,
+      contextOverflow: false,
+      usagePercentage: selectedUsagePercentage,
+      currentContextTokens,
+      skippedModels
+    }
+  };
+}
+function formatSwitchResult(args) {
+  const result = args.detailed;
+  const allModels = args.modelProfiles;
+  if (allModels.length === 0) {
+    return {
+      success: false,
+      modelName: null,
+      blocked: false,
+      message: "\u274C No models configured. Use /model to add models."
+    };
+  }
+  if (allModels.length === 1) {
+    return {
+      success: false,
+      modelName: null,
+      blocked: false,
+      message: `\u26A0\uFE0F Only one model configured (${allModels[0].modelName}). Use /model to add more models for switching.`
+    };
+  }
+  const currentModel = args.currentMainModelName ? allModels.find((p) => p.modelName === args.currentMainModelName) ?? null : null;
+  const modelsSorted = [...allModels].sort((a, b) => a.createdAt - b.createdAt);
+  const currentIndex = modelsSorted.findIndex(
+    (m) => m.modelName === currentModel?.modelName
+  );
+  const totalModels = modelsSorted.length;
+  if (result.success && result.modelName) {
+    const skippedCount = result.skippedModels?.length ?? 0;
+    const skippedSuffix = skippedCount > 0 ? ` \xB7 skipped ${skippedCount} incompatible` : "";
+    const contextSuffix = currentModel?.contextLength && result.currentContextTokens ? ` \xB7 context ~${formatTokens(result.currentContextTokens)}/${formatTokens(currentModel.contextLength)}` : "";
+    return {
+      success: true,
+      modelName: result.modelName,
+      blocked: false,
+      message: `\u2705 Switched to ${result.modelName} (${currentIndex + 1}/${totalModels})${currentModel?.provider ? ` [${currentModel.provider}]` : ""}${skippedSuffix}${contextSuffix}`
+    };
+  }
+  if (result.contextOverflow) {
+    const attempted = result.skippedModels?.[0];
+    const attemptedContext = attempted?.contextLength;
+    const attemptedBudget = attempted?.budgetTokens;
+    const currentLabel = currentModel?.name || currentModel?.modelName || "current model";
+    const attemptedText = attempted ? `Can't switch to ${attempted.name}: current ~${formatTokens(result.currentContextTokens)} tokens exceeds safe budget (~${formatTokens(attemptedBudget ?? 0)} tokens, 90% of ${formatTokens(attemptedContext ?? 0)}).` : `Can't switch models due to context size (~${formatTokens(result.currentContextTokens)} tokens).`;
+    return {
+      success: false,
+      modelName: null,
+      blocked: true,
+      message: `\u26A0\uFE0F ${attemptedText} Keeping ${currentLabel}.`
+    };
+  }
+  return {
+    success: false,
+    modelName: null,
+    blocked: false,
+    message: "\u274C Failed to switch models"
+  };
+}
+
+// packages/core/src/model/manager.ts
+var POINTERS2 = ["main", "task", "compact", "quick"];
+var DEFAULT_MODEL_POINTERS = {
+  main: "",
+  task: "",
+  compact: "",
+  quick: ""
+};
+var ModelManager = class {
+  config;
+  modelProfiles;
+  constructor(config) {
+    this.config = config;
+    this.modelProfiles = config.modelProfiles || [];
+  }
+  getCurrentModel() {
+    const mainModelName = this.config.modelPointers?.main;
+    if (mainModelName) {
+      const profile = this.findByModelName(mainModelName);
+      if (profile && profile.isActive) return profile.modelName;
+    }
+    return this.getMainAgentModel();
+  }
+  getMainAgentModel() {
+    const mainModelName = this.config.modelPointers?.main;
+    if (mainModelName) {
+      const profile = this.findByModelName(mainModelName);
+      if (profile && profile.isActive) return profile.modelName;
+    }
+    const activeProfile = this.modelProfiles.find((p) => p.isActive);
+    return activeProfile ? activeProfile.modelName : null;
+  }
+  getTaskToolModel() {
+    const taskModelName = this.config.modelPointers?.task;
+    if (taskModelName) {
+      const profile = this.findByModelName(taskModelName);
+      if (profile && profile.isActive) return profile.modelName;
+    }
+    return this.getMainAgentModel();
+  }
+  switchToNextModelWithContextCheck(currentContextTokens = 0) {
+    const { selected, result } = chooseNextModelWithContextCheck({
+      modelProfiles: this.getAllConfiguredModels(),
+      currentMainModelName: this.config.modelPointers?.main,
+      currentContextTokens
+    });
+    if (!selected) return result;
+    if (!selected.isActive) selected.isActive = true;
+    this.setPointer("main", selected.modelName);
+    this.updateLastUsed(selected.modelName);
+    return result;
+  }
+  switchToNextModel(currentContextTokens = 0) {
+    const detailed = this.switchToNextModelWithContextCheck(currentContextTokens);
+    return formatSwitchResult({
+      detailed,
+      modelProfiles: this.getAllConfiguredModels(),
+      currentMainModelName: this.config.modelPointers?.main
+    });
+  }
+  analyzeContextCompatibility = analyzeContextCompatibility;
+  switchToNextModelWithAnalysis(currentContextTokens = 0) {
+    const result = this.switchToNextModel(currentContextTokens);
+    if (!result.success || !result.modelName) {
+      return {
+        modelName: null,
+        contextAnalysis: null,
+        requiresCompression: false,
+        estimatedTokensAfterSwitch: 0
+      };
+    }
+    const newModel = this.getModel("main");
+    if (!newModel) {
+      return {
+        modelName: result.modelName,
+        contextAnalysis: null,
+        requiresCompression: false,
+        estimatedTokensAfterSwitch: currentContextTokens
+      };
+    }
+    const analysis = analyzeContextCompatibility(newModel, currentContextTokens);
+    return {
+      modelName: result.modelName,
+      contextAnalysis: analysis,
+      requiresCompression: analysis.severity === "critical",
+      estimatedTokensAfterSwitch: currentContextTokens
+    };
+  }
+  canModelHandleContext(model, contextTokens) {
+    return canModelHandleContext(model, contextTokens);
+  }
+  findModelWithSufficientContext(models, contextTokens) {
+    return findModelWithSufficientContext(models, contextTokens);
+  }
+  getModelForContext(contextType) {
+    switch (contextType) {
+      case "terminal":
+        return this.getCurrentModel();
+      case "main-agent":
+        return this.getMainAgentModel();
+      case "task-tool":
+        return this.getTaskToolModel();
+      default:
+        return this.getMainAgentModel();
+    }
+  }
+  getActiveModelProfiles() {
+    return this.modelProfiles.filter((p) => p.isActive);
+  }
+  hasConfiguredModels() {
+    return this.getActiveModelProfiles().length > 0;
+  }
+  getModel(pointer) {
+    const pointerId = this.config.modelPointers?.[pointer];
+    if (!pointerId) return this.getDefaultModel();
+    const profile = this.findByModelName(pointerId);
+    return profile && profile.isActive ? profile : this.getDefaultModel();
+  }
+  getModelName(pointer) {
+    const profile = this.getModel(pointer);
+    return profile ? profile.modelName : null;
+  }
+  getCompactModel() {
+    return this.getModelName("compact") || this.getModelName("main");
+  }
+  getQuickModel() {
+    return this.getModelName("quick") || this.getModelName("task") || this.getModelName("main");
+  }
+  async addModel(config) {
+    const existingByModelName = this.modelProfiles.find(
+      (p) => p.modelName === config.modelName
+    );
+    if (existingByModelName) {
+      throw new Error(
+        `Model with modelName '${config.modelName}' already exists: ${existingByModelName.name}`
+      );
+    }
+    const existingByName = this.modelProfiles.find((p) => p.name === config.name);
+    if (existingByName) {
+      throw new Error(`Model with name '${config.name}' already exists`);
+    }
+    const newModel = {
+      ...config,
+      createdAt: Date.now(),
+      isActive: true
+    };
+    this.modelProfiles.push(newModel);
+    if (this.modelProfiles.length === 1) {
+      this.config.modelPointers = {
+        main: config.modelName,
+        task: config.modelName,
+        compact: config.modelName,
+        quick: config.modelName
+      };
+      this.config.defaultModelName = config.modelName;
+    } else {
+      if (!this.config.modelPointers) {
+        this.config.modelPointers = {
+          ...DEFAULT_MODEL_POINTERS,
+          main: config.modelName
+        };
+      } else {
+        this.config.modelPointers.main = config.modelName;
+      }
+    }
+    this.saveConfig();
+    return config.modelName;
+  }
+  setPointer(pointer, modelName) {
+    if (!this.findByModelName(modelName)) {
+      throw new Error(`Model '${modelName}' not found`);
+    }
+    if (!this.config.modelPointers) {
+      this.config.modelPointers = { ...DEFAULT_MODEL_POINTERS };
+    }
+    this.config.modelPointers[pointer] = modelName;
+    this.saveConfig();
+  }
+  getAvailableModels() {
+    return this.modelProfiles.filter((p) => p.isActive);
+  }
+  getAllConfiguredModels() {
+    return this.modelProfiles;
+  }
+  getAllAvailableModelNames() {
+    return this.getAvailableModels().map((p) => p.modelName);
+  }
+  getAllConfiguredModelNames() {
+    return this.getAllConfiguredModels().map((p) => p.modelName);
+  }
+  getModelSwitchingDebugInfo() {
+    const availableModels = this.getAvailableModels();
+    const currentMainModelName = this.config.modelPointers?.main;
+    return {
+      totalModels: this.modelProfiles.length,
+      activeModels: availableModels.length,
+      inactiveModels: this.modelProfiles.length - availableModels.length,
+      currentMainModel: currentMainModelName || null,
+      availableModels: this.modelProfiles.map((p) => ({
+        name: p.name,
+        modelName: p.modelName,
+        provider: p.provider,
+        isActive: p.isActive,
+        lastUsed: p.lastUsed
+      })),
+      modelPointers: this.config.modelPointers || {}
+    };
+  }
+  removeModel(modelName) {
+    this.modelProfiles = this.modelProfiles.filter(
+      (p) => p.modelName !== modelName
+    );
+    if (this.config.modelPointers) {
+      for (const pointer of POINTERS2) {
+        if (this.config.modelPointers[pointer] === modelName) {
+          this.config.modelPointers[pointer] = this.config.defaultModelName || "";
+        }
+      }
+    }
+    this.saveConfig();
+  }
+  getDefaultModel() {
+    if (this.config.defaultModelId) {
+      const profile = this.findByModelName(this.config.defaultModelId);
+      if (profile && profile.isActive) return profile;
+    }
+    return this.modelProfiles.find((p) => p.isActive) || null;
+  }
+  saveConfig() {
+    const updatedConfig = {
+      ...this.config,
+      modelProfiles: this.modelProfiles
+    };
+    saveGlobalConfig(updatedConfig);
+  }
+  async getFallbackModel() {
+    const modelConfig = await getModelConfig();
+    if (USE_BEDROCK) return modelConfig.bedrock;
+    if (USE_VERTEX) return modelConfig.vertex;
+    return modelConfig.firstParty;
+  }
+  resolveModel(modelParam) {
+    return resolveModel(this.config, this.modelProfiles, modelParam);
+  }
+  resolveModelWithInfo(modelParam) {
+    return resolveModelWithInfo(this.config, this.modelProfiles, modelParam);
+  }
+  findByModelName(modelName) {
+    return this.modelProfiles.find((p) => p.modelName === modelName) || null;
+  }
+  updateLastUsed(modelName) {
+    const profile = this.findByModelName(modelName);
+    if (profile) profile.lastUsed = Date.now();
+  }
+};
+
+// packages/core/src/model/selector.ts
+import { memoize } from "lodash-es";
+var DEFAULT_MODEL_POINTERS2 = {
+  main: "",
+  task: "",
+  compact: "",
+  quick: ""
+};
+var getSlowAndCapableModel = memoize(async () => {
+  const config = await getGlobalConfig();
+  const modelManager = new ModelManager(config);
+  const model = modelManager.getMainAgentModel();
+  if (model) return model;
+  const modelConfig = await getModelConfig();
+  if (USE_BEDROCK) return modelConfig.bedrock;
+  if (USE_VERTEX) return modelConfig.vertex;
+  return modelConfig.firstParty;
+});
+async function isDefaultSlowAndCapableModel() {
+  return !process.env.ANTHROPIC_MODEL || process.env.ANTHROPIC_MODEL === await getSlowAndCapableModel();
+}
+var globalModelManager = null;
+var getModelManager = () => {
+  try {
+    if (!globalModelManager) {
+      const config = getGlobalConfig();
+      if (!config) {
+        debug.warn("MODEL_MANAGER_GLOBAL_CONFIG_MISSING", {});
+        globalModelManager = new ModelManager({
+          ...DEFAULT_GLOBAL_CONFIG,
+          modelProfiles: [],
+          modelPointers: { ...DEFAULT_MODEL_POINTERS2 }
+        });
+      } else {
+        globalModelManager = new ModelManager(config);
+      }
+    }
+    return globalModelManager;
+  } catch (error) {
+    logError(error);
+    debug.error("MODEL_MANAGER_CREATE_FAILED", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return new ModelManager({
+      ...DEFAULT_GLOBAL_CONFIG,
+      modelProfiles: [],
+      modelPointers: { ...DEFAULT_MODEL_POINTERS2 }
+    });
+  }
+};
+var reloadModelManager = () => {
+  globalModelManager = null;
+  getModelManager();
+};
+var getQuickModel = () => {
+  const manager = getModelManager();
+  const quickModel = manager.getModel("quick");
+  return quickModel?.modelName || "quick";
+};
+
+export {
+  USE_BEDROCK,
+  USE_VERTEX,
+  getVertexRegionForModel,
+  analyzeContextCompatibility,
+  canModelHandleContext,
+  findModelWithSufficientContext,
+  ModelManager,
+  getSlowAndCapableModel,
+  isDefaultSlowAndCapableModel,
+  getModelManager,
+  reloadModelManager,
+  getQuickModel
+};