skyloom 1.24.0 → 1.25.0

package/eslint.config.js

@@ -0,0 +1,62 @@
+// ESLint 9 flat config. Replaces the missing config that made `npm run lint` a
+// silent no-op. Scope: src/ TypeScript. We run WITHOUT type-aware linting (no
+// parserOptions.project) so it's fast and doesn't need a second TS program;
+// the strict tsconfig already does the type checking.
+//
+// Philosophy: errors catch real bugs (unused vars, unsafe patterns); the large
+// existing `any` surface and a few stylistic rules are warnings so the gate is
+// honest without forcing a mass rewrite to go green. Tighten over time.
+
+const tsParser = require('@typescript-eslint/parser');
+const tsPlugin = require('@typescript-eslint/eslint-plugin');
+
+module.exports = [
+  {
+    ignores: ['dist/**', 'node_modules/**', 'coverage/**', '**/*.d.ts'],
+  },
+  {
+    files: ['src/**/*.ts'],
+    languageOptions: {
+      parser: tsParser,
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+      globals: {
+        process: 'readonly', console: 'readonly', Buffer: 'readonly',
+        __dirname: 'readonly', __filename: 'readonly', module: 'writable',
+        require: 'readonly', exports: 'writable', global: 'readonly',
+        setTimeout: 'readonly', clearTimeout: 'readonly',
+        setInterval: 'readonly', clearInterval: 'readonly',
+        URL: 'readonly', URLSearchParams: 'readonly', fetch: 'readonly',
+        AbortController: 'readonly', AbortSignal: 'readonly',
+        FormData: 'readonly', Blob: 'readonly', TextEncoder: 'readonly', TextDecoder: 'readonly',
+        performance: 'readonly', NodeJS: 'readonly', BufferEncoding: 'readonly',
+      },
+    },
+    plugins: { '@typescript-eslint': tsPlugin },
+    rules: {
+      // ── Real-bug errors ──
+      'no-unused-vars': 'off', // superseded by the TS-aware version below
+      '@typescript-eslint/no-unused-vars': ['error', {
+        argsIgnorePattern: '^_', varsIgnorePattern: '^_', caughtErrors: 'none',
+        ignoreRestSiblings: true,
+      }],
+      'no-undef': 'error',
+      'no-dupe-keys': 'error',
+      'no-unreachable': 'error',
+      'no-constant-condition': ['error', { checkLoops: false }],
+      'no-fallthrough': 'error',
+      'no-self-assign': 'error',
+      'no-unsafe-negation': 'error',
+      'use-isnan': 'error',
+      'valid-typeof': 'error',
+      'no-cond-assign': ['error', 'except-parens'],
+
+      // ── Debt warnings (honest, not blocking) ──
+      '@typescript-eslint/no-explicit-any': 'warn',
+      'no-empty': ['warn', { allowEmptyCatch: true }],
+      'prefer-const': 'warn',
+      'no-var': 'warn',
+    },
+  },
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skyloom",
-  "version": "1.24.0",
+  "version": "1.25.0",
   "description": "天空织机 Skyloom — 6 weather-themed AI agents: Fog, Rain, Frost, Snow, Dew, Fair",
   "preferGlobal": true,
   "type": "commonjs",

package/src/cli/main.ts

@@ -10,9 +10,8 @@ import { createSystemContext, orchestrateTask } from "../core/factory";
 import { loadConfig, USER_CONFIG_DIR } from "../core/config";
 import { listProviders, modelsFor, providerLabel, validateModel } from "../core/catalog";
 import { agentTheme } from "../core/theme";
-import { classify } from "../core/router";
 import { InteractiveMode, ModeController } from "./mode";
-import { readLine, renderPalette, StreamRenderer, stripMarkdown } from "./tui";
+import { readLine, renderPalette, StreamRenderer } from "./tui";
 import { loomChat } from "./loom_chat";
 
 const MODE = new ModeController();
@@ -73,18 +72,6 @@ function welcome(agent: any) {
   process.stdout.write(chalk.dim("  /help for commands  ·  /quit to exit\n\n"));
 }
 
-function statusBar(agent: any, ctx: any): string {
-  try {
-    const cu = agent.contextUsage();
-    const pct = cu.pct || 0;
-    const bar = pct < 50 ? chalk.green : pct < 80 ? chalk.yellow : chalk.red;
-    const filled = Math.round(pct / 10);
-    const ctxBar = `${bar("█".repeat(filled) + "░".repeat(10 - filled))} ${pct}%`;
-    const cost = formatCost(ctx.llm.getTotalCost());
-    return chalk.dim(`${ctxBar}  ·  ${cost}  ·  ${cu.model || "?"}`);
-  } catch { return ""; }
-}
-
 function formatCost(c: number): string {
   if (c >= 1) return chalk.yellow(`$${c.toFixed(2)}`);
   if (c >= 0.01) return chalk.yellow(`$${c.toFixed(4)}`);
@@ -119,11 +106,6 @@ async function streamResponse(agent: any, input: string): Promise<void> {
   const header = () => { if (!headerShown) { out.write("\n  " + chalk.bold.hex(theme.hex)(`${theme.symbol} ${theme.kanji}`) + chalk.hex(theme.hex)(` ${theme.name}`) + "\n\n"); headerShown = true; } };
   const endBlock = () => { if (renderer) { renderer.flush(); renderer = null; out.write("\n"); } };
 
-  // All content passes through this cleaner before display
-  const writeClean = (text: string) => {
-    if (renderer) renderer.write(text);
-  };
-
   // ── Ctrl-C interrupts this turn (keeps partial output); a 2nd Ctrl-C exits. ──
   const controller = new AbortController();
   let interrupted = false;
@@ -374,7 +356,7 @@ async function chat(agentName: string, modelOverride?: string, classic?: boolean
 
   // Wire up security approval — prompt user for HIGH/CRITICAL operations
   try {
-    const { getSecurity, DangerLevel, PERMISSION_MODE_ALIASES } = require("../core/security");
+    const { getSecurity, PERMISSION_MODE_ALIASES } = require("../core/security");
     const sec = getSecurity();
     // Honor a configured permission mode (config.yaml cli.approvalMode), mapped
     // through the same aliases as /perm.
@@ -405,7 +387,6 @@ async function chat(agentName: string, modelOverride?: string, classic?: boolean
     return; // loomChat exits the process itself
   }
 
-  // eslint-disable-next-line prefer-const
   let currentAgent = agent; // mutable for agent switching
   let lastSessions: any[] = []; // index→session map for /resume <n>
   welcome(agent);
@@ -599,7 +580,7 @@ async function chat(agentName: string, modelOverride?: string, classic?: boolean
       continue;
     }
     if (cmdL === "/models" || cmdL.startsWith("/models ")) {
-      const { listProviders, modelsFor, providerLabel, allModels } = require("../core/catalog");
+      const { listProviders, modelsFor, providerLabel } = require("../core/catalog");
       const args = inp.split(/\s+/).slice(1);
       const filter = args[0]?.toLowerCase() || "";
       process.stdout.write(chalk.bold("\n  ✦ 模型目录 · Model Catalog\n"));

package/src/cli/tui.ts

@@ -14,8 +14,6 @@ import chalk from "chalk";
 import { agentTheme, PALETTE } from "../core/theme";
 import { registry } from "../core/commands";
 
-const TUI_VERSION = (() => { try { return require("../../package.json").version; } catch { return ""; } })();
-
 export interface TUIContext {
   agent: any;
   agents: Map<string, any>;

package/src/core/diff.ts

@@ -60,7 +60,6 @@ export function unifiedDiff(oldStr: string, newStr: string, opts: DiffOptions =
   // Context window bounds.
   const ctxStart = Math.max(0, pre - context);
   const oldCtxAfterStart = oldLines.length - suf;
-  const newCtxAfterStart = newLines.length - suf;
   const oldCtxAfter = oldLines.slice(oldCtxAfterStart, oldCtxAfterStart + context);
   const leading = oldLines.slice(ctxStart, pre);
 

package/src/core/evolve.ts

@@ -121,12 +121,6 @@ export function analyzeFailures(
     }
   }
 
-  // General rule: if failure rate > 20%, suggest self-review
-  const recentExperiences = recent.filter(e => {
-    try { return new Date(e.lastSeen).getTime() > Date.now() - 3 * 86400000; }
-    catch { return false; }
-  });
-
   // Deduplicate suggestions
   const seen = new Set<string>();
   const uniqueDiffs = suggestedDiffs.filter(d => {

package/src/core/graph.ts

@@ -140,7 +140,7 @@ const RELATION_PATTERNS: Array<[RegExp, string]> = [
   [/(\w+) (?:file|path|文件|路径) (?:在|为|at) (.+?)(?:[。，,.\n]|$)/gi, "located_at"],
 ];
 
-export function extractFacts(text: string, agent: string): Array<[string, string, string]> {
+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;

package/src/core/llm.ts

@@ -355,37 +355,6 @@ const FALLBACK_CHAINS: Map<string, string[]> = new Map([
 /**
  * HTTP status codes that are considered transient errors (worth retrying).
  */
-const RETRYABLE_STATUSES = new Set([408, 425, 429, 500, 502, 503, 504]);
-
-/**
- * Check if an exception is worth retrying.
- */
-function isTransientError(err: unknown): boolean {
-  if (err instanceof Error) {
-    const status =
-      (err as any).status_code || (err as any).http_status || 0;
-    if (status && RETRYABLE_STATUSES.has(status)) {
-      return true;
-    }
-
-    if (err.name === "TimeoutError") {
-      return true;
-    }
-
-    const errName = err.constructor.name.toLowerCase();
-    return [
-      "ratelimiterror",
-      "apitimeouterror",
-      "apiconnectionerror",
-      "serviceunavailableerror",
-      "internalservererror",
-      "timeout",
-    ].includes(errName);
-  }
-
-  return false;
-}
-
 /**
  * Estimate cost for LLM API call.
  */
@@ -704,7 +673,7 @@ export class LLMClient {
     messages: Record<string, unknown>[],
     agentName?: string,
     tools?: string[],
-    stream: boolean = false,
+    _stream: boolean = false,
     overrides?: Record<string, unknown>
   ): Promise<LLMResponse> {
     const temperature = (overrides?.temperature as number) ?? 0.7;
@@ -867,7 +836,9 @@ export class LLMClient {
   private async *callOpenAIStream(
     m: string, messages: Record<string, unknown>[], tools?: string[], temp?: number, maxTok?: number, signal?: AbortSignal, agentName?: string
   ): AsyncGenerator<StreamEvent> {
-    const apiKey = this.getApiKey(m);
+    // Honor a per-agent API key override (agents.<name>.api_key) on the
+    // streaming path too — previously only the non-streaming path passed it.
+    const apiKey = this.getApiKey(m, agentName);
     const baseUrl = this.getBaseUrl(m);
     const body: Record<string, unknown> = {
       model: m, messages, temperature: temp ?? 0.7, max_tokens: maxTok ?? 4096,

package/src/core/sandbox.ts

@@ -6,15 +6,12 @@
  * limits, and dangerous command detection BEFORE execution.
  */
 
-import { execSync, exec } from "child_process";
+import { execSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
-import { getLogger } from "./logger";
 import { REDLINE_PATTERNS, REDLINE_COMMANDS } from "./security";
 
-const log = getLogger("sandbox");
-
 /* ═══════════════════════════════════════
    Configuration
    ═══════════════════════════════════════ */

package/src/core/schemas.ts

@@ -78,30 +78,6 @@ export interface MessageSchema {
   tool_call_id?: string;
 }
 
-/**
- * Coerce a value to a target type with best-effort conversion
- */
-function coerceType(value: unknown, targetType: string): unknown {
-  if (value === null || value === undefined) {
-    return value;
-  }
-
-  switch (targetType) {
-    case "string":
-      return String(value);
-    case "number":
-      return Number(value);
-    case "boolean":
-      return Boolean(value);
-    case "array":
-      return Array.isArray(value) ? value : [];
-    case "object":
-      return typeof value === "object" ? value : {};
-    default:
-      return value;
-  }
-}
-
 /**
  * Extract JSON object/array from a potentially malformed string
  */
@@ -170,7 +146,7 @@ function repairJSON(text: string): string {
  */
 export function parseSchema<T extends Record<string, unknown>>(
   raw: string,
-  schemaType?: new () => T
+  _schemaType?: new () => T
 ): T {
   if (!raw || !raw.trim()) {
     throw new SchemaValidationError("empty response", raw);

package/src/core/skill.ts

@@ -245,7 +245,6 @@ function extractSkillHead(body: string, maxChars: number): string {
 // Patterns for auto-deriving triggers
 const TRIGGER_QUOTED = /["'"'""]([^"'""\n]{1,40})["'""']/g;
 const TRIGGER_EXT = /(?<![A-Za-z0-9])\.[A-Za-z0-9]{2,6}\b/g;
-const TRIGGER_STRIP = " \t,.;:!?，。、；：！？、。";
 
 /**
  * Pull candidate trigger phrases out of a skill description.

package/src/gateway/qr.ts

@@ -5,7 +5,6 @@
  */
 
 // qrcode-terminal ships no types; declare the tiny surface we use.
-// eslint-disable-next-line @typescript-eslint/no-require-imports
 const qrcode: { generate: (text: string, opts: { small?: boolean }, cb: (s: string) => void) => void } =
   require('qrcode-terminal');
 

package/src/tools/computer.ts

@@ -5,11 +5,11 @@
  * processes and services, and install/uninstall software.
  */
 
-import { execSync, execFileSync, spawn } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import * as os from 'os';
 import * as fs from 'fs';
 import * as path from 'path';
-import type { ToolRegistry, ToolDefinition } from '../core/tool';
+import type { ToolRegistry } from '../core/tool';
 
 const MAX_OUT = 8000;
 

package/src/web/server.ts

@@ -8,11 +8,8 @@
 
 import { createServer, IncomingMessage, ServerResponse } from "http";
 import { createSystemContext } from "../core/factory";
-import { getLogger } from "../core/logger";
 import { renderInkWashUI, SKYLOOM_FAVICON_SVG } from "./ui";
 
-const log = getLogger("web-server");
-
 /* ──────────────────────────────────────────────
    Server
    ────────────────────────────────────────────── */

package/tests/factory.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi } from "vitest";
+import { SystemContext, TaskExecutionResult } from "../src/core/factory";
+import { MessageBus } from "../src/core/bus";
+
+describe("factory · TaskExecutionResult", () => {
+  it("holds the provided fields", () => {
+    const r = new TaskExecutionResult({ id: "t1", agent: "fog", description: "do x", success: true, content: "done" });
+    expect(r).toMatchObject({ id: "t1", agent: "fog", success: true, content: "done" });
+  });
+});
+
+describe("factory · SystemContext", () => {
+  function ctx(overrides: Partial<ConstructorParameters<typeof SystemContext>[0]> = {}) {
+    return new SystemContext({
+      config: { agents: {} } as any,
+      bus: new MessageBus(),
+      llm: {} as any,
+      agentMap: new Map(),
+      toolRegistry: {} as any,
+      ...overrides,
+    });
+  }
+
+  it("stores constructor options with sensible defaults", () => {
+    const c = ctx({ workspacePath: "/ws" });
+    expect(c.workspacePath).toBe("/ws");
+    expect(c.mcp).toBeNull();
+    expect(c.mcpStatus).toEqual([]);
+    expect(c.agentMap.size).toBe(0);
+  });
+
+  it("initAll fires the plugin init hook before agents come up", async () => {
+    const emit = vi.fn().mockResolvedValue(undefined);
+    const c = ctx({ plugins: { emit } as any });
+    await c.initAll();
+    expect(emit).toHaveBeenCalledWith("init", expect.objectContaining({ config: expect.anything() }));
+  });
+
+  it("closeAll closes every agent and tolerates a missing mcp", async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const agents = new Map<string, any>([
+      ["fog", { close }],
+      ["rain", { close }],
+    ]);
+    const c = ctx({ agentMap: agents as any });
+    await c.closeAll();
+    expect(close).toHaveBeenCalledTimes(2);
+  });
+
+  it("closeAll also closes mcp when present", async () => {
+    const closeAll = vi.fn().mockResolvedValue(undefined);
+    const c = ctx({ mcp: { closeAll } as any });
+    await c.closeAll();
+    expect(closeAll).toHaveBeenCalled();
+  });
+});

package/tests/pipelines.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "vitest";
+import {
+  matchPipeline,
+  matchAllPipelines,
+  buildTasksFromPipeline,
+  listPipelines,
+  getPipelineByName,
+  validateDAG,
+  topologicalSort,
+  type Task,
+} from "../src/core/pipelines";
+
+function task(id: string, dependsOn: string[] = []): Task {
+  return { id, description: id, assignedTo: "fog", parentId: dependsOn[0] ?? null, dependsOn };
+}
+
+describe("pipelines · matching", () => {
+  it("matches a code-review goal to the code_review pipeline", () => {
+    const p = matchPipeline("帮我审查代码");
+    expect(p?.name).toBe("code_review");
+  });
+
+  it("matches an English review goal", () => {
+    expect(matchPipeline("please review my code")?.name).toBe("code_review");
+  });
+
+  it("returns null for an unmatched / empty goal", () => {
+    expect(matchPipeline("今天天气怎么样")).toBeNull();
+    expect(matchPipeline("")).toBeNull();
+  });
+
+  it("matchAllPipelines returns an array (possibly empty)", () => {
+    expect(Array.isArray(matchAllPipelines("审查代码"))).toBe(true);
+    expect(matchAllPipelines("xyzzy nonsense")).toEqual([]);
+  });
+});
+
+describe("pipelines · introspection", () => {
+  it("lists pipelines with names, triggers and steps", () => {
+    const list = listPipelines();
+    expect(list.length).toBeGreaterThan(0);
+    for (const p of list) {
+      expect(typeof p.name).toBe("string");
+      expect(Array.isArray(p.triggers)).toBe(true);
+      expect(Array.isArray(p.steps)).toBe(true);
+    }
+  });
+
+  it("getPipelineByName round-trips a listed name; unknown → null", () => {
+    const name = listPipelines()[0].name as string;
+    expect(getPipelineByName(name)?.name).toBe(name);
+    expect(getPipelineByName("___nope___")).toBeNull();
+  });
+});
+
+describe("pipelines · materialization", () => {
+  it("builds tasks from a pipeline, substituting {goal}", () => {
+    const p = getPipelineByName("code_review")!;
+    const tasks = buildTasksFromPipeline(p, "登录模块");
+    expect(tasks.length).toBe(p.steps.length);
+    expect(tasks[0].description).toContain("登录模块");
+    expect(tasks[0].metadata?.goal).toBe("登录模块");
+    expect(tasks[0].metadata?.pipeline).toBe("code_review");
+  });
+
+  it("a materialized pipeline is a valid DAG", () => {
+    for (const meta of listPipelines()) {
+      const p = getPipelineByName(meta.name as string)!;
+      const tasks = buildTasksFromPipeline(p, "x");
+      const v = validateDAG(tasks);
+      expect(v.valid, `${meta.name}: ${v.errors.join("; ")}`).toBe(true);
+    }
+  });
+});
+
+describe("pipelines · validateDAG", () => {
+  it("accepts a linear chain", () => {
+    const v = validateDAG([task("1"), task("2", ["1"]), task("3", ["2"])]);
+    expect(v.valid).toBe(true);
+    expect(v.errors).toEqual([]);
+  });
+
+  it("flags a missing dependency", () => {
+    const v = validateDAG([task("2", ["1"])]); // 1 doesn't exist
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(" ")).toMatch(/non-existent/);
+  });
+
+  it("detects a cycle", () => {
+    const v = validateDAG([task("a", ["b"]), task("b", ["a"])]);
+    expect(v.valid).toBe(false);
+    expect(v.errors.join(" ")).toMatch(/[Cc]ycle/);
+  });
+});
+
+describe("pipelines · topologicalSort", () => {
+  it("orders dependencies before dependents", () => {
+    const sorted = topologicalSort([task("3", ["2"]), task("1"), task("2", ["1"])]);
+    const order = sorted.map((t) => t.id);
+    expect(order.indexOf("1")).toBeLessThan(order.indexOf("2"));
+    expect(order.indexOf("2")).toBeLessThan(order.indexOf("3"));
+  });
+
+  it("handles independent tasks (all in-degree 0)", () => {
+    const sorted = topologicalSort([task("a"), task("b"), task("c")]);
+    expect(sorted.map((t) => t.id).sort()).toEqual(["a", "b", "c"]);
+  });
+
+  it("a diamond DAG keeps the root first and the join last", () => {
+    // a → b, a → c, b → d, c → d
+    const sorted = topologicalSort([
+      task("d", ["b", "c"]), task("b", ["a"]), task("c", ["a"]), task("a"),
+    ]);
+    const order = sorted.map((t) => t.id);
+    expect(order[0]).toBe("a");
+    expect(order[order.length - 1]).toBe("d");
+  });
+});