kc-beta 0.1.0

package/src/cli/index.js

@@ -0,0 +1,329 @@
+import React, { useState, useEffect, useCallback, useRef } from "react";
+import { render, Box, Text, useApp, useInput } from "ink";
+import { loadSettings } from "../config.js";
+import { LLMClient } from "../agent/llm-client.js";
+import { AgentEngine } from "../agent/engine.js";
+import { Workspace } from "../agent/workspace.js";
+import { ConversationHistory } from "../agent/history.js";
+import {
+  WelcomeBanner,
+  StatusBar,
+  CookingSpinner,
+  ToolBlock,
+  HRule,
+  InputPrompt,
+} from "./components.js";
+
+const h = React.createElement;
+
+/**
+ * Main KC Agent CLI App using Ink (React for terminals).
+ */
+function App({ engine, config }) {
+  const { exit } = useApp();
+  const [messages, setMessages] = useState([]);
+  const [inputValue, setInputValue] = useState("");
+  const [streaming, setStreaming] = useState(false);
+  const [streamingText, setStreamingText] = useState("");
+  const [currentTool, setCurrentTool] = useState(null);
+  const [sessionId, setSessionId] = useState(engine.workspace.sessionId);
+  const [phase, setPhase] = useState(engine.currentPhase);
+  const [showWelcome, setShowWelcome] = useState(true);
+
+  const engineRef = useRef(engine);
+  const streamingRef = useRef(false);
+  const queueRef = useRef([]);
+
+  const addMessage = useCallback((msg) => {
+    setMessages((prev) => [...prev, msg]);
+  }, []);
+
+  const runTurn = useCallback(async (text) => {
+    streamingRef.current = true;
+    setStreaming(true);
+    setStreamingText("");
+    setCurrentTool(null);
+
+    let accumulated = "";
+
+    try {
+      for await (const event of engineRef.current.runTurn(text)) {
+        switch (event.type) {
+          case "text_delta":
+            accumulated += event.text ?? "";
+            setStreamingText(accumulated);
+            break;
+
+          case "turn_complete":
+            if (accumulated) {
+              addMessage({ role: "agent", content: accumulated });
+            }
+            accumulated = "";
+            setStreamingText("");
+            setCurrentTool(null);
+            break;
+
+          case "tool_start":
+            // Flush any accumulated text before tool
+            if (accumulated) {
+              addMessage({ role: "agent", content: accumulated });
+              accumulated = "";
+              setStreamingText("");
+            }
+            setCurrentTool({ name: event.name, input: event.input, output: null, isError: false, isRunning: true });
+            break;
+
+          case "tool_result":
+            // Add completed tool to messages
+            addMessage({
+              role: "tool",
+              toolName: event.name,
+              toolInput: currentTool?.input ?? event.input,
+              toolOutput: event.output,
+              toolIsError: event.isError,
+            });
+            setCurrentTool(null);
+            break;
+
+          case "pipeline_event": {
+            const nextPhase = event.data?.nextPhase ?? event.data?.next_phase ?? "";
+            if (nextPhase) setPhase(nextPhase);
+            addMessage({ role: "system", content: `[Pipeline] ${event.data?.message ?? ""}` });
+            break;
+          }
+
+          case "error":
+            addMessage({ role: "system", content: `Error: ${event.message ?? "Unknown error"}` });
+            break;
+        }
+      }
+    } catch (err) {
+      addMessage({ role: "system", content: `Error: ${err.message}` });
+    }
+
+    streamingRef.current = false;
+    setStreaming(false);
+
+    // Process queue
+    if (queueRef.current.length > 0) {
+      const next = queueRef.current.shift();
+      runTurn(next);
+    }
+  }, [addMessage]);
+
+  const handleSlashCommand = useCallback((text) => {
+    const parts = text.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const arg = parts.slice(1).join(" ").trim();
+
+    switch (cmd) {
+      case "/help":
+        addMessage({
+          role: "system",
+          content:
+            "Commands:\n" +
+            "  /help                Show this help\n" +
+            "  /status              Show session info, model, phase, workspace\n" +
+            "  /clear               Clear conversation history (keep workspace)\n" +
+            "  /sessions            List all sessions\n" +
+            "  /resume <name>       Resume a previous session\n" +
+            "  /rename <name>       Rename current session\n" +
+            "  /exit                Quit",
+        });
+        return true;
+
+      case "/status":
+        addMessage({
+          role: "system",
+          content:
+            `Session:   ${engineRef.current.workspace.sessionId}\n` +
+            `Phase:     ${engineRef.current.currentPhase.toUpperCase()}\n` +
+            `Model:     ${config.kcModel}\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`,
+        });
+        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." });
+        return true;
+
+      case "/rename":
+        if (!arg) {
+          addMessage({ role: "system", content: "Usage: /rename <new_name>" });
+        } else {
+          try {
+            const newId = engineRef.current.workspace.rename(arg);
+            setSessionId(newId);
+            addMessage({ role: "system", content: `Session renamed to: ${newId}` });
+          } catch (err) {
+            addMessage({ role: "system", content: `Rename failed: ${err.message}` });
+          }
+        }
+        return true;
+
+      case "/sessions": {
+        const sessions = Workspace.listSessions(config.kcWorkspaceRoot);
+        if (sessions.length === 0) {
+          addMessage({ role: "system", content: "No sessions found." });
+        } else {
+          const lines = sessions.map((s) => {
+            const marker = s.id === engineRef.current.workspace.sessionId ? " ← current" : "";
+            return `  ${s.id}${marker}`;
+          });
+          addMessage({ role: "system", content: "Sessions:\n" + lines.join("\n") });
+        }
+        return true;
+      }
+
+      case "/resume":
+        if (!arg) {
+          const sessions = Workspace.listSessions(config.kcWorkspaceRoot);
+          if (sessions.length === 0) {
+            addMessage({ role: "system", content: "No sessions found." });
+          } else {
+            const lines = sessions.map((s) => {
+              const marker = s.id === engineRef.current.workspace.sessionId ? " ← current" : "";
+              return `  ${s.id}${marker}`;
+            });
+            addMessage({ role: "system", content: "Sessions:\n" + lines.join("\n") + "\n\nUsage: /resume <name>" });
+          }
+        } else {
+          addMessage({ role: "system", content: `Resuming session: ${arg} (not yet implemented)` });
+        }
+        return true;
+
+      case "/exit":
+      case "/quit":
+        exit();
+        return true;
+
+      default:
+        return false;
+    }
+  }, [addMessage, config, exit]);
+
+  const handleSubmit = useCallback((text) => {
+    const trimmed = text.trim();
+    setInputValue("");
+    if (!trimmed) return;
+
+    addMessage({ role: "user", content: trimmed });
+
+    if (trimmed.startsWith("/")) {
+      const handled = handleSlashCommand(trimmed);
+      if (handled) return;
+    }
+
+    if (streamingRef.current) {
+      queueRef.current.push(trimmed);
+    } else {
+      runTurn(trimmed);
+    }
+  }, [addMessage, handleSlashCommand, runTurn]);
+
+  // Handle Ctrl+C and Ctrl+D
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (streamingRef.current) {
+        queueRef.current.length = 0;
+        addMessage({ role: "system", content: "[Queue cleared]" });
+      } else {
+        exit();
+      }
+    }
+    if (key.ctrl && input === "d") {
+      exit();
+    }
+  });
+
+  return h(Box, { flexDirection: "column" },
+    // Welcome banner
+    showWelcome ? h(WelcomeBanner) : null,
+
+    // Message history
+    ...messages.map((msg, i) => {
+      if (msg.role === "user") {
+        return h(Box, { key: `msg-${i}` },
+          h(Text, { dimColor: true }, "❯ "),
+          h(Text, null, msg.content),
+        );
+      }
+      if (msg.role === "agent") {
+        return h(Box, { key: `msg-${i}` },
+          h(Text, null, msg.content),
+        );
+      }
+      if (msg.role === "tool") {
+        return h(ToolBlock, {
+          key: `msg-${i}`,
+          name: msg.toolName,
+          input: msg.toolInput,
+          output: msg.toolOutput,
+          isError: msg.toolIsError,
+          isRunning: false,
+        });
+      }
+      if (msg.role === "system") {
+        return h(Box, { key: `msg-${i}` },
+          h(Text, { dimColor: true }, msg.content),
+        );
+      }
+      return null;
+    }),
+
+    // Currently streaming text
+    streamingText ? h(Box, { key: "streaming" },
+      h(Text, null, streamingText),
+    ) : null,
+
+    // Currently running tool
+    currentTool ? h(ToolBlock, {
+      key: "current-tool",
+      name: currentTool.name,
+      input: currentTool.input,
+      output: null,
+      isError: false,
+      isRunning: true,
+    }) : null,
+
+    // Spinner while waiting
+    streaming && !streamingText && !currentTool
+      ? h(CookingSpinner)
+      : null,
+
+    // Separator + Input
+    h(HRule),
+    h(InputPrompt, {
+      value: inputValue,
+      onChange: setInputValue,
+      onSubmit: handleSubmit,
+      isActive: !streaming,
+    }),
+    h(HRule),
+    h(StatusBar, { sessionId, phase }),
+  );
+}
+
+export async function main() {
+  const config = loadSettings();
+
+  if (!config.llmApiKey) {
+    console.error("Error: No API key configured. Run 'kc-beta onboard' first.");
+    process.exit(1);
+  }
+
+  const client = new LLMClient({
+    apiKey: config.llmApiKey,
+    baseUrl: config.llmBaseUrl,
+  });
+
+  const engine = new AgentEngine({ client, config });
+
+  const instance = render(h(App, { engine, config }));
+  await instance.waitUntilExit();
+}

package/src/cli/init.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_DIR = path.resolve(__dirname, "../../template");
+
+/**
+ * kc-beta init [project-name] [--lang=zh]
+ * Creates a new workspace from the bundled template.
+ */
+export async function init() {
+  const args = process.argv.slice(3);
+  let projectName = "kc-project";
+  let lang = "en";
+
+  for (const arg of args) {
+    if (arg.startsWith("--lang=")) {
+      lang = arg.split("=")[1] || "en";
+    } else if (!arg.startsWith("-")) {
+      projectName = arg;
+    }
+  }
+
+  const targetDir = path.resolve(process.cwd(), projectName);
+
+  if (fs.existsSync(targetDir)) {
+    console.error(`Error: Directory '${projectName}' already exists.`);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(TEMPLATE_DIR)) {
+    console.error("Error: Template directory not found. Ensure kc-beta is installed correctly.");
+    process.exit(1);
+  }
+
+  // Copy template
+  copyDir(TEMPLATE_DIR, targetDir);
+
+  // Remove opposite language skills
+  const skillsDir = path.join(targetDir, "skills");
+  if (fs.existsSync(skillsDir)) {
+    const removeLang = lang === "zh" ? "en" : "zh";
+    const removePath = path.join(skillsDir, removeLang);
+    if (fs.existsSync(removePath)) {
+      fs.rmSync(removePath, { recursive: true, force: true });
+    }
+  }
+
+  // Rename .env.template to .env
+  const envTemplate = path.join(targetDir, ".env.template");
+  const envTarget = path.join(targetDir, ".env");
+  if (fs.existsSync(envTemplate)) {
+    fs.renameSync(envTemplate, envTarget);
+    // Set language
+    let content = fs.readFileSync(envTarget, "utf-8");
+    content = content.replace("LANGUAGE=en", `LANGUAGE=${lang}`);
+    fs.writeFileSync(envTarget, content, "utf-8");
+  }
+
+  console.log(`\n  Created ${projectName}/`);
+  console.log(`  Language: ${lang === "zh" ? "中文" : "English"}`);
+  console.log(`\n  Next steps:`);
+  console.log(`    cd ${projectName}`);
+  console.log(`    kc-beta onboard    # configure API keys`);
+  console.log(`    kc-beta            # start the agent\n`);
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}

package/src/cli/onboard.js

@@ -0,0 +1,182 @@
+import fs from "node:fs";
+import path from "node:path";
+import readline from "node:readline";
+import os from "node:os";
+
+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 Setup",
+    existingConfig: "Existing config found. Press Enter to keep current values.",
+    langPrompt: "Language",
+    langOptions: ["English", "中文"],
+    providerPrompt: "LLM Provider",
+    providerLabels: [
+      "SiliconFlow (recommended for China)",
+      "Aliyun Bailian",
+      "Anthropic",
+      "OpenAI",
+      "Custom (enter base URL)",
+    ],
+    current: "current",
+    choose: "Choose",
+    baseUrl: "Base URL",
+    baseUrlRequired: "Base URL is required for custom provider.",
+    apiKey: "API Key",
+    apiKeyRequired: "required",
+    apiKeyKeep: "Enter to keep",
+    apiKeyMissing: "API key is required. Run 'kc-beta onboard' again.",
+    conductorModel: "Conductor Model",
+    workerTiers: "Worker LLM Tiers",
+    tierHint: "Enter to accept defaults",
+    accuracy: "Accuracy Threshold",
+    saved: "Saved to",
+    runHint: "Run {cmd} to start the agent.",
+  },
+  zh: {
+    title: "KC Agent 配置向导",
+    existingConfig: "检测到已有配置。按回车保留当前值。",
+    langPrompt: "语言",
+    langOptions: ["English", "中文"],
+    providerPrompt: "大模型服务商",
+    providerLabels: [
+      "SiliconFlow（国内推荐）",
+      "阿里云百炼",
+      "Anthropic",
+      "OpenAI",
+      "自定义（输入接口地址）",
+    ],
+    current: "当前",
+    choose: "选择",
+    baseUrl: "接口地址",
+    baseUrlRequired: "自定义服务商必须填写接口地址。",
+    apiKey: "API 密钥",
+    apiKeyRequired: "必填",
+    apiKeyKeep: "回车保留当前密钥",
+    apiKeyMissing: "API 密钥为必填项。请重新运行 'kc-beta onboard'。",
+    conductorModel: "主模型",
+    workerTiers: "Worker 模型分层",
+    tierHint: "回车接受默认值",
+    accuracy: "准确率阈值",
+    saved: "已保存至",
+    runHint: "运行 {cmd} 启动 Agent。",
+  },
+};
+
+const PROVIDERS = [
+  { name: "SiliconFlow", base_url: "https://api.siliconflow.cn/v1", model: "Pro/zai-org/GLM-5",
+    tiers: { tier1: "Pro/zai-org/GLM-5, Pro/moonshotai/Kimi-K2.5", tier2: "Pro/deepseek-ai/DeepSeek-V3.2, Pro/MiniMaxAI/MiniMax-M2.5", tier3: "Qwen/Qwen3.5-122B-A10B", tier4: "Qwen/Qwen3.5-35B-A3B" } },
+  { name: "Aliyun", base_url: "https://coding.dashscope.aliyuncs.com/v1", model: "glm-5",
+    tiers: { tier1: "glm-5", tier2: "deepseek-v3", tier3: "qwen-plus", tier4: "qwen-turbo" } },
+  { name: "Anthropic", base_url: "https://api.anthropic.com/v1", model: "claude-sonnet-4-20250514",
+    tiers: { tier1: "claude-sonnet-4-20250514", tier2: "claude-sonnet-4-20250514", tier3: "claude-haiku-4-5-20251001", tier4: "claude-haiku-4-5-20251001" } },
+  { name: "OpenAI", base_url: "https://api.openai.com/v1", model: "gpt-4o",
+    tiers: { tier1: "gpt-4o", tier2: "gpt-4o-mini", tier3: "gpt-4o-mini", tier4: "gpt-4o-mini" } },
+  { name: "Custom", base_url: "", model: "", tiers: { tier1: "", tier2: "", tier3: "", tier4: "" } },
+];
+
+function ask(rl, question, defaultValue = "") {
+  const suffix = defaultValue ? ` ${DIM}[${defaultValue}]${RESET}` : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => resolve(answer.trim() || defaultValue));
+  });
+}
+
+export async function onboard() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+
+  let existing = {};
+  if (fs.existsSync(CONFIG_PATH)) {
+    try { existing = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8")); } catch { /* ignore */ }
+  }
+
+  console.log();
+  console.log(`  ${BOLD}KC Agent Setup / KC Agent 配置向导${RESET}`);
+  console.log(`  ${GRAY}${"─".repeat(40)}${RESET}`);
+  console.log();
+  console.log(`  ${CYAN}Language / 语言:${RESET}`);
+  console.log(`    1. English`);
+  console.log(`    2. 中文`);
+  const langDefault = existing.language === "zh" ? "2" : "1";
+  const langChoice = await ask(rl, `  ${GRAY}>${RESET} Choose / 选择`, langDefault);
+  const lang = langChoice === "2" ? "zh" : "en";
+  const t = L[lang];
+  console.log();
+
+  if (Object.keys(existing).length > 0) {
+    console.log(`  ${DIM}${t.existingConfig}${RESET}`);
+    console.log();
+  }
+
+  console.log(`  ${CYAN}${t.providerPrompt}:${RESET}`);
+  for (let i = 0; i < PROVIDERS.length; i++) {
+    const marker = PROVIDERS[i].name.toLowerCase() === existing.provider ? ` ${GREEN}(${t.current})${RESET}` : "";
+    console.log(`    ${i + 1}. ${t.providerLabels[i]}${marker}`);
+  }
+  const providerIdx = parseInt(await ask(rl, `  ${GRAY}>${RESET} ${t.choose}`, "1"), 10) - 1;
+  const provider = PROVIDERS[Math.max(0, Math.min(providerIdx, PROVIDERS.length - 1))];
+  console.log();
+
+  let baseUrl = provider.base_url;
+  if (provider.name === "Custom") {
+    baseUrl = await ask(rl, `  ${t.baseUrl}`, existing.base_url || "");
+    if (!baseUrl) { console.log(`  ${RED}${t.baseUrlRequired}${RESET}`); rl.close(); process.exit(1); }
+  }
+
+  const maskedExisting = existing.api_key ? existing.api_key.slice(0, 6) + "..." + existing.api_key.slice(-4) : "";
+  const keyPrompt = maskedExisting
+    ? `  ${CYAN}${t.apiKey}${RESET} ${DIM}(${maskedExisting}, ${t.apiKeyKeep})${RESET}`
+    : `  ${CYAN}${t.apiKey}${RESET} ${YELLOW}(${t.apiKeyRequired})${RESET}`;
+  const apiKey = await ask(rl, keyPrompt, "");
+  const finalKey = apiKey || existing.api_key || "";
+  if (!finalKey) { console.log(`  ${RED}${t.apiKeyMissing}${RESET}`); rl.close(); process.exit(1); }
+  console.log();
+
+  const defaultModel = provider.model || existing.conductor_model || "";
+  const model = await ask(rl, `  ${CYAN}${t.conductorModel}${RESET}`, defaultModel);
+  console.log();
+
+  console.log(`  ${CYAN}${t.workerTiers}${RESET} ${DIM}(${t.tierHint})${RESET}`);
+  const tiers = {};
+  for (const tier of ["tier1", "tier2", "tier3", "tier4"]) {
+    const def = provider.tiers[tier] || existing?.tiers?.[tier] || "";
+    tiers[tier] = await ask(rl, `    ${tier.toUpperCase()}`, def);
+  }
+  console.log();
+
+  const defaultAcc = existing.accuracy_threshold?.toString() || "0.9";
+  const accuracy = parseFloat(await ask(rl, `  ${CYAN}${t.accuracy}${RESET}`, defaultAcc));
+  console.log();
+
+  rl.close();
+
+  const config = {
+    language: lang,
+    provider: provider.name.toLowerCase(),
+    api_key: finalKey,
+    base_url: baseUrl,
+    conductor_model: model,
+    tiers,
+    accuracy_threshold: accuracy,
+  };
+
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+
+  console.log(`  ${GREEN}✓${RESET} ${t.saved} ${GRAY}${CONFIG_PATH}${RESET}`);
+  console.log();
+  console.log(`  ${t.runHint.replace("{cmd}", `${BOLD}kc-beta${RESET}`)}`);
+  console.log();
+}