kc-beta 0.1.1 → 0.2.1

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();
+}

package/src/cli/index.js

@@ -29,11 +29,23 @@ function App({ engine, config }) {
   const [sessionId, setSessionId] = useState(engine.workspace.sessionId);
   const [phase, setPhase] = useState(engine.currentPhase);
   const [showWelcome, setShowWelcome] = useState(true);
+  const [spinnerStatus, setSpinnerStatus] = useState(null);
+  const [contextTokens, setContextTokens] = useState(0);
+  const [contextLimit, setContextLimit] = useState(config.kcContextLimit || 200000);
 
   const engineRef = useRef(engine);
   const streamingRef = useRef(false);
   const queueRef = useRef([]);
 
+  // Update context stats
+  const updateContextStats = useCallback(() => {
+    try {
+      const stats = engineRef.current.getContextStats();
+      setContextTokens(stats.totalTokens);
+      setContextLimit(stats.limit);
+    } catch { /* ignore */ }
+  }, []);
+
   const addMessage = useCallback((msg) => {
     setMessages((prev) => [...prev, msg]);
   }, []);
@@ -43,6 +55,7 @@ function App({ engine, config }) {
     setStreaming(true);
     setStreamingText("");
     setCurrentTool(null);
+    setSpinnerStatus("Thinking...");
 
     let accumulated = "";
 
@@ -52,6 +65,7 @@ function App({ engine, config }) {
           case "text_delta":
             accumulated += event.text ?? "";
             setStreamingText(accumulated);
+            setSpinnerStatus("Thinking...");
             break;
 
           case "turn_complete":
@@ -61,6 +75,8 @@ function App({ engine, config }) {
             accumulated = "";
             setStreamingText("");
             setCurrentTool(null);
+            setSpinnerStatus(null);
+            updateContextStats();
             break;
 
           case "tool_start":
@@ -71,6 +87,7 @@ function App({ engine, config }) {
               setStreamingText("");
             }
             setCurrentTool({ name: event.name, input: event.input, output: null, isError: false, isRunning: true });
+            setSpinnerStatus(`Running ${event.name}...`);
             break;
 
           case "tool_result":
@@ -83,6 +100,7 @@ function App({ engine, config }) {
               toolIsError: event.isError,
             });
             setCurrentTool(null);
+            setSpinnerStatus("Analyzing results...");
             break;
 
           case "pipeline_event": {
@@ -103,13 +121,15 @@ function App({ engine, config }) {
 
     streamingRef.current = false;
     setStreaming(false);
+    setSpinnerStatus(null);
+    updateContextStats();
 
     // Process queue
     if (queueRef.current.length > 0) {
       const next = queueRef.current.shift();
       runTurn(next);
     }
-  }, [addMessage]);
+  }, [addMessage, updateContextStats]);
 
   const handleSlashCommand = useCallback((text) => {
     const parts = text.split(/\s+/);
@@ -125,6 +145,7 @@ function App({ engine, config }) {
             "  /help                Show this help\n" +
             "  /status              Show session info, model, phase, workspace\n" +
             "  /clear               Clear conversation history (keep workspace)\n" +
+            "  /compact             Summarize older messages to reduce context\n" +
             "  /sessions            List all sessions\n" +
             "  /resume <name>       Resume a previous session\n" +
             "  /rename <name>       Rename current session\n" +
@@ -132,26 +153,53 @@ function App({ engine, config }) {
         });
         return true;
 
-      case "/status":
+      case "/status": {
+        const stats = engineRef.current.getContextStats();
         addMessage({
           role: "system",
           content:
             `Session:   ${engineRef.current.workspace.sessionId}\n` +
             `Phase:     ${engineRef.current.currentPhase.toUpperCase()}\n` +
             `Model:     ${config.kcModel}\n` +
+            `Provider:  ${config.provider || "unknown"}\n` +
             `LLM URL:   ${config.llmBaseUrl}\n` +
             `Workspace: ${engineRef.current.workspace.cwd}\n` +
             `Tools:     ${engineRef.current.toolRegistry.size} registered\n` +
-            `History:   ${engineRef.current.history.messages.length} messages`,
+            `History:   ${engineRef.current.history.messages.length} messages\n` +
+            `Context:   ~${stats.totalTokens} tokens (${stats.percentage}% of ${stats.limit})`,
         });
         return true;
+      }
 
       case "/clear":
         engineRef.current.history = new ConversationHistory(engineRef.current.workspace.cwd);
         setMessages([]);
         addMessage({ role: "system", content: "Conversation cleared. Workspace and pipeline state preserved." });
+        updateContextStats();
         return true;
 
+      case "/compact": {
+        addMessage({ role: "system", content: "Compacting conversation history..." });
+        // Run compact asynchronously
+        (async () => {
+          try {
+            const result = await engineRef.current.compact();
+            if (result) {
+              addMessage({
+                role: "system",
+                content: `Compacted: removed ${result.removedCount} messages, kept ${result.retainedCount}. Summary: ~${result.summaryTokens} tokens.`,
+              });
+            } else {
+              addMessage({ role: "system", content: "Nothing to compact (conversation is short enough)." });
+            }
+            updateContextStats();
+          } catch (err) {
+            addMessage({ role: "system", content: `Compact failed: ${err.message}` });
+          }
+        })();
+        return true;
+      }
+
       case "/rename":
         if (!arg) {
           addMessage({ role: "system", content: "Usage: /rename <new_name>" });
@@ -193,19 +241,46 @@ function App({ engine, config }) {
             addMessage({ role: "system", content: "Sessions:\n" + lines.join("\n") + "\n\nUsage: /resume <name>" });
           }
         } else {
-          addMessage({ role: "system", content: `Resuming session: ${arg} (not yet implemented)` });
+          // Resume a previous session
+          (async () => {
+            try {
+              const client = new LLMClient({
+                apiKey: config.llmApiKey,
+                baseUrl: config.llmBaseUrl,
+                authType: config.authType,
+                apiFormat: config.apiFormat,
+              });
+              const resumed = await AgentEngine.resume({ client, config, sessionId: arg });
+              engineRef.current = resumed;
+              setSessionId(resumed.workspace.sessionId);
+              setPhase(resumed.currentPhase);
+              setMessages([]);
+              addMessage({
+                role: "system",
+                content:
+                  `Resumed session: ${arg}\n` +
+                  `Phase: ${resumed.currentPhase.toUpperCase()}\n` +
+                  `History: ${resumed.history.messages.length} messages restored`,
+              });
+              updateContextStats();
+            } catch (err) {
+              addMessage({ role: "system", content: `Resume failed: ${err.message}` });
+            }
+          })();
         }
         return true;
 
       case "/exit":
       case "/quit":
+        // Save state before exit
+        try { engineRef.current.saveState(); } catch { /* ignore */ }
         exit();
         return true;
 
       default:
         return false;
     }
-  }, [addMessage, config, exit]);
+  }, [addMessage, config, exit, updateContextStats]);
 
   const handleSubmit = useCallback((text) => {
     const trimmed = text.trim();
@@ -233,10 +308,12 @@ function App({ engine, config }) {
         queueRef.current.length = 0;
         addMessage({ role: "system", content: "[Queue cleared]" });
       } else {
+        try { engineRef.current.saveState(); } catch { /* ignore */ }
         exit();
       }
     }
     if (key.ctrl && input === "d") {
+      try { engineRef.current.saveState(); } catch { /* ignore */ }
       exit();
     }
   });
@@ -291,9 +368,9 @@ function App({ engine, config }) {
       isRunning: true,
     }) : null,
 
-    // Spinner while waiting
-    streaming && !streamingText && !currentTool
-      ? h(CookingSpinner)
+    // Activity indicator while KC is working
+    streaming
+      ? h(CookingSpinner, { status: spinnerStatus })
       : null,
 
     // Separator + Input
@@ -305,13 +382,18 @@ function App({ engine, config }) {
       isActive: !streaming,
     }),
     h(HRule),
-    h(StatusBar, { sessionId, phase }),
+    h(StatusBar, { sessionId, phase, contextTokens, contextLimit }),
   );
 }
 
-export async function main() {
+export async function main({ languageOverride } = {}) {
   const config = loadSettings();
 
+  // Session-only language override (does NOT persist to config)
+  if (languageOverride) {
+    config.language = languageOverride;
+  }
+
   if (!config.llmApiKey) {
     console.error("Error: No API key configured. Run 'kc-beta onboard' first.");
     process.exit(1);
@@ -320,10 +402,17 @@ export async function main() {
   const client = new LLMClient({
     apiKey: config.llmApiKey,
     baseUrl: config.llmBaseUrl,
+    authType: config.authType,
+    apiFormat: config.apiFormat,
   });
 
   const engine = new AgentEngine({ client, config });
 
+  // Save state on process exit
+  const saveOnExit = () => { try { engine.saveState(); } catch { /* ignore */ } };
+  process.on("SIGINT", saveOnExit);
+  process.on("SIGTERM", saveOnExit);
+
   const instance = render(h(App, { engine, config }));
   await instance.waitUntilExit();
 }