kc-beta 0.1.2 → 0.2.1

package/src/agent/retry.js

@@ -0,0 +1,83 @@
+/**
+ * Retry wrapper with exponential backoff and jitter.
+ * Designed for LLM API calls — retries transient errors, fails fast on auth/validation errors.
+ */
+
+const MAX_RETRIES = 10;
+const INITIAL_DELAY_MS = 1000;
+const MAX_DELAY_MS = 60000;
+const BACKOFF_MULTIPLIER = 2;
+const JITTER_FRACTION = 0.2;
+
+const RETRYABLE_STATUS = new Set([408, 429, 500, 502, 503, 504, 520, 522, 524]);
+const NON_RETRYABLE_STATUS = new Set([400, 401, 403, 404, 422]);
+
+/**
+ * Determine if an error is retryable.
+ * @param {Error} err
+ * @returns {boolean}
+ */
+function isRetryable(err) {
+  if (err.status) {
+    if (NON_RETRYABLE_STATUS.has(err.status)) return false;
+    if (RETRYABLE_STATUS.has(err.status)) return true;
+  }
+  // Network errors (ECONNRESET, ETIMEDOUT, fetch TypeError, AbortError)
+  const msg = err.message || "";
+  if (/ECONNRESET|ETIMEDOUT|ENOTFOUND|ECONNREFUSED|UND_ERR|fetch failed|network|socket hang up/i.test(msg)) {
+    return true;
+  }
+  if (err.name === "AbortError" || err.name === "TimeoutError") return true;
+  // If we have a status code and it's not in our known sets, retry server errors (5xx)
+  if (err.status && err.status >= 500) return true;
+  // Unknown errors without status — retry conservatively
+  return !err.status;
+}
+
+/**
+ * Calculate delay for a given attempt using exponential backoff with jitter.
+ * @param {number} attempt - 0-indexed attempt number
+ * @param {number|null} retryAfterSec - Retry-After header value in seconds
+ * @returns {number} Delay in milliseconds
+ */
+function calculateDelay(attempt, retryAfterSec) {
+  if (retryAfterSec && retryAfterSec > 0) {
+    return Math.min(retryAfterSec * 1000, MAX_DELAY_MS);
+  }
+  const base = Math.min(INITIAL_DELAY_MS * Math.pow(BACKOFF_MULTIPLIER, attempt), MAX_DELAY_MS);
+  const jitter = base * JITTER_FRACTION * Math.random();
+  return base + jitter;
+}
+
+/**
+ * Execute an async function with retry logic.
+ *
+ * @param {() => Promise<any>} fn - The async function to execute. Should throw with
+ *   an error that has `.status` and optionally `.retryAfter` properties on failure.
+ * @returns {Promise<any>} The successful result
+ * @throws {Error} The last error after all retries exhausted, or a non-retryable error immediately
+ */
+export async function withRetry(fn) {
+  let lastError;
+
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+
+      if (!isRetryable(err)) throw err;
+      if (attempt === MAX_RETRIES) break;
+
+      const retryAfterSec = err.retryAfter ? parseFloat(err.retryAfter) : null;
+      const delay = calculateDelay(attempt, retryAfterSec);
+
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+
+  const wrapper = new Error(`LLM API call failed after ${MAX_RETRIES + 1} attempts: ${lastError.message}`);
+  wrapper.cause = lastError;
+  wrapper.status = lastError.status;
+  throw wrapper;
+}

package/src/agent/session-state.js

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Persists session state (phase, pipeline milestones, phase summaries)
+ * to enable cross-session resume.
+ *
+ * Stored as: workspace/{sessionId}/session-state.json
+ */
+export class SessionState {
+  /**
+   * @param {string} workspacePath - Session workspace directory
+   */
+  constructor(workspacePath) {
+    this._path = path.join(workspacePath, "session-state.json");
+  }
+
+  /** Whether a session state file exists */
+  get exists() {
+    return fs.existsSync(this._path);
+  }
+
+  /**
+   * Save engine state to disk.
+   * @param {import('./engine.js').AgentEngine} engine
+   */
+  save(engine) {
+    const state = {
+      version: 1,
+      sessionId: engine.workspace.sessionId,
+      currentPhase: engine.currentPhase,
+      phaseSummaries: engine._phaseSummaries || [],
+      lastEventSeq: engine.eventLog?.currentSeq || 0,
+      createdAt: this._loadRaw()?.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      pipelineMilestones: this._extractMilestones(engine.pipelines),
+    };
+
+    fs.writeFileSync(this._path, JSON.stringify(state, null, 2), "utf-8");
+  }
+
+  /**
+   * Load session state from disk.
+   * @returns {object} The persisted state
+   */
+  load() {
+    return this._loadRaw() || {};
+  }
+
+  /**
+   * Read raw file contents.
+   */
+  _loadRaw() {
+    if (!this.exists) return null;
+    try {
+      return JSON.parse(fs.readFileSync(this._path, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Serialize pipeline milestones for persistence.
+   * @param {object} pipelines - Map of phase -> pipeline instance
+   * @returns {object}
+   */
+  _extractMilestones(pipelines) {
+    const milestones = {};
+    for (const [phase, pipeline] of Object.entries(pipelines)) {
+      if (pipeline?.exportState) {
+        try {
+          milestones[phase] = pipeline.exportState();
+        } catch { /* skip if not implemented */ }
+      }
+    }
+    return milestones;
+  }
+}

package/src/agent/token-counter.js

@@ -0,0 +1,62 @@
+/**
+ * Lightweight token estimation without external dependencies.
+ * Uses character-based heuristics: ~4 chars per token for Latin text,
+ * ~1.5 tokens per CJK character.
+ */
+
+// CJK Unified Ideographs and extensions
+const CJK_REGEX = /[\u4e00-\u9fff\u3400-\u4dbf\uf900-\ufaff]/g;
+
+/**
+ * Estimate the number of tokens in a string.
+ * @param {string} text
+ * @returns {number}
+ */
+export function estimateTokens(text) {
+  if (!text) return 0;
+  const cjkMatches = text.match(CJK_REGEX);
+  const cjkCount = cjkMatches ? cjkMatches.length : 0;
+  const nonCjkLength = text.length - cjkCount;
+  return Math.ceil(nonCjkLength / 4) + Math.ceil(cjkCount * 1.5);
+}
+
+/**
+ * Estimate total tokens for an array of OpenAI-format messages.
+ * Accounts for per-message overhead (~4 tokens for role/formatting).
+ * @param {Array<object>} messages
+ * @returns {number}
+ */
+export function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += 4; // role + formatting overhead
+    if (typeof msg.content === "string") {
+      total += estimateTokens(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      // Anthropic-style content blocks
+      for (const block of msg.content) {
+        if (block.text) total += estimateTokens(block.text);
+        if (block.content) total += estimateTokens(block.content);
+      }
+    }
+    if (msg.tool_calls) {
+      for (const tc of msg.tool_calls) {
+        total += estimateTokens(tc.function?.name || "");
+        total += estimateTokens(tc.function?.arguments || "");
+      }
+    }
+  }
+  return total;
+}
+
+/**
+ * Format a token count for display (e.g., "45.2k").
+ * @param {number} tokens
+ * @returns {string}
+ */
+export function formatTokenCount(tokens) {
+  if (tokens >= 1000) {
+    return (tokens / 1000).toFixed(1) + "k";
+  }
+  return tokens.toString();
+}

package/src/agent/tools/document-parse.js

@@ -12,13 +12,13 @@ const MIN_CHARS_PER_PAGE = 50;
  * Level 3: OCR models via SiliconFlow — fallback via vision models
  */
 export class DocumentParseTool extends BaseTool {
-  constructor(workspace, { mineruApiUrl, mineruApiKey, siliconflowApiKey, siliconflowBaseUrl, ocrModel } = {}) {
+  constructor(workspace, { mineruApiUrl, mineruApiKey, llmApiKey, llmBaseUrl, siliconflowApiKey, siliconflowBaseUrl, ocrModel } = {}) {
     super();
     this._workspace = workspace;
     this._mineruApiUrl = mineruApiUrl || "";
     this._mineruApiKey = mineruApiKey || "";
-    this._sfApiKey = siliconflowApiKey || "";
-    this._sfBaseUrl = siliconflowBaseUrl || "https://api.siliconflow.cn/v1";
+    this._sfApiKey = llmApiKey || siliconflowApiKey || "";
+    this._sfBaseUrl = llmBaseUrl || siliconflowBaseUrl || "https://api.siliconflow.cn/v1";
     this._ocrModel = ocrModel || "";
   }
 

package/src/agent/tools/web-search.js

@@ -0,0 +1,107 @@
+import { BaseTool, ToolResult } from "./base.js";
+
+/**
+ * Web search via Tavily API.
+ * Returns extracted text content from search results.
+ */
+export class WebSearchTool extends BaseTool {
+  /**
+   * @param {string} apiKey - Tavily API key
+   */
+  constructor(apiKey) {
+    super();
+    this._apiKey = apiKey;
+  }
+
+  get name() { return "web_search"; }
+
+  get description() {
+    return (
+      "Search the web for information using Tavily. Returns extracted text from top results. " +
+      "IMPORTANT: Always prioritize information from user-provided domain documents " +
+      "(uploaded regulations, sample files, workspace documents) over web search results. " +
+      "Use web search only when: (1) the needed information is not in provided documents, " +
+      "(2) you need to verify or supplement document content with external sources, or " +
+      "(3) the user explicitly asks for web information (e.g., latest LLM model info, API docs)."
+    );
+  }
+
+  get inputSchema() {
+    return {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query",
+        },
+        search_depth: {
+          type: "string",
+          enum: ["basic", "advanced"],
+          description: "Search depth: 'basic' for fast results, 'advanced' for more thorough search (default: basic)",
+        },
+        max_results: {
+          type: "integer",
+          description: "Maximum number of results to return (default: 5, max: 10)",
+        },
+      },
+      required: ["query"],
+    };
+  }
+
+  async execute(input) {
+    const query = input.query || "";
+    if (!query.trim()) {
+      return new ToolResult("No query provided", true);
+    }
+
+    if (!this._apiKey) {
+      return new ToolResult(
+        "Web search is not configured. Set TAVILY_API_KEY in your .env file or global config.",
+        true,
+      );
+    }
+
+    const searchDepth = input.search_depth || "basic";
+    const maxResults = Math.min(input.max_results || 5, 10);
+
+    try {
+      const resp = await fetch("https://api.tavily.com/search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          api_key: this._apiKey,
+          query,
+          search_depth: searchDepth,
+          max_results: maxResults,
+        }),
+        signal: AbortSignal.timeout(15000),
+      });
+
+      if (!resp.ok) {
+        const text = await resp.text();
+        return new ToolResult(`Tavily API error ${resp.status}: ${text}`, true);
+      }
+
+      const data = await resp.json();
+      const results = data.results || [];
+
+      if (results.length === 0) {
+        return new ToolResult(`No results found for: ${query}`);
+      }
+
+      const lines = [];
+      for (const r of results) {
+        lines.push(`--- ${r.title || "Untitled"} ---`);
+        lines.push(`URL: ${r.url || ""}`);
+        lines.push(r.content || "(no content)");
+        lines.push("");
+      }
+
+      return new ToolResult(
+        `Found ${results.length} result(s) for "${query}":\n\n${lines.join("\n")}`,
+      );
+    } catch (err) {
+      return new ToolResult(`Web search failed: ${err.message}`, true);
+    }
+  }
+}

package/src/agent/tools/worker-llm-call.js

@@ -8,15 +8,27 @@ import { BaseTool, ToolResult } from "./base.js";
  * the configured API provider.
  */
 export class WorkerLLMCallTool extends BaseTool {
-  constructor(workspace, { apiKey, baseUrl } = {}) {
+  constructor(workspace, { apiKey, baseUrl, authType = "bearer" } = {}) {
     super();
     this._workspace = workspace;
     this._apiKey = apiKey || "";
     this._baseUrl = (baseUrl || "https://api.siliconflow.cn/v1").replace(/\/+$/, "");
+    this._authType = authType;
     this._tierModels = {};
     this._loadTiers();
   }
 
+  _buildHeaders() {
+    const headers = { "Content-Type": "application/json" };
+    if (this._authType === "x-api-key") {
+      headers["x-api-key"] = this._apiKey;
+      headers["anthropic-version"] = "2023-06-01";
+    } else {
+      headers["Authorization"] = `Bearer ${this._apiKey}`;
+    }
+    return headers;
+  }
+
   _loadTiers() {
     const envPath = path.join(this._workspace.cwd, ".env");
     if (!fs.existsSync(envPath)) return;
@@ -78,10 +90,7 @@ export class WorkerLLMCallTool extends BaseTool {
       try {
         const resp = await fetch(`${this._baseUrl}/chat/completions`, {
           method: "POST",
-          headers: {
-            "Authorization": `Bearer ${this._apiKey}`,
-            "Content-Type": "application/json",
-          },
+          headers: this._buildHeaders(),
           body: JSON.stringify({ model, messages, max_tokens: maxTokens }),
           signal: AbortSignal.timeout(120000),
         });

package/src/cli/components.js

@@ -12,7 +12,7 @@ const COOKING_WORDS = [
   "Stewing", "Tempering", "Whisking", "Zesting", "Garnishing", "Drizzling",
 ];
 
-export function CookingSpinner() {
+export function CookingSpinner({ status }) {
   const [idx, setIdx] = useState(Math.floor(Math.random() * COOKING_WORDS.length));
 
   useEffect(() => {
@@ -20,9 +20,11 @@ export function CookingSpinner() {
     return () => clearInterval(timer);
   }, []);
 
+  const displayText = status || `${COOKING_WORDS[idx]}...`;
+
   return h(Box, null,
     h(Text, { color: "yellow" }, "  * "),
-    h(Text, { dimColor: true }, `${COOKING_WORDS[idx]}...`),
+    h(Text, { dimColor: true }, displayText),
   );
 }
 
@@ -30,13 +32,23 @@ export function CookingSpinner() {
 
 const LENAT_QUOTE = "Intelligence is ten million rules.";
 
-export function StatusBar({ sessionId, phase }) {
+export function StatusBar({ sessionId, phase, contextTokens, contextLimit }) {
+  const pct = contextLimit ? Math.round((contextTokens / contextLimit) * 100) : 0;
+  const ctxColor = pct > 80 ? "red" : pct > 60 ? "yellow" : "green";
+  const ctxLabel = contextTokens >= 1000
+    ? `${(contextTokens / 1000).toFixed(1)}k`
+    : `${contextTokens || 0}`;
+  const limitLabel = contextLimit >= 1000
+    ? `${(contextLimit / 1000).toFixed(0)}k`
+    : `${contextLimit || 0}`;
+
   return h(Box, { marginTop: 0 },
     h(Text, { dimColor: true }, "  ⏵⏵  KC Agent CLI "),
     h(Text, { dimColor: true }, sessionId ? `[${sessionId}]` : ""),
     phase ? h(Text, { color: "cyan" }, ` ${phase.toUpperCase()}`) : null,
     h(Text, { color: "green" }, "  ●  "),
-    h(Text, { dimColor: true }, `· ${LENAT_QUOTE}`),
+    h(Text, { color: ctxColor }, `CTX: ${ctxLabel}/${limitLabel} (${pct}%)`),
+    h(Text, { dimColor: true }, `  · ${LENAT_QUOTE}`),
   );
 }
 

package/src/cli/config.js

@@ -0,0 +1,246 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import os from "node:os";
+import { getProviders, getProviderById, getProviderLabels } from "../providers.js";
+
+const CONFIG_DIR = path.join(os.homedir(), ".kc_agent");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+
+const ESC = "\x1b[";
+const RESET = `${ESC}0m`;
+const BOLD = `${ESC}1m`;
+const DIM = `${ESC}2m`;
+const GREEN = `${ESC}32m`;
+const CYAN = `${ESC}36m`;
+const GRAY = `${ESC}90m`;
+const YELLOW = `${ESC}33m`;
+const RED = `${ESC}31m`;
+
+const L = {
+  en: {
+    title: "KC Agent Configuration",
+    noConfig: "No config found. Run 'kc-beta onboard' first.",
+    menu: "Configuration Categories",
+    choose: "Choose category (q to quit)",
+    categories: ["LLM Provider & API Key", "Model Tiers", "Quality Thresholds", "Language"],
+    saved: "Saved.",
+    back: "← Back to menu",
+    enterKeep: "Press Enter to keep",
+    enterDefault: "Press Enter to use default",
+    currentValue: "current",
+    provider: "Provider",
+    baseUrl: "Base URL",
+    apiKey: "API Key",
+    conductor: "Conductor Model",
+    language: "Language",
+    langOptions: ["English", "中文"],
+  },
+  zh: {
+    title: "KC Agent 配置",
+    noConfig: "未找到配置。请先运行 'kc-beta onboard'。",
+    menu: "配置类别",
+    choose: "选择类别（q 退出）",
+    categories: ["大模型服务商 & API 密钥", "模型分层", "质量阈值", "语言"],
+    saved: "已保存。",
+    back: "← 返回菜单",
+    enterKeep: "回车保留当前值",
+    enterDefault: "回车使用默认值",
+    currentValue: "当前",
+    provider: "服务商",
+    baseUrl: "接口地址",
+    apiKey: "API 密钥",
+    conductor: "主模型",
+    language: "语言",
+    langOptions: ["English", "中文"],
+  },
+};
+
+function loadConfig() {
+  if (fs.existsSync(CONFIG_PATH)) {
+    try { return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8")); } catch { /* ignore */ }
+  }
+  return null;
+}
+
+function saveConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+function ask(rl, question, defaultValue = "", hint = "") {
+  const suffix = defaultValue ? ` ${DIM}[${defaultValue}]${RESET}` : "";
+  const hintText = hint
+    ? ` ${GRAY}(${hint})${RESET}`
+    : defaultValue
+      ? ` ${GRAY}(Press Enter to keep)${RESET}`
+      : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}${hintText}: `, (answer) => resolve(answer.trim() || defaultValue));
+  });
+}
+
+function maskKey(key) {
+  if (!key || key.length < 10) return key || "";
+  return key.slice(0, 6) + "..." + key.slice(-4);
+}
+
+/**
+ * Category 1: LLM Provider & API Key
+ */
+async function editProvider(rl, config, t) {
+  console.log();
+  console.log(`  ${BOLD}${t.categories[0]}${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(35)}${RESET}`);
+
+  // Show current
+  const currentProvider = getProviderById(config.provider);
+  console.log(`  ${DIM}${t.currentValue}: ${config.provider} (${currentProvider?.name || "unknown"})${RESET}`);
+  console.log();
+
+  // Provider selection
+  const providers = getProviders();
+  const labels = getProviderLabels(config.language || "en");
+  console.log(`  ${CYAN}${t.provider}:${RESET}`);
+  for (let i = 0; i < labels.length; i++) {
+    const marker = providers[i].id === config.provider ? ` ${GREEN}(${t.currentValue})${RESET}` : "";
+    console.log(`    ${i + 1}. ${labels[i].label}${marker}`);
+  }
+  const currentIdx = providers.findIndex((p) => p.id === config.provider);
+  const providerChoice = await ask(rl, `  ${GRAY}>${RESET} ${t.choose.split(" (")[0]}`, String(currentIdx + 1 || 1));
+  const provIdx = parseInt(providerChoice, 10) - 1;
+  const provider = providers[Math.max(0, Math.min(provIdx, providers.length - 1))];
+  config.provider = provider.id;
+  config.auth_type = provider.authType;
+  config.api_format = provider.apiFormat;
+  console.log();
+
+  // Base URL
+  if (provider.id === "custom") {
+    config.base_url = await ask(rl, `  ${CYAN}${t.baseUrl}${RESET}`, config.base_url || "");
+  } else {
+    const defaultUrl = provider.baseUrl;
+    console.log(`  ${CYAN}${t.baseUrl}${RESET}: ${DIM}${defaultUrl}${RESET}`);
+    config.base_url = defaultUrl;
+  }
+
+  // API Key
+  const masked = maskKey(config.api_key);
+  const keyPrompt = masked
+    ? `  ${CYAN}${t.apiKey}${RESET} ${DIM}(${masked})${RESET}`
+    : `  ${CYAN}${t.apiKey}${RESET}`;
+  const newKey = await ask(rl, keyPrompt, "", masked ? t.enterKeep : "");
+  if (newKey) config.api_key = newKey;
+
+  // Conductor model
+  console.log();
+  const defaultModel = provider.defaultModel || config.conductor_model || "";
+  config.conductor_model = await ask(rl, `  ${CYAN}${t.conductor}${RESET}`, config.conductor_model || defaultModel, t.enterKeep);
+  console.log();
+}
+
+/**
+ * Category 2: Model Tiers
+ */
+async function editTiers(rl, config, t) {
+  console.log();
+  console.log(`  ${BOLD}${t.categories[1]}${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(35)}${RESET}`);
+  console.log();
+
+  const tiers = config.tiers || {};
+  const provider = getProviderById(config.provider);
+  const defaults = provider?.defaultTiers || {};
+
+  for (const tier of ["tier1", "tier2", "tier3", "tier4"]) {
+    const current = tiers[tier] || defaults[tier] || "";
+    tiers[tier] = await ask(rl, `  ${CYAN}${tier.toUpperCase()}${RESET}`, current, t.enterKeep);
+  }
+  config.tiers = tiers;
+  console.log();
+}
+
+/**
+ * Category 3: Quality Thresholds
+ */
+async function editThresholds(rl, config, t) {
+  console.log();
+  console.log(`  ${BOLD}${t.categories[2]}${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(35)}${RESET}`);
+  console.log();
+
+  config.accuracy_threshold = parseFloat(
+    await ask(rl, `  ${CYAN}Accuracy threshold${RESET}`, String(config.accuracy_threshold ?? 0.9), t.enterKeep)
+  );
+  config.systemic_threshold = parseFloat(
+    await ask(rl, `  ${CYAN}Systemic threshold${RESET}`, String(config.systemic_threshold ?? 0.10), t.enterKeep)
+  );
+  config.spot_check_rate = parseFloat(
+    await ask(rl, `  ${CYAN}Spot-check rate${RESET}`, String(config.spot_check_rate ?? 0.10), t.enterKeep)
+  );
+  config.tier_tolerance = parseFloat(
+    await ask(rl, `  ${CYAN}Tier downgrade tolerance${RESET}`, String(config.tier_tolerance ?? 0.05), t.enterKeep)
+  );
+  console.log();
+}
+
+/**
+ * Category 4: Language
+ */
+async function editLanguage(rl, config, t) {
+  console.log();
+  console.log(`  ${BOLD}${t.categories[3]}${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(35)}${RESET}`);
+  console.log();
+
+  console.log(`  ${CYAN}${t.language}:${RESET}`);
+  console.log(`    1. ${t.langOptions[0]}${config.language === "en" ? ` ${GREEN}(${t.currentValue})${RESET}` : ""}`);
+  console.log(`    2. ${t.langOptions[1]}${config.language === "zh" ? ` ${GREEN}(${t.currentValue})${RESET}` : ""}`);
+  const langDefault = config.language === "zh" ? "2" : "1";
+  const langChoice = await ask(rl, `  ${GRAY}>${RESET}`, langDefault);
+  config.language = langChoice === "2" ? "zh" : "en";
+  console.log();
+}
+
+const CATEGORY_HANDLERS = [editProvider, editTiers, editThresholds, editLanguage];
+
+/**
+ * Main config editor loop.
+ */
+export async function configEditor() {
+  const config = loadConfig();
+  if (!config) {
+    console.log(`\n  ${RED}${L.en.noConfig}${RESET}\n`);
+    process.exit(1);
+  }
+
+  const lang = config.language || "en";
+  const t = L[lang];
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+
+  while (true) {
+    console.log();
+    console.log(`  ${BOLD}${t.title}${RESET}`);
+    console.log(`  ${GRAY}${"─".repeat(35)}${RESET}`);
+    console.log();
+    for (let i = 0; i < t.categories.length; i++) {
+      console.log(`    ${i + 1}. ${t.categories[i]}`);
+    }
+    console.log();
+
+    const choice = await ask(rl, `  ${GRAY}>${RESET} ${t.choose}`, "");
+
+    if (choice === "q" || choice === "Q" || choice === "") break;
+
+    const idx = parseInt(choice, 10) - 1;
+    if (idx >= 0 && idx < CATEGORY_HANDLERS.length) {
+      await CATEGORY_HANDLERS[idx](rl, config, t);
+      saveConfig(config);
+      console.log(`  ${GREEN}✓${RESET} ${t.saved}`);
+    }
+  }
+
+  rl.close();
+  console.log();
+}