skyloom 1.8.0 → 1.10.0

package/src/cli/main.ts

@@ -77,6 +77,12 @@ program.command("web").option("-p,--port <p>", "port", "3000")
 program.command("mcp").action(() => { import("../core/mcp_server").then(m => m.startMCPServer()); });
 program.command("config").action(() => { const c = loadConfig(); process.stdout.write(chalk.cyan("\nConfig: ") + USER_CONFIG_DIR + "\n"); for (const [n, a] of Object.entries(c.agents || {})) process.stdout.write(`  ${chalk.bold(n)}: ${(a as any).model || "default"}\n`); });
 program.command("init").action(() => { if (!fs.existsSync(USER_CONFIG_DIR)) fs.mkdirSync(USER_CONFIG_DIR, { recursive: true }); process.stdout.write(chalk.green("✓ ") + USER_CONFIG_DIR + "\n"); });
+program.command("apikey").description("Manage API keys (persisted to ~/.skyloom/config.yaml)")
+  .argument("[action]", "set|list").argument("[provider]", "e.g. deepseek").argument("[key]", "API key")
+  .action((action?: string, provider?: string, key?: string) => {
+    if (action === "set" && provider && key) { saveApiKey(provider, key); process.stdout.write(chalk.green("✓ Saved " + provider + " API key\n")); }
+    else { process.stdout.write(chalk.dim("Usage: sky apikey set deepseek YOUR_KEY\n")); }
+  });
 program.command("version").action(() => { process.stdout.write(`Skyloom v${VERSION}\n`); });
 
 /* ═══════════════════════════════════════
@@ -143,20 +149,45 @@ function render(text: string): string[] {
 /* ═══════════════════════════════════════
    Chat loop
    ═══════════════════════════════════════ */
-/* Check for API key availability */
+/* API key persistence — read from config file too */
 function checkApiKeys(): string | null {
-  const keys = ["DEEPSEEK_API_KEY","OPENAI_API_KEY","ANTHROPIC_API_KEY","GROQ_API_KEY","OPENROUTER_API_KEY"];
-  for (const k of keys) { if (process.env[k]) return k; }
+  // Check env vars
+  const envKeys = ["DEEPSEEK_API_KEY","OPENAI_API_KEY","ANTHROPIC_API_KEY","GROQ_API_KEY","OPENROUTER_API_KEY"];
+  for (const k of envKeys) { if (process.env[k]) return "env:" + k; }
+  // Check config file
+  try {
+    const path = require("path"); const fs = require("fs"); const yaml = require("yaml");
+    const cfgPath = path.join(require("os").homedir(), ".skyloom", "config.yaml");
+    if (fs.existsSync(cfgPath)) {
+      const cfg = yaml.parse(fs.readFileSync(cfgPath, "utf-8")) || {};
+      const keys = cfg.api_keys || {};
+      for (const [p, k] of Object.entries(keys)) { if (k) return "cfg:" + p; }
+    }
+  } catch { /* ignore */ }
   return null;
 }
 
+/** Save API key to config file */
+function saveApiKey(provider: string, key: string): void {
+  const path = require("path"); const fs = require("fs"); const yaml = require("yaml");
+  const cfgPath = path.join(require("os").homedir(), ".skyloom", "config.yaml");
+  const dir = path.dirname(cfgPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  let cfg: any = {};
+  if (fs.existsSync(cfgPath)) { try { cfg = yaml.parse(fs.readFileSync(cfgPath, "utf-8")) || {}; } catch { } }
+  if (!cfg.api_keys) cfg.api_keys = {};
+  cfg.api_keys[provider] = key;
+  fs.writeFileSync(cfgPath, yaml.stringify(cfg), "utf-8");
+}
+
 async function chat(agentName: string, modelOverride?: string): Promise<void> {
   const haveKey = checkApiKeys();
   if (!haveKey) {
     process.stdout.write("\n" + chalk.yellow("  ⚠ No API key configured.\n"));
-    process.stdout.write(chalk.dim("  Set one:  $env:DEEPSEEK_API_KEY = \"sk-your-key\"  (PowerShell)\n"));
-    process.stdout.write(chalk.dim("            export DEEPSEEK_API_KEY=sk-your-key    (Bash)\n\n"));
-    process.stdout.write(chalk.dim("  Then run: sky\n\n"));
+    process.stdout.write(chalk.dim("  Quick setup:\n"));
+    process.stdout.write(chalk.dim("    sky apikey set deepseek sk-your-key-here\n"));
+    process.stdout.write(chalk.dim("  Or env var:\n"));
+    process.stdout.write(chalk.dim("    $env:DEEPSEEK_API_KEY = \"sk-your-key\"\n\n"));
     process.exit(1);
   }
 
@@ -164,6 +195,22 @@ async function chat(agentName: string, modelOverride?: string): Promise<void> {
   let agent = ctx.agentMap.get(agentName);
   if (!agent) { process.stdout.write(chalk.red("Unknown agent: " + agentName) + "\n"); return; }
   await agent.init();
+
+  // Wire up security approval — prompt user for HIGH/CRITICAL operations
+  try {
+    const { getSecurity, DangerLevel } = require("../core/security");
+    const sec = getSecurity();
+    sec.setApprovalCallback(async (tool: string, args: Record<string, any>, level: number) => {
+      process.stdout.write(chalk.yellow(`\n  ⚠ ${tool} ( danger level ${level} )\n`));
+      process.stdout.write(chalk.dim(`     args: ${JSON.stringify(args).slice(0, 80)}\n`));
+      const answer = await new Promise<string>(resolve => {
+        const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl2.question(chalk.red("     Approve? [y/N] "), (a: string) => { rl2.close(); resolve(a.trim().toLowerCase()); });
+      });
+      return answer === "y" || answer === "yes";
+    });
+  } catch { /* security module optional */ }
+
   // eslint-disable-next-line prefer-const
   let currentAgent = agent; // mutable for agent switching
   welcome(agent);
@@ -192,6 +239,14 @@ async function chat(agentName: string, modelOverride?: string): Promise<void> {
     if (cmdL === "/compact") { const r = await currentAgent.compact(); process.stdout.write(chalk.green("  ✓ " + r + "\n\n")); ask(); return; }
     if (cmdL === "/version") { process.stdout.write("  Skyloom v" + VERSION + "\n"); ask(); return; }
     if (cmdL.startsWith("/task ")) { const g = inp.slice(6); process.stdout.write(chalk.cyan("\n  ✦ " + g + "\n\n")); await runTask(g); ask(); return; }
+    if (cmdL.startsWith("/apikey set ")) { const parts = inp.split(/\s+/); if (parts.length >= 4) { saveApiKey(parts[2], parts[3]); process.stdout.write(chalk.green("  ✓ Saved " + parts[2] + " API key to ~/.skyloom/config.yaml\n\n")); } else { process.stdout.write(chalk.yellow("  Usage: /apikey set <provider> <key>\n\n")); } ask(); return; }
+    if (cmdL === "/apikey") {
+      const providers = ["openai","deepseek","anthropic","groq","openrouter"];
+      process.stdout.write(chalk.bold("\n  API Keys:\n"));
+      for (const p of providers) { const envVar = p.toUpperCase() + "_API_KEY"; const hasEnv = !!process.env[envVar]; process.stdout.write(chalk.dim("  " + p.padEnd(14) + (hasEnv ? chalk.green("env") : chalk.dim("—")) + "\n")); }
+      process.stdout.write(chalk.dim("\n  Save: /apikey set <provider> <key>\n\n"));
+      ask(); return;
+    }
     if (inp.startsWith("/")) { process.stdout.write(helpText()); ask(); return; }
 
     // ── Chat ──

package/src/core/graph.ts

@@ -0,0 +1,156 @@
+/**
+ * 简易知识图谱 — entity-relation storage in SQLite.
+ *
+ * Lightweight triple store: (subject, predicate, object) with metadata.
+ * Used for: project info, tool preferences, dependency relationships.
+ *
+ * Schema:
+ *   CREATE TABLE triples (subj, pred, obj, agent, ts, meta)
+ *
+ * Queries:
+ *   - Find all relations for an entity
+ *   - Find all entities matching a predicate
+ *   - Transitive closure (2-hop max for performance)
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { USER_CONFIG_DIR } from "./config";
+import { getLogger } from "./logger";
+
+const log = getLogger("graph");
+
+/* ═══════════════════════════════════════
+   Triple store — in-memory + optional persistence
+   ═══════════════════════════════════════ */
+interface Triple {
+  subj: string;
+  pred: string;
+  obj: string;
+  agent: string;
+  ts: string;
+  meta?: Record<string, string>;
+}
+
+export class KnowledgeGraph {
+  private triples: Triple[] = [];
+  private indexPath: string;
+
+  constructor(name: string = "default") {
+    this.indexPath = path.join(USER_CONFIG_DIR, `kg_${name}.json`);
+    this.load();
+  }
+
+  /** Add a fact: (subject, predicate, object). */
+  add(subj: string, pred: string, obj: string, agent: string = "system", meta?: Record<string, string>): void {
+    // Deduplicate
+    const exists = this.triples.find(t => t.subj === subj && t.pred === pred && t.obj === obj);
+    if (exists) { exists.ts = new Date().toISOString(); if (meta) exists.meta = { ...exists.meta, ...meta }; return; }
+
+    this.triples.push({ subj, pred, obj, agent, ts: new Date().toISOString(), meta });
+    if (this.triples.length > 5000) this.triples.splice(0, this.triples.length - 5000);
+    this.save();
+  }
+
+  /** Find all facts about an entity. */
+  about(entity: string, limit: number = 20): Triple[] {
+    return this.triples.filter(t => t.subj === entity || t.obj === entity).slice(-limit);
+  }
+
+  /** Find all subjects matching a predicate. */
+  byPredicate(pred: string): Triple[] {
+    return this.triples.filter(t => t.pred === pred);
+  }
+
+  /** Find all objects for a subject-predicate pair. */
+  find(subj: string, pred: string): Triple[] {
+    return this.triples.filter(t => t.subj === subj && t.pred === pred);
+  }
+
+  /** Transitive expansion: 2-hop from a starting entity. */
+  expand(entity: string, maxDepth: number = 2): Triple[] {
+    const seen = new Set<Triple>();
+    const queue = [entity];
+    for (let depth = 0; depth < maxDepth && queue.length > 0; depth++) {
+      const current = queue.shift()!;
+      const facts = this.about(current, 10);
+      for (const f of facts) {
+        if (seen.has(f)) continue;
+        seen.add(f);
+        if (f.subj === current && !queue.includes(f.obj)) queue.push(f.obj);
+        if (f.obj === current && !queue.includes(f.subj)) queue.push(f.subj);
+      }
+    }
+    return Array.from(seen);
+  }
+
+  /** Remove a fact. */
+  remove(subj: string, pred: string, obj: string): void {
+    this.triples = this.triples.filter(t => !(t.subj === subj && t.pred === pred && t.obj === obj));
+    this.save();
+  }
+
+  /** Search for entities or predicates containing a keyword. */
+  search(keyword: string, limit: number = 15): Triple[] {
+    const k = keyword.toLowerCase();
+    return this.triples.filter(t => t.subj.toLowerCase().includes(k) || t.pred.toLowerCase().includes(k) || t.obj.toLowerCase().includes(k)).slice(-limit);
+  }
+
+  /** Format facts as readable text. */
+  format(entity?: string): string {
+    const facts = entity ? this.about(entity) : this.triples.slice(-30);
+    if (facts.length === 0) return "(no facts)";
+    const bySubj = new Map<string, string[]>();
+    for (const f of facts) {
+      if (!bySubj.has(f.subj)) bySubj.set(f.subj, []);
+      bySubj.get(f.subj)!.push(`${f.pred} → ${f.obj}`);
+    }
+    const lines: string[] = [];
+    for (const [subj, preds] of bySubj) {
+      lines.push(`**${subj}**: ${preds.join(", ")}`);
+    }
+    return lines.join("\n");
+  }
+
+  get size(): number { return this.triples.length; }
+
+  private save(): void {
+    try {
+      const dir = path.dirname(this.indexPath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this.indexPath, JSON.stringify(this.triples.slice(-2000)), "utf-8");
+    } catch (e) { log.warn("kg_save_failed", { error: String(e) }); }
+  }
+
+  private load(): void {
+    try {
+      if (fs.existsSync(this.indexPath)) {
+        this.triples = JSON.parse(fs.readFileSync(this.indexPath, "utf-8"));
+      }
+    } catch { this.triples = []; }
+  }
+}
+
+/* ── Auto-extract facts from conversation ── */
+const RELATION_PATTERNS: Array<[RegExp, string]> = [
+  [/(\w+) (?:是|为|属于|使用|用|用到了|采用) (.+?)(?:[。，,.\n]|$)/g, "is"],
+  [/(\w+) (?:版本|version|v) (?:是|为)? ?(\d[\d.]*)/gi, "version"],
+  [/(\w+) (?:depends|依赖|需要|requires) (\w+)/gi, "depends_on"],
+  [/(\w+) (?:config|配置) (?:为|是)? (.+?)(?:[。，,.\n]|$)/gi, "config"],
+  [/(\w+) (?:file|path|文件|路径) (?:在|为|at) (.+?)(?:[。，,.\n]|$)/gi, "located_at"],
+];
+
+export function extractFacts(text: string, agent: string): Array<[string, string, string]> {
+  const facts: Array<[string, string, string]> = [];
+  for (const [pattern, pred] of RELATION_PATTERNS) {
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      const subj = match[1].trim().toLowerCase();
+      const obj = match[2].trim();
+      if (subj.length >= 2 && obj.length >= 2 && subj !== obj) {
+        facts.push([subj, pred, obj]);
+      }
+    }
+  }
+  return facts;
+}

package/src/core/llm.ts

@@ -756,9 +756,23 @@ export class LLMClient {
     else { const l = model.toLowerCase(); if (l.includes("claude")) provider = "anthropic"; else if (l.includes("deepseek")) provider = "deepseek"; else if (l.includes("groq")) provider = "groq"; else if (l.includes("openrouter")) provider = "openrouter"; else if (l.includes("gemini")) provider = "gemini"; }
     const envMap = getProviderEnvMap();
     const envVar = envMap.get(provider) || (provider.toUpperCase() + "_API_KEY");
-    const key = process.env[envVar];
-    if (!key) throw new Error("Missing " + envVar + ". Set environment variable or configure in ~/.skyloom/config.yaml");
-    return key;
+
+    // 1. Check environment variable first
+    let key = process.env[envVar];
+    if (key) return key;
+
+    // 2. Check config file (~/.skyloom/config.yaml)
+    try {
+      const fs = require("fs"); const path = require("path"); const yaml = require("yaml");
+      const cfgPath = path.join(require("os").homedir(), ".skyloom", "config.yaml");
+      if (fs.existsSync(cfgPath)) {
+        const cfg = yaml.parse(fs.readFileSync(cfgPath, "utf-8")) || {};
+        const keys = cfg.api_keys || {};
+        if (keys[provider]) return keys[provider];
+      }
+    } catch { /* ignore */ }
+
+    throw new Error("Missing " + envVar + ". Run: sky apikey set " + provider + " YOUR_KEY");
   }
 
   private getBaseUrl(model: string): string {

package/src/core/vector.ts

@@ -0,0 +1,152 @@
+/**
+ * 向量语义搜索 — TF-IDF + Cosine similarity, zero dependencies.
+ *
+ * Replaces n-gram Jaccard as the default semantic scorer.
+ * - IDF pre-computed from document corpus
+ * - Cosine similarity on TF-IDF vectors
+ * - CJK-aware tokenization (bigram for CJK, whitespace for ASCII)
+ *
+ * Usage:
+ *   const idx = new VectorIndex();
+ *   idx.addDocuments(docs);
+ *   const results = idx.search("deploy script", 5);
+ */
+
+/* ═══════════════════════════════════════
+   Tokenizer — CJK-aware
+   ═══════════════════════════════════════ */
+const CJK = /[一-鿿぀-ゟ가-힯]/;
+
+function tokenize(text: string): string[] {
+  const tokens: string[] = [];
+  let i = 0;
+  while (i < text.length) {
+    if (CJK.test(text[i])) {
+      if (i + 1 < text.length && CJK.test(text[i + 1])) {
+        tokens.push(text.slice(i, i + 2)); i += 2;
+      } else {
+        tokens.push(text[i]); i++;
+      }
+    } else if (/[A-Za-z0-9_]/.test(text[i])) {
+      let j = i;
+      while (j < text.length && /[A-Za-z0-9_]/.test(text[j])) j++;
+      tokens.push(text.slice(i, j).toLowerCase()); i = j;
+    } else {
+      i++;
+    }
+  }
+  return tokens;
+}
+
+/* ═══════════════════════════════════════
+   TF-IDF Vector computation
+   ═══════════════════════════════════════ */
+interface DocVector {
+  id: string;
+  tf: Map<string, number>;
+  norm: number;
+  content: string;
+  meta?: Record<string, any>;
+}
+
+export class VectorIndex {
+  private docs: DocVector[] = [];
+  private idf: Map<string, number> = new Map();
+  private totalDocs = 0;
+
+  /** Add a document to the index. */
+  addDocument(id: string, content: string, meta?: Record<string, any>): void {
+    const tokens = tokenize(content);
+    const tf = new Map<string, number>();
+    for (const t of tokens) { tf.set(t, (tf.get(t) || 0) + 1); }
+
+    // Normalize by doc length
+    const tfIdf = new Map<string, number>();
+    let normSq = 0;
+    for (const [term, freq] of tf) {
+      const tfVal = freq / tokens.length;
+      const idfVal = this.idf.get(term) || 0;
+      const val = tfVal * Math.max(0.1, idfVal);
+      tfIdf.set(term, val);
+      normSq += val * val;
+    }
+
+    const norm = Math.sqrt(normSq);
+    this.docs.push({ id, tf: tfIdf, norm, content: content.slice(0, 500), meta });
+    this.totalDocs++;
+
+    // Update IDF
+    for (const term of tf.keys()) {
+      this.idf.set(term, Math.log((this.totalDocs + 1) / ((this.docFrequency(term) + 1))));
+    }
+  }
+
+  addDocuments(docs: Array<{ id: string; content: string; meta?: Record<string, any> }>): void {
+    for (const d of docs) this.addDocument(d.id, d.content, d.meta);
+  }
+
+  private docFrequency(term: string): number {
+    let count = 0;
+    for (const d of this.docs) { if (d.tf.has(term)) count++; }
+    return count;
+  }
+
+  /** Search for documents similar to query. Returns [score, doc] pairs. */
+  search(query: string, topK: number = 5, minScore: number = 0.01): Array<[number, DocVector]> {
+    const queryTokens = tokenize(query);
+    const queryTf = new Map<string, number>();
+    for (const t of queryTokens) { queryTf.set(t, (queryTf.get(t) || 0) + 1); }
+
+    // Query vector
+    const qv = new Map<string, number>();
+    let qNormSq = 0;
+    for (const [term, freq] of queryTf) {
+      const tfVal = freq / queryTokens.length;
+      const idfVal = this.idf.get(term) || 0;
+      const val = tfVal * Math.max(0.1, idfVal);
+      qv.set(term, val);
+      qNormSq += val * val;
+    }
+    const qNorm = Math.sqrt(qNormSq);
+    if (qNorm === 0) return [];
+
+    // Cosine similarity against all docs
+    const scored: Array<[number, DocVector]> = [];
+    for (const doc of this.docs) {
+      if (doc.norm === 0) continue;
+      let dot = 0;
+      for (const [term, qVal] of qv) {
+        dot += qVal * (doc.tf.get(term) || 0);
+      }
+      const score = dot / (qNorm * doc.norm);
+      if (score >= minScore) scored.push([score, doc]);
+    }
+
+    scored.sort((a, b) => b[0] - a[0]);
+    return scored.slice(0, topK);
+  }
+
+  /** Remove a document by ID. */
+  removeDocument(id: string): void {
+    this.docs = this.docs.filter(d => d.id !== id);
+    this.totalDocs = this.docs.length;
+  }
+
+  get size(): number { return this.docs.length; }
+
+  clear(): void { this.docs = []; this.idf.clear(); this.totalDocs = 0; }
+}
+
+/* ═══════════════════════════════════════
+   Singleton instance for memory recall
+   ═══════════════════════════════════════ */
+let globalIndex: VectorIndex | null = null;
+
+export function getVectorIndex(): VectorIndex {
+  if (!globalIndex) globalIndex = new VectorIndex();
+  return globalIndex;
+}
+
+export function resetVectorIndex(): void {
+  globalIndex = new VectorIndex();
+}