panopticon-cli 0.4.33 → 0.5.0

package/dist/chunk-HJSM6E6U.js

@@ -0,0 +1,1038 @@
+import {
+  SETTINGS_FILE,
+  init_paths
+} from "./chunk-ZTFNYOC7.js";
+import {
+  __esm,
+  init_esm_shims
+} from "./chunk-ZHC57RCV.js";
+
+// src/lib/settings.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+function deepMerge(defaults, overrides) {
+  const result = { ...defaults };
+  for (const key of Object.keys(overrides)) {
+    const defaultVal = defaults[key];
+    const overrideVal = overrides[key];
+    if (overrideVal === void 0) continue;
+    if (typeof defaultVal === "object" && defaultVal !== null && !Array.isArray(defaultVal) && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(overrideVal)) {
+      result[key] = deepMerge(defaultVal, overrideVal);
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function loadSettings() {
+  let settings;
+  if (!existsSync(SETTINGS_FILE)) {
+    settings = getDefaultSettings();
+  } else {
+    try {
+      const content = readFileSync(SETTINGS_FILE, "utf8");
+      const parsed = JSON.parse(content);
+      settings = deepMerge(DEFAULT_SETTINGS, parsed);
+    } catch (error) {
+      console.error("Warning: Failed to parse settings.json, using defaults");
+      settings = getDefaultSettings();
+    }
+  }
+  const envApiKeys = {};
+  if (process.env.OPENAI_API_KEY) envApiKeys.openai = process.env.OPENAI_API_KEY;
+  if (process.env.GOOGLE_API_KEY) envApiKeys.google = process.env.GOOGLE_API_KEY;
+  if (process.env.ZAI_API_KEY) envApiKeys.zai = process.env.ZAI_API_KEY;
+  if (process.env.KIMI_API_KEY) envApiKeys.kimi = process.env.KIMI_API_KEY;
+  settings.api_keys = {
+    ...envApiKeys,
+    ...settings.api_keys
+  };
+  return settings;
+}
+function saveSettings(settings) {
+  const content = JSON.stringify(settings, null, 2);
+  writeFileSync(SETTINGS_FILE, content, "utf8");
+}
+function validateSettings(settings) {
+  if (!settings.models) {
+    return "Missing models configuration";
+  }
+  if (!settings.models.specialists) {
+    return "Missing specialists configuration";
+  }
+  const specialists = settings.models.specialists;
+  if (!specialists.review_agent || !specialists.test_agent || !specialists.merge_agent) {
+    return "Missing specialist agent model configuration";
+  }
+  if (!settings.models.complexity) {
+    return "Missing complexity configuration";
+  }
+  const complexity = settings.models.complexity;
+  const requiredLevels = ["trivial", "simple", "medium", "complex", "expert"];
+  for (const level of requiredLevels) {
+    if (!complexity[level]) {
+      return `Missing complexity level: ${level}`;
+    }
+  }
+  if (!settings.api_keys) {
+    return "Missing api_keys configuration";
+  }
+  return null;
+}
+function getDefaultSettings() {
+  return JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
+}
+function getAvailableModels(settings) {
+  const anthropicModels = [
+    "claude-opus-4-6",
+    "claude-sonnet-4-6",
+    "claude-haiku-4-5"
+  ];
+  const openaiModels = settings.api_keys.openai ? ["gpt-5.2-codex", "o3-deep-research", "gpt-4o", "gpt-4o-mini"] : [];
+  const googleModels = settings.api_keys.google ? ["gemini-3-pro-preview", "gemini-3-flash-preview"] : [];
+  const zaiModels = settings.api_keys.zai ? ["glm-4.7", "glm-4.7-flash"] : [];
+  const kimiModels = settings.api_keys.kimi ? ["kimi-k2", "kimi-k2.5"] : [];
+  return {
+    anthropic: anthropicModels,
+    openai: openaiModels,
+    google: googleModels,
+    zai: zaiModels,
+    kimi: kimiModels
+  };
+}
+function isAnthropicModel(modelId) {
+  return modelId.startsWith("claude-");
+}
+function getClaudeModelFlag(modelId) {
+  const modelMap = {
+    "claude-opus-4-6": "opus",
+    "claude-sonnet-4-6": "sonnet",
+    "claude-sonnet-4-5": "sonnet",
+    "claude-haiku-4-5": "haiku"
+  };
+  return modelMap[modelId] || "sonnet";
+}
+function getAgentCommand(modelId) {
+  if (isAnthropicModel(modelId)) {
+    return {
+      command: "claude",
+      args: ["--model", getClaudeModelFlag(modelId)]
+    };
+  }
+  return {
+    command: "claude-code-router",
+    args: []
+  };
+}
+var DEFAULT_SETTINGS;
+var init_settings = __esm({
+  "src/lib/settings.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_paths();
+    DEFAULT_SETTINGS = {
+      models: {
+        specialists: {
+          review_agent: "claude-opus-4-6",
+          test_agent: "claude-sonnet-4-6",
+          merge_agent: "claude-sonnet-4-6"
+        },
+        status_review: "claude-opus-4-6",
+        complexity: {
+          trivial: "claude-haiku-4-5",
+          simple: "claude-haiku-4-5",
+          medium: "kimi-k2.5",
+          complex: "kimi-k2.5",
+          expert: "claude-opus-4-6"
+        }
+      },
+      api_keys: {}
+    };
+  }
+});
+
+// src/lib/providers.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join } from "path";
+function getProviderForModel(modelId) {
+  if (["claude-opus-4-6", "claude-sonnet-4-6", "claude-sonnet-4-5", "claude-haiku-4-5"].includes(modelId)) {
+    return PROVIDERS.anthropic;
+  }
+  if (["gpt-5.2-codex", "o3-deep-research", "gpt-4o", "gpt-4o-mini"].includes(modelId)) {
+    return PROVIDERS.openai;
+  }
+  if (["gemini-3-pro-preview", "gemini-3-flash-preview"].includes(modelId)) {
+    return PROVIDERS.google;
+  }
+  if (["glm-4.7", "glm-4.7-flash"].includes(modelId)) {
+    return PROVIDERS.zai;
+  }
+  if (["kimi-k2", "kimi-k2.5"].includes(modelId)) {
+    return PROVIDERS.kimi;
+  }
+  return PROVIDERS.anthropic;
+}
+function requiresRouter(provider) {
+  return PROVIDERS[provider].compatibility === "router";
+}
+function getRouterProviders() {
+  return Object.values(PROVIDERS).filter((p) => p.compatibility === "router");
+}
+function getDirectProviders() {
+  return Object.values(PROVIDERS).filter((p) => p.compatibility === "direct");
+}
+function needsRouter(apiKeys) {
+  return !!(apiKeys.openai || apiKeys.google);
+}
+function getProviderEnv(provider, apiKey) {
+  if (provider.compatibility === "direct") {
+    const env = {};
+    if (provider.baseUrl) {
+      env.ANTHROPIC_BASE_URL = provider.baseUrl;
+    }
+    if (provider.name !== "anthropic") {
+      if (provider.authType === "credential-file") {
+        env.ANTHROPIC_AUTH_TOKEN = apiKey;
+        env.CLAUDE_CODE_API_KEY_HELPER_TTL_MS = "60000";
+      } else {
+        env.ANTHROPIC_AUTH_TOKEN = apiKey;
+      }
+    }
+    if (provider.name === "zai") {
+      env.API_TIMEOUT_MS = "300000";
+    }
+    return env;
+  } else {
+    return {
+      ANTHROPIC_BASE_URL: "http://localhost:3456",
+      ANTHROPIC_AUTH_TOKEN: "router-managed"
+    };
+  }
+}
+function setupCredentialFileAuth(provider, workspacePath) {
+  if (provider.authType !== "credential-file" || !provider.credentialHelper) return;
+  const helperPath = provider.credentialHelper.replace("~", process.env.HOME || "");
+  const claudeDir = join(workspacePath, ".claude");
+  const settingsPath = join(claudeDir, "settings.local.json");
+  if (!existsSync2(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+  let settings = {};
+  if (existsSync2(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  settings.apiKeyHelper = helperPath;
+  writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+}
+function clearCredentialFileAuth(workspacePath) {
+  const settingsPath = join(workspacePath, ".claude", "settings.local.json");
+  if (!existsSync2(settingsPath)) return;
+  try {
+    const settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+    if (!settings.apiKeyHelper) return;
+    delete settings.apiKeyHelper;
+    writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  } catch {
+  }
+}
+var PROVIDERS;
+var init_providers = __esm({
+  "src/lib/providers.ts"() {
+    "use strict";
+    init_esm_shims();
+    PROVIDERS = {
+      anthropic: {
+        name: "anthropic",
+        displayName: "Anthropic",
+        compatibility: "direct",
+        models: ["claude-opus-4-6", "claude-sonnet-4-6", "claude-sonnet-4-5", "claude-haiku-4-5"],
+        tested: true,
+        description: "Native Claude API"
+      },
+      kimi: {
+        name: "kimi",
+        displayName: "Kimi (Moonshot AI)",
+        compatibility: "direct",
+        baseUrl: "https://api.kimi.com/coding/",
+        authType: "credential-file",
+        credentialFile: "~/.kimi/credentials/kimi-code.json",
+        credentialHelper: "~/.panopticon/bin/kimi-token-helper.sh",
+        models: [],
+        // Kimi uses same model names as Anthropic
+        tested: true,
+        description: "Anthropic-compatible API via Kimi Code Plan (OAuth token refresh)"
+      },
+      zai: {
+        name: "zai",
+        displayName: "Z.AI (GLM)",
+        compatibility: "direct",
+        baseUrl: "https://api.z.ai/api/anthropic",
+        models: ["glm-4.7", "glm-4.7-flash"],
+        tested: true,
+        description: "Anthropic-compatible API, tested 2026-01-28"
+      },
+      openai: {
+        name: "openai",
+        displayName: "OpenAI",
+        compatibility: "router",
+        models: ["gpt-5.2-codex", "o3-deep-research", "gpt-4o", "gpt-4o-mini"],
+        tested: false,
+        description: "Requires claude-code-router for API translation"
+      },
+      google: {
+        name: "google",
+        displayName: "Google (Gemini)",
+        compatibility: "router",
+        models: ["gemini-3-pro-preview", "gemini-3-flash-preview"],
+        tested: false,
+        description: "Requires claude-code-router for API translation"
+      }
+    };
+  }
+});
+
+// src/lib/model-capabilities.ts
+function getModelCapability(model) {
+  return MODEL_CAPABILITIES[model];
+}
+var MODEL_DEPRECATIONS, MODEL_CAPABILITIES;
+var init_model_capabilities = __esm({
+  "src/lib/model-capabilities.ts"() {
+    "use strict";
+    init_esm_shims();
+    MODEL_DEPRECATIONS = {
+      "claude-opus-4-5": "claude-opus-4-6",
+      "claude-sonnet-4-5": "claude-sonnet-4-6"
+    };
+    MODEL_CAPABILITIES = {
+      // ═══════════════════════════════════════════════════════════════════════════
+      // ANTHROPIC MODELS
+      // ═══════════════════════════════════════════════════════════════════════════
+      "claude-opus-4-6": {
+        model: "claude-opus-4-6",
+        provider: "anthropic",
+        displayName: "Claude Opus 4.6",
+        costPer1MTokens: 45,
+        // $5 in / $25 out → same pricing as 4.5
+        contextWindow: 2e5,
+        // 1M available via opt-in beta, but we use 200K
+        skills: {
+          "code-generation": 96,
+          // 80.9% SWE-bench (first >80%), 89.4% Aider Polyglot
+          "code-review": 98,
+          debugging: 97,
+          planning: 99,
+          // User confirms: "Opus 4.6 planning for sure"
+          documentation: 95,
+          testing: 92,
+          security: 98,
+          // Best for security review
+          performance: 90,
+          synthesis: 98,
+          // Best for combining info across domains
+          speed: 40,
+          // Slower but 76% more token efficient
+          "context-length": 95
+        },
+        notes: "Successor to Opus 4.5. Same pricing, 1M context available (opt-in beta). Best for planning, security, complex reasoning."
+      },
+      "claude-sonnet-4-6": {
+        model: "claude-sonnet-4-6",
+        provider: "anthropic",
+        displayName: "Claude Sonnet 4.6",
+        costPer1MTokens: 9,
+        // $3 in / $15 out → avg ~$9
+        contextWindow: 2e5,
+        skills: {
+          "code-generation": 94,
+          "code-review": 94,
+          debugging: 92,
+          planning: 90,
+          documentation: 92,
+          testing: 92,
+          security: 88,
+          performance: 88,
+          synthesis: 90,
+          speed: 70,
+          "context-length": 95
+        },
+        notes: "Successor to Sonnet 4.5. Same pricing tier. Improved coding and reasoning."
+      },
+      "claude-sonnet-4-5": {
+        model: "claude-sonnet-4-5",
+        provider: "anthropic",
+        displayName: "Claude Sonnet 4.5",
+        costPer1MTokens: 9,
+        // $3 in / $15 out → avg ~$9
+        contextWindow: 2e5,
+        skills: {
+          "code-generation": 92,
+          // 77.2% SWE-bench (82% parallel), beats GPT-5 Codex (74.5%)
+          "code-review": 92,
+          debugging: 90,
+          planning: 88,
+          documentation: 90,
+          // 100% AIME with Python
+          testing: 90,
+          // 50% Terminal-Bench, 61.4% OSWorld
+          security: 85,
+          performance: 85,
+          synthesis: 88,
+          speed: 70,
+          "context-length": 95
+        },
+        notes: "Best value: 77.2% SWE-bench at 1/5th Opus cost. Beats GPT-5 Codex."
+      },
+      "claude-haiku-4-5": {
+        model: "claude-haiku-4-5",
+        provider: "anthropic",
+        displayName: "Claude Haiku 4.5",
+        costPer1MTokens: 4,
+        // $0.80 in / $4 out → avg ~$2.4
+        contextWindow: 2e5,
+        skills: {
+          "code-generation": 75,
+          "code-review": 72,
+          debugging: 70,
+          planning: 65,
+          documentation: 75,
+          testing: 70,
+          security: 60,
+          performance: 65,
+          synthesis: 68,
+          speed: 95,
+          // Fastest Anthropic
+          "context-length": 95
+        },
+        notes: "Fast and cheap, good for simple tasks and exploration"
+      },
+      // ═══════════════════════════════════════════════════════════════════════════
+      // OPENAI MODELS
+      // ═══════════════════════════════════════════════════════════════════════════
+      "gpt-5.2-codex": {
+        model: "gpt-5.2-codex",
+        provider: "openai",
+        displayName: "GPT-5.2 Codex",
+        costPer1MTokens: 75,
+        // Premium tier ~$75/M
+        contextWindow: 128e3,
+        skills: {
+          "code-generation": 95,
+          // 80% SWE-bench Verified, 55.6% SWE-bench Pro
+          "code-review": 90,
+          debugging: 92,
+          // 92.4% GPQA Diamond
+          planning: 88,
+          documentation: 85,
+          testing: 90,
+          security: 85,
+          performance: 88,
+          // 52.9% ARC-AGI-2 (best reasoning)
+          synthesis: 88,
+          // 100% AIME 2025 without tools
+          speed: 55,
+          "context-length": 75
+        },
+        notes: "Premium coding: 80% SWE-bench. Best raw reasoning (52.9% ARC-AGI-2). Expensive."
+      },
+      "o3-deep-research": {
+        model: "o3-deep-research",
+        provider: "openai",
+        displayName: "O3 Deep Research",
+        costPer1MTokens: 100,
+        // Expensive reasoning model
+        contextWindow: 2e5,
+        skills: {
+          "code-generation": 85,
+          "code-review": 95,
+          debugging: 98,
+          // Best for debugging
+          planning: 95,
+          documentation: 88,
+          testing: 85,
+          security: 92,
+          performance: 92,
+          synthesis: 95,
+          speed: 20,
+          // Very slow (reasoning chains)
+          "context-length": 95
+        },
+        notes: "Deep reasoning model, excellent for complex debugging and analysis"
+      },
+      "gpt-4o": {
+        model: "gpt-4o",
+        provider: "openai",
+        displayName: "GPT-4o",
+        costPer1MTokens: 15,
+        // $5 in / $15 out
+        contextWindow: 128e3,
+        skills: {
+          "code-generation": 88,
+          "code-review": 85,
+          debugging: 85,
+          planning: 82,
+          documentation: 88,
+          testing: 82,
+          security: 78,
+          performance: 80,
+          synthesis: 85,
+          speed: 75,
+          "context-length": 75
+        },
+        notes: "Good all-rounder, competitive with Sonnet"
+      },
+      "gpt-4o-mini": {
+        model: "gpt-4o-mini",
+        provider: "openai",
+        displayName: "GPT-4o Mini",
+        costPer1MTokens: 1,
+        // Very cheap
+        contextWindow: 128e3,
+        skills: {
+          "code-generation": 72,
+          "code-review": 68,
+          debugging: 65,
+          planning: 60,
+          documentation: 70,
+          testing: 65,
+          security: 55,
+          performance: 60,
+          synthesis: 62,
+          speed: 92,
+          "context-length": 75
+        },
+        notes: "Budget option, good for simple tasks"
+      },
+      // ═══════════════════════════════════════════════════════════════════════════
+      // GOOGLE MODELS
+      // ═══════════════════════════════════════════════════════════════════════════
+      "gemini-3-pro-preview": {
+        model: "gemini-3-pro-preview",
+        provider: "google",
+        displayName: "Gemini 3 Pro",
+        costPer1MTokens: 12,
+        // $4.2 in / $18.9 out
+        contextWindow: 1e6,
+        // 1M context!
+        skills: {
+          "code-generation": 90,
+          // 2439 Elo LiveCodeBench Pro (first >1500 on LMArena)
+          "code-review": 88,
+          debugging: 85,
+          planning: 85,
+          documentation: 88,
+          testing: 85,
+          // ~95% AIME 2025
+          security: 78,
+          performance: 85,
+          // Strong multimodal
+          synthesis: 90,
+          // Best for combining large codebases
+          speed: 80,
+          "context-length": 100
+          // Best context - 1M tokens
+        },
+        notes: "First to exceed 1500 Elo on LMArena. Best for large codebase analysis with 1M context."
+      },
+      "gemini-3-flash-preview": {
+        model: "gemini-3-flash-preview",
+        provider: "google",
+        displayName: "Gemini 3 Flash",
+        costPer1MTokens: 0.5,
+        // Very cheap
+        contextWindow: 1e6,
+        skills: {
+          "code-generation": 75,
+          "code-review": 70,
+          debugging: 68,
+          planning: 62,
+          documentation: 72,
+          testing: 68,
+          security: 55,
+          performance: 65,
+          synthesis: 70,
+          speed: 98,
+          // Fastest overall
+          "context-length": 100
+        },
+        notes: "Extremely fast and cheap, huge context, great for exploration"
+      },
+      "gemini-2.5-pro": {
+        model: "gemini-2.5-pro",
+        provider: "google",
+        displayName: "Gemini 2.5 Pro",
+        costPer1MTokens: 12,
+        contextWindow: 1e6,
+        skills: {
+          "code-generation": 92,
+          "code-review": 90,
+          debugging: 88,
+          planning: 88,
+          documentation: 90,
+          testing: 87,
+          security: 82,
+          performance: 88,
+          synthesis: 92,
+          speed: 75,
+          "context-length": 100
+        },
+        notes: "Advanced reasoning and code capabilities with 1M context"
+      },
+      "gemini-2.5-flash": {
+        model: "gemini-2.5-flash",
+        provider: "google",
+        displayName: "Gemini 2.5 Flash",
+        costPer1MTokens: 0.6,
+        contextWindow: 1e6,
+        skills: {
+          "code-generation": 78,
+          "code-review": 73,
+          debugging: 70,
+          planning: 65,
+          documentation: 75,
+          testing: 70,
+          security: 58,
+          performance: 68,
+          synthesis: 73,
+          speed: 95,
+          "context-length": 100
+        },
+        notes: "Fast and efficient with large context support"
+      },
+      // ═══════════════════════════════════════════════════════════════════════════
+      // Z.AI MODELS
+      // ═══════════════════════════════════════════════════════════════════════════
+      "glm-4.7": {
+        model: "glm-4.7",
+        provider: "zai",
+        displayName: "GLM 4.7",
+        costPer1MTokens: 5,
+        contextWindow: 2e5,
+        // 200K context, 128K output
+        skills: {
+          "code-generation": 88,
+          // 73.8% SWE-bench, 84.9 LiveCodeBench v6 (open-source SOTA)
+          "code-review": 85,
+          debugging: 85,
+          // Strong debugging with Interleaved Thinking
+          planning: 82,
+          // 95.7% AIME 2025 (beats Gemini 3 & GPT-5.1)
+          documentation: 80,
+          testing: 82,
+          // 87.4 τ²-Bench (SOTA for tool use)
+          security: 72,
+          performance: 78,
+          synthesis: 85,
+          // Preserved Thinking retains context across turns
+          speed: 80,
+          "context-length": 95
+          // 200K context
+        },
+        notes: "Top open-source for agentic coding. 73.8% SWE-bench, best tool use. 400B params with Interleaved Thinking."
+      },
+      "glm-4.7-flash": {
+        model: "glm-4.7-flash",
+        provider: "zai",
+        displayName: "GLM 4.7 Flash",
+        costPer1MTokens: 1.5,
+        contextWindow: 128e3,
+        skills: {
+          "code-generation": 72,
+          "code-review": 68,
+          debugging: 65,
+          planning: 62,
+          documentation: 70,
+          testing: 65,
+          security: 55,
+          performance: 62,
+          synthesis: 65,
+          speed: 92,
+          // Fast inference
+          "context-length": 75
+        },
+        notes: "Fast and affordable. Good for quick iterations and exploration."
+      },
+      // ═══════════════════════════════════════════════════════════════════════════
+      // KIMI MODELS
+      // ═══════════════════════════════════════════════════════════════════════════
+      "kimi-k2": {
+        model: "kimi-k2",
+        provider: "kimi",
+        displayName: "Kimi K2",
+        costPer1MTokens: 1.4,
+        // $0.16 in / $2.63 out → very cheap
+        contextWindow: 131e3,
+        skills: {
+          "code-generation": 82,
+          // 65.8% SWE-bench (beats GPT-4.1 at 54.6%)
+          "code-review": 80,
+          debugging: 78,
+          planning: 75,
+          documentation: 80,
+          testing: 75,
+          security: 70,
+          performance: 72,
+          synthesis: 78,
+          speed: 80,
+          "context-length": 75
+        },
+        notes: "Strong value: 65.8% SWE-bench at very low cost. Good for routine tasks."
+      },
+      "kimi-k2.5": {
+        model: "kimi-k2.5",
+        provider: "kimi",
+        displayName: "Kimi K2.5",
+        costPer1MTokens: 8,
+        // ~5.1x cheaper than GPT-5.2
+        contextWindow: 256e3,
+        skills: {
+          "code-generation": 92,
+          // 76.8% SWE-bench, 85 LiveCodeBench v6
+          "code-review": 90,
+          debugging: 90,
+          // Strong analytical capabilities
+          planning: 88,
+          // User confirms "highly capable"
+          documentation: 88,
+          testing: 88,
+          // 92% coding accuracy
+          security: 82,
+          performance: 85,
+          synthesis: 92,
+          // Can coordinate 100 sub-agents, 1500 tool calls
+          speed: 75,
+          // MoE: 1T total params, 32B active
+          "context-length": 98
+          // 256K context
+        },
+        notes: "Best open-source coding model. 5x cheaper than GPT-5.2. Excellent for frontend dev and multi-agent orchestration."
+      }
+    };
+  }
+});
+
+// src/lib/config-yaml.ts
+import { readFileSync as readFileSync3, existsSync as existsSync3, writeFileSync as writeFileSync3, copyFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+import yaml from "js-yaml";
+function normalizeProviderConfig(providerConfig, fallbackKey) {
+  if (providerConfig === void 0) {
+    return { enabled: false };
+  }
+  if (typeof providerConfig === "boolean") {
+    return { enabled: providerConfig, api_key: fallbackKey };
+  }
+  return {
+    enabled: providerConfig.enabled,
+    api_key: providerConfig.api_key || fallbackKey
+  };
+}
+function resolveEnvVar(value) {
+  if (!value) return void 0;
+  return value.replace(/\$\{?([A-Z_][A-Z0-9_]*)\}?/g, (match, varName) => {
+    const envValue = process.env[varName];
+    return envValue !== void 0 ? envValue : match;
+  });
+}
+function loadYamlFile(filePath) {
+  if (!existsSync3(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    const parsed = yaml.load(content);
+    return parsed || {};
+  } catch (error) {
+    console.error(`Error loading YAML config from ${filePath}:`, error);
+    return null;
+  }
+}
+function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  while (currentDir !== "/") {
+    if (existsSync3(join2(currentDir, ".git"))) {
+      return currentDir;
+    }
+    currentDir = join2(currentDir, "..");
+  }
+  return null;
+}
+function loadProjectConfig() {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    return null;
+  }
+  const projectConfigPath = join2(projectRoot, ".panopticon.yaml");
+  return loadYamlFile(projectConfigPath);
+}
+function loadGlobalConfig() {
+  return loadYamlFile(GLOBAL_CONFIG_PATH);
+}
+function mergeShadowConfig(result, config) {
+  if (!config?.shadow) return;
+  if (config.shadow.enabled !== void 0) {
+    result.enabled = config.shadow.enabled;
+  }
+  if (config.shadow.trackers) {
+    if (config.shadow.trackers.linear !== void 0) {
+      result.trackers.linear = config.shadow.trackers.linear;
+    }
+    if (config.shadow.trackers.github !== void 0) {
+      result.trackers.github = config.shadow.trackers.github;
+    }
+    if (config.shadow.trackers.gitlab !== void 0) {
+      result.trackers.gitlab = config.shadow.trackers.gitlab;
+    }
+    if (config.shadow.trackers.rally !== void 0) {
+      result.trackers.rally = config.shadow.trackers.rally;
+    }
+  }
+}
+function mergeConfigs(...configs) {
+  const result = {
+    ...DEFAULT_CONFIG,
+    enabledProviders: new Set(DEFAULT_CONFIG.enabledProviders),
+    shadow: {
+      enabled: DEFAULT_CONFIG.shadow.enabled,
+      trackers: { ...DEFAULT_CONFIG.shadow.trackers }
+    }
+  };
+  const validConfigs = configs.filter((c) => c !== null);
+  for (const config of validConfigs.reverse()) {
+    if (config.models?.providers) {
+      const providers = config.models.providers;
+      const legacyKeys = config.api_keys || {};
+      result.enabledProviders.add("anthropic");
+      const openai = normalizeProviderConfig(providers.openai, legacyKeys.openai);
+      if (openai.enabled) {
+        result.enabledProviders.add("openai");
+        if (openai.api_key) {
+          result.apiKeys.openai = resolveEnvVar(openai.api_key);
+        }
+      }
+      const google = normalizeProviderConfig(providers.google, legacyKeys.google);
+      if (google.enabled) {
+        result.enabledProviders.add("google");
+        if (google.api_key) {
+          result.apiKeys.google = resolveEnvVar(google.api_key);
+        }
+      }
+      const zai = normalizeProviderConfig(providers.zai, legacyKeys.zai);
+      if (zai.enabled) {
+        result.enabledProviders.add("zai");
+        if (zai.api_key) {
+          result.apiKeys.zai = resolveEnvVar(zai.api_key);
+        }
+      }
+      const kimi = normalizeProviderConfig(providers.kimi, legacyKeys.kimi);
+      if (kimi.enabled) {
+        result.enabledProviders.add("kimi");
+        if (kimi.api_key) {
+          result.apiKeys.kimi = resolveEnvVar(kimi.api_key);
+        }
+      }
+    }
+    if (config.api_keys) {
+      if (config.api_keys.openai) {
+        result.apiKeys.openai = resolveEnvVar(config.api_keys.openai);
+        result.enabledProviders.add("openai");
+      }
+      if (config.api_keys.google) {
+        result.apiKeys.google = resolveEnvVar(config.api_keys.google);
+        result.enabledProviders.add("google");
+      }
+      if (config.api_keys.zai) {
+        result.apiKeys.zai = resolveEnvVar(config.api_keys.zai);
+        result.enabledProviders.add("zai");
+      }
+      if (config.api_keys.kimi) {
+        result.apiKeys.kimi = resolveEnvVar(config.api_keys.kimi);
+        result.enabledProviders.add("kimi");
+      }
+    }
+    if (config.models?.overrides) {
+      result.overrides = {
+        ...result.overrides,
+        ...config.models.overrides
+      };
+    }
+    if (config.models?.gemini_thinking_level) {
+      result.geminiThinkingLevel = config.models.gemini_thinking_level;
+    }
+    if (config.tracker_keys) {
+      if (config.tracker_keys.linear) {
+        result.trackerKeys.linear = resolveEnvVar(config.tracker_keys.linear);
+      }
+      if (config.tracker_keys.github) {
+        result.trackerKeys.github = resolveEnvVar(config.tracker_keys.github);
+      }
+      if (config.tracker_keys.gitlab) {
+        result.trackerKeys.gitlab = resolveEnvVar(config.tracker_keys.gitlab);
+      }
+      if (config.tracker_keys.rally) {
+        result.trackerKeys.rally = resolveEnvVar(config.tracker_keys.rally);
+      }
+    }
+    mergeShadowConfig(result.shadow, config);
+  }
+  return result;
+}
+function detectDeprecatedModels(config) {
+  if (!config?.models?.overrides) {
+    return [];
+  }
+  const migrations = [];
+  for (const [workType, modelId] of Object.entries(config.models.overrides)) {
+    if (modelId && MODEL_DEPRECATIONS[modelId]) {
+      migrations.push({
+        workType,
+        from: modelId,
+        to: MODEL_DEPRECATIONS[modelId]
+      });
+    }
+  }
+  return migrations;
+}
+function applyMigrations(config, migrations) {
+  if (!config.models) {
+    config.models = {};
+  }
+  if (!config.models.overrides) {
+    config.models.overrides = {};
+  }
+  for (const { workType, to } of migrations) {
+    config.models.overrides[workType] = to;
+  }
+}
+function backupGlobalConfig() {
+  try {
+    const backupPath = `${GLOBAL_CONFIG_PATH}.bak`;
+    copyFileSync(GLOBAL_CONFIG_PATH, backupPath);
+    console.log(`\u2713 Backed up config.yaml \u2192 config.yaml.bak`);
+    return true;
+  } catch (error) {
+    console.error(`Failed to create config backup:`, error);
+    return false;
+  }
+}
+function writeGlobalConfig(config) {
+  const yamlContent = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 100,
+    noRefs: true
+  });
+  writeFileSync3(GLOBAL_CONFIG_PATH, yamlContent, "utf-8");
+}
+function loadConfig() {
+  let globalConfig = loadGlobalConfig();
+  const projectConfig = loadProjectConfig();
+  let migrationResult;
+  if (globalConfig && hasGlobalConfig()) {
+    const migrations = detectDeprecatedModels(globalConfig);
+    if (migrations.length > 0) {
+      const backedUp = backupGlobalConfig();
+      applyMigrations(globalConfig, migrations);
+      writeGlobalConfig(globalConfig);
+      console.log("\n\u{1F504} Model ID Migration:");
+      for (const { workType, from, to } of migrations) {
+        console.log(`  ${workType}: ${from} \u2192 ${to}`);
+      }
+      console.log("");
+      migrationResult = { migrated: migrations, backedUp };
+    }
+  }
+  const config = mergeConfigs(projectConfig, globalConfig);
+  if (process.env.OPENAI_API_KEY && !config.apiKeys.openai) {
+    config.apiKeys.openai = process.env.OPENAI_API_KEY;
+    config.enabledProviders.add("openai");
+  }
+  if (process.env.GOOGLE_API_KEY && !config.apiKeys.google) {
+    config.apiKeys.google = process.env.GOOGLE_API_KEY;
+    config.enabledProviders.add("google");
+  }
+  if (process.env.ZAI_API_KEY && !config.apiKeys.zai) {
+    config.apiKeys.zai = process.env.ZAI_API_KEY;
+    config.enabledProviders.add("zai");
+  }
+  if (process.env.KIMI_API_KEY && !config.apiKeys.kimi) {
+    config.apiKeys.kimi = process.env.KIMI_API_KEY;
+    config.enabledProviders.add("kimi");
+  }
+  if (process.env.LINEAR_API_KEY && !config.trackerKeys.linear) {
+    config.trackerKeys.linear = process.env.LINEAR_API_KEY;
+  }
+  if (process.env.GITHUB_TOKEN && !config.trackerKeys.github) {
+    config.trackerKeys.github = process.env.GITHUB_TOKEN;
+  }
+  if (process.env.GITLAB_TOKEN && !config.trackerKeys.gitlab) {
+    config.trackerKeys.gitlab = process.env.GITLAB_TOKEN;
+  }
+  if (process.env.RALLY_API_KEY && !config.trackerKeys.rally) {
+    config.trackerKeys.rally = process.env.RALLY_API_KEY;
+  }
+  if (process.env.SHADOW_MODE !== void 0) {
+    const envShadowMode = ["true", "1", "yes"].includes(process.env.SHADOW_MODE.toLowerCase());
+    config.shadow.enabled = envShadowMode;
+  }
+  return { config, migration: migrationResult };
+}
+function hasGlobalConfig() {
+  return existsSync3(GLOBAL_CONFIG_PATH);
+}
+var DEFAULT_CONFIG, GLOBAL_CONFIG_PATH;
+var init_config_yaml = __esm({
+  "src/lib/config-yaml.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_model_capabilities();
+    DEFAULT_CONFIG = {
+      enabledProviders: /* @__PURE__ */ new Set(["anthropic"]),
+      // Only Anthropic by default
+      apiKeys: {},
+      overrides: {},
+      geminiThinkingLevel: 3,
+      trackerKeys: {},
+      shadow: {
+        enabled: false,
+        trackers: {
+          linear: false,
+          github: false,
+          gitlab: false,
+          rally: false
+        }
+      }
+    };
+    GLOBAL_CONFIG_PATH = join2(homedir(), ".panopticon", "config.yaml");
+  }
+});
+
+export {
+  loadSettings,
+  saveSettings,
+  validateSettings,
+  getDefaultSettings,
+  getAvailableModels,
+  isAnthropicModel,
+  getClaudeModelFlag,
+  getAgentCommand,
+  init_settings,
+  MODEL_CAPABILITIES,
+  getModelCapability,
+  init_model_capabilities,
+  loadConfig,
+  init_config_yaml,
+  PROVIDERS,
+  getProviderForModel,
+  requiresRouter,
+  getRouterProviders,
+  getDirectProviders,
+  needsRouter,
+  getProviderEnv,
+  setupCredentialFileAuth,
+  clearCredentialFileAuth,
+  init_providers
+};
+//# sourceMappingURL=chunk-HJSM6E6U.js.map