skyloom 1.13.5 → 1.13.7

package/tests/config.test.ts

@@ -1,41 +1,41 @@
-import { describe, it, expect } from "vitest";
-import { mergeConfigs } from "../src/core/config";
-
-describe("mergeConfigs", () => {
-  it("preserves top-level default_model / default_provider (regression)", () => {
-    // Previously these were dropped, so the wizard's chosen model never applied.
-    const def: any = { agents: { fog: { temperature: 0.7 } }, llm: { default_model: "gpt-4o" } };
-    const user: any = { default_model: "deepseek-v4-flash", default_provider: "deepseek" };
-    const merged: any = mergeConfigs(def, user);
-    expect(merged.default_model).toBe("deepseek-v4-flash");
-    expect(merged.default_provider).toBe("deepseek");
-  });
-
-  it("deep-merges the llm block with the user winning", () => {
-    const def: any = { agents: {}, llm: { default_model: "gpt-4o", temperature: 0.7 } };
-    const user: any = { llm: { default_model: "deepseek-chat" } };
-    const merged: any = mergeConfigs(def, user);
-    expect(merged.llm.default_model).toBe("deepseek-chat");
-    expect(merged.llm.temperature).toBe(0.7); // preserved from default
-  });
-
-  it("merges agents (user overrides, defaults retained)", () => {
-    const def: any = { agents: { fog: { temperature: 0.7 }, rain: { temperature: 0.5 } } };
-    const user: any = { agents: { fog: { model: "deepseek-v4-pro", temperature: 0.2 } } };
-    const merged: any = mergeConfigs(def, user);
-    expect(merged.agents.fog.model).toBe("deepseek-v4-pro");
-    expect(merged.agents.rain.temperature).toBe(0.5);
-  });
-
-  it("returns the default config unchanged when no user config", () => {
-    const def: any = { agents: { fog: {} }, default_model: "gpt-4o" };
-    expect(mergeConfigs(def, null)).toBe(def);
-  });
-
-  it("preserves passthrough top-level blocks (memory, workspace)", () => {
-    const def: any = { agents: {}, memory: { short_term_limit: 100 }, workspace: { path: "auto" } };
-    const merged: any = mergeConfigs(def, { agents: {} } as any);
-    expect(merged.memory.short_term_limit).toBe(100);
-    expect(merged.workspace.path).toBe("auto");
-  });
-});
+import { describe, it, expect } from "vitest";
+import { mergeConfigs } from "../src/core/config";
+
+describe("mergeConfigs", () => {
+  it("preserves top-level default_model / default_provider (regression)", () => {
+    // Previously these were dropped, so the wizard's chosen model never applied.
+    const def: any = { agents: { fog: { temperature: 0.7 } }, llm: { default_model: "gpt-4o" } };
+    const user: any = { default_model: "deepseek-v4-flash", default_provider: "deepseek" };
+    const merged: any = mergeConfigs(def, user);
+    expect(merged.default_model).toBe("deepseek-v4-flash");
+    expect(merged.default_provider).toBe("deepseek");
+  });
+
+  it("deep-merges the llm block with the user winning", () => {
+    const def: any = { agents: {}, llm: { default_model: "gpt-4o", temperature: 0.7 } };
+    const user: any = { llm: { default_model: "deepseek-chat" } };
+    const merged: any = mergeConfigs(def, user);
+    expect(merged.llm.default_model).toBe("deepseek-chat");
+    expect(merged.llm.temperature).toBe(0.7); // preserved from default
+  });
+
+  it("merges agents (user overrides, defaults retained)", () => {
+    const def: any = { agents: { fog: { temperature: 0.7 }, rain: { temperature: 0.5 } } };
+    const user: any = { agents: { fog: { model: "deepseek-v4-pro", temperature: 0.2 } } };
+    const merged: any = mergeConfigs(def, user);
+    expect(merged.agents.fog.model).toBe("deepseek-v4-pro");
+    expect(merged.agents.rain.temperature).toBe(0.5);
+  });
+
+  it("returns the default config unchanged when no user config", () => {
+    const def: any = { agents: { fog: {} }, default_model: "gpt-4o" };
+    expect(mergeConfigs(def, null)).toBe(def);
+  });
+
+  it("preserves passthrough top-level blocks (memory, workspace)", () => {
+    const def: any = { agents: {}, memory: { short_term_limit: 100 }, workspace: { path: "auto" } };
+    const merged: any = mergeConfigs(def, { agents: {} } as any);
+    expect(merged.memory.short_term_limit).toBe(100);
+    expect(merged.workspace.path).toBe("auto");
+  });
+});

package/tests/guard.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from "vitest";
+import { LoopGuard } from "../src/core/agent/guard";
+
+function toolCall(name: string, args: any = {}) {
+  return { id: "c" + Math.random(), type: "function", function: { name, arguments: JSON.stringify(args) } } as any;
+}
+const ok = (name: string) => ({ toolName: name, success: true, result: "ok" });
+const fail = (name: string) => ({ toolName: name, success: false, result: "Error: boom" });
+
+describe("LoopGuard", () => {
+  it("no hints / no stop for a normal round", () => {
+    const g = new LoopGuard();
+    const d = g.observe("hello", [toolCall("read", { path: "a" })], [ok("read")]);
+    expect(d.hints).toEqual([]);
+    expect(d.stop).toBeUndefined();
+  });
+
+  it("hard-stops when the same tool signature repeats past the threshold", () => {
+    const g = new LoopGuard();
+    let last: any;
+    for (let i = 0; i < 12; i++) last = g.observe("", [toolCall("spin", { n: 1 })], [ok("spin")]);
+    expect(last.stop).toBeDefined();
+    expect(last.stop.contentLine).toContain("repeated");
+    expect(last.stop.note).toContain("Stopping");
+  });
+
+  it("injects a tool-loop hint once before hard-stopping", () => {
+    const g = new LoopGuard();
+    const hintRounds: string[][] = [];
+    for (let i = 0; i < 12; i++) hintRounds.push(g.observe("", [toolCall("spin", { n: 1 })], [ok("spin")]).hints);
+    const allHints = hintRounds.flat();
+    expect(allHints.filter((h) => h.includes("[Tool loop]")).length).toBe(1); // once only
+  });
+
+  it("flags a narration loop when responses are near-identical", () => {
+    const g = new LoopGuard();
+    const text = "我正在分析这个问题并准备给出答案，请稍候。";
+    g.observe(text, [], []);
+    const d = g.observe(text, [], []); // same content again
+    expect(d.hints.some((h) => h.includes("Stop narrating"))).toBe(true);
+  });
+
+  it("injects a recovery hint when most recent tool calls failed", () => {
+    const g = new LoopGuard();
+    const hints: string[] = [];
+    for (let i = 0; i < 5; i++) hints.push(...g.observe("", [toolCall("t" + i)], [fail("t" + i)]).hints);
+    expect(hints.some((h) => h.includes("[Recovery hint]"))).toBe(true);
+  });
+
+  it("hard-stops when the last 8 tool calls all failed", () => {
+    const g = new LoopGuard();
+    let last: any;
+    // distinct tool names so the signature-loop guard doesn't fire first
+    for (let i = 0; i < 8; i++) last = g.observe("", [toolCall("t" + i, { i })], [fail("t" + i)]);
+    expect(last.stop).toBeDefined();
+    expect(last.stop.contentLine).toContain("every recent tool call failed");
+  });
+
+  it("hard-stops on a search storm (>=12 distinct search calls)", () => {
+    const g = new LoopGuard();
+    let last: any;
+    // cycle distinct search tools so the signature-loop guard doesn't fire first
+    const tools = ["web_search", "fetch_page", "http_get"];
+    for (let i = 0; i < 12; i++) last = g.observe("", [toolCall(tools[i % 3], { q: "x" + i })], [ok(tools[i % 3])]);
+    expect(last.stop).toBeDefined();
+    expect(last.stop.contentLine).toContain("excessive web searching");
+  });
+
+  it("ignores task_done in signature counting (never hard-stops on it)", () => {
+    const g = new LoopGuard();
+    let last: any;
+    for (let i = 0; i < 15; i++) last = g.observe("", [toolCall("task_done", {})], [ok("task_done")]);
+    expect(last.stop).toBeUndefined();
+  });
+});

package/tests/icons.test.ts

@@ -1,45 +1,45 @@
-/**
- * Tests for agent icon system.
- */
-import { describe, it, expect } from 'vitest';
-import { AGENT_COLORS, AGENT_EMOJI, iconText, svgPath } from '../src/core/icons';
-
-describe('AGENT_COLORS', () => {
-  it('has all 6 agents', () => {
-    expect(Object.keys(AGENT_COLORS).sort()).toEqual(['dew', 'fair', 'fog', 'frost', 'rain', 'snow']);
-  });
-
-  it('each agent has a non-empty color', () => {
-    for (const color of Object.values(AGENT_COLORS)) {
-      expect(color).toBeTruthy();
-    }
-  });
-});
-
-describe('AGENT_EMOJI', () => {
-  it('has all 6 agents', () => {
-    expect(Object.keys(AGENT_EMOJI).sort()).toEqual(['dew', 'fair', 'fog', 'frost', 'rain', 'snow']);
-  });
-
-  it('unique emoji per agent', () => {
-    const values = Object.values(AGENT_EMOJI);
-    expect(new Set(values).size).toBe(values.length);
-  });
-});
-
-describe('iconText', () => {
-  it('returns glyph for known agent', () => {
-    expect(iconText('fog')).toBe('≋');
-    expect(iconText('fair')).toBe('☼');
-  });
-
-  it('returns name as fallback for unknown agent', () => {
-    expect(iconText('unknown')).toBe('unknown');
-  });
-});
-
-describe('svgPath', () => {
-  it('returns a path ending with .svg', () => {
-    expect(svgPath('fog')).toContain('icons');
-  });
-});
+/**
+ * Tests for agent icon system.
+ */
+import { describe, it, expect } from 'vitest';
+import { AGENT_COLORS, AGENT_EMOJI, iconText, svgPath } from '../src/core/icons';
+
+describe('AGENT_COLORS', () => {
+  it('has all 6 agents', () => {
+    expect(Object.keys(AGENT_COLORS).sort()).toEqual(['dew', 'fair', 'fog', 'frost', 'rain', 'snow']);
+  });
+
+  it('each agent has a non-empty color', () => {
+    for (const color of Object.values(AGENT_COLORS)) {
+      expect(color).toBeTruthy();
+    }
+  });
+});
+
+describe('AGENT_EMOJI', () => {
+  it('has all 6 agents', () => {
+    expect(Object.keys(AGENT_EMOJI).sort()).toEqual(['dew', 'fair', 'fog', 'frost', 'rain', 'snow']);
+  });
+
+  it('unique emoji per agent', () => {
+    const values = Object.values(AGENT_EMOJI);
+    expect(new Set(values).size).toBe(values.length);
+  });
+});
+
+describe('iconText', () => {
+  it('returns glyph for known agent', () => {
+    expect(iconText('fog')).toBe('≋');
+    expect(iconText('fair')).toBe('☼');
+  });
+
+  it('returns name as fallback for unknown agent', () => {
+    expect(iconText('unknown')).toBe('unknown');
+  });
+});
+
+describe('svgPath', () => {
+  it('returns a path ending with .svg', () => {
+    expect(svgPath('fog')).toContain('icons');
+  });
+});

package/tests/loom.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect } from "vitest";
+import { visualWidth } from "../src/cli/tui";
+import {
+  cutVisual, padAnsi, wrapPlain, Screen, mountainRow, overlay, circled,
+  LoomUI, OrchState,
+} from "../src/cli/loom";
+
+const strip = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
+
+describe("ANSI-aware helpers", () => {
+  it("cutVisual truncates by visual width, keeping ANSI", () => {
+    expect(strip(cutVisual("hello", 3))).toBe("hel");
+    expect(strip(cutVisual("雾雨霜", 4))).toBe("雾雨");
+    expect(strip(cutVisual("雾雨霜", 5))).toBe("雾雨"); // can't split a wide glyph
+    const styled = "\x1b[36m雾雨\x1b[39m";
+    expect(visualWidth(cutVisual(styled, 2))).toBe(2);
+    expect(cutVisual(styled, 2)).toContain("\x1b[36m");
+  });
+
+  it("padAnsi pads to exact visual width", () => {
+    expect(visualWidth(padAnsi("雾", 6))).toBe(6);
+    expect(visualWidth(padAnsi("雾雨霜雪露晴", 4))).toBe(4); // truncates
+    expect(visualWidth(padAnsi("\x1b[31mab\x1b[0m", 5))).toBe(5);
+  });
+
+  it("wrapPlain wraps CJK per glyph and latin per word", () => {
+    expect(wrapPlain("雾雨霜雪", 4)).toEqual(["雾雨", "霜雪"]);
+    expect(wrapPlain("alpha beta", 6)).toEqual(["alpha", "beta"]);
+    expect(wrapPlain("", 10)).toEqual([""]);
+    for (const ln of wrapPlain("混合 mixed 文本 with 中英 words", 10)) {
+      expect(visualWidth(ln)).toBeLessThanOrEqual(10);
+    }
+  });
+
+  it("wrapPlain hard-breaks unbroken monster tokens", () => {
+    const lines = wrapPlain("a".repeat(25), 10);
+    expect(lines.every((l) => visualWidth(l) <= 10)).toBe(true);
+    expect(lines.join("")).toBe("a".repeat(25));
+  });
+
+  it("overlay puts top glyphs over base, fixed width", () => {
+    const res = overlay("▁▁▁▁▁▁", "  ≋   ", 6);
+    const plain = strip(res);
+    expect(plain).toContain("≋");
+    expect(plain).toContain("▁");
+    expect(visualWidth(res)).toBe(6);
+  });
+
+  it("circled maps indices to ①②…", () => {
+    expect(circled(0)).toBe("①");
+    expect(circled(5)).toBe("⑥");
+  });
+});
+
+describe("Screen diff renderer", () => {
+  it("repaints only changed rows", () => {
+    let buf = "";
+    const out = { write: (s: string) => { buf += s; return true; } };
+    const sc = new Screen(out);
+    sc.flush(["aaa", "bbb", "ccc"], null);
+    buf = "";
+    sc.flush(["aaa", "BBB", "ccc"], null);
+    expect(buf).toContain("BBB");
+    expect(buf).not.toContain("aaa");
+    expect(buf).not.toContain("ccc");
+    expect(buf).toContain("\x1b[2;1H"); // row 2 repainted in place
+  });
+
+  it("clears rows that disappear when the frame shrinks", () => {
+    let buf = "";
+    const out = { write: (s: string) => { buf += s; return true; } };
+    const sc = new Screen(out);
+    sc.flush(["a", "b", "c"], null);
+    buf = "";
+    sc.flush(["a"], null);
+    expect(buf).toContain("\x1b[2;1H\x1b[2K");
+    expect(buf).toContain("\x1b[3;1H\x1b[2K");
+  });
+});
+
+describe("mountainRow", () => {
+  it("is deterministic and fills the width", () => {
+    const a = mountainRow(40, 5);
+    const b = mountainRow(40, 5);
+    expect(a).toBe(b);
+    expect(visualWidth(a)).toBe(40);
+  });
+
+  it("grows with the session", () => {
+    const young = strip(mountainRow(60, 0));
+    const old = strip(mountainRow(60, 30));
+    const mass = (s: string) => [...s].reduce((n, c) => n + " ▁▂▃▄▅".indexOf(c), 0);
+    expect(mass(old)).toBeGreaterThan(mass(young));
+  });
+});
+
+describe("OrchState (multi-agent dynamics)", () => {
+  const plan = [
+    { id: "t1", assignedTo: "fog", description: "调研", allDeps: [] },
+    { id: "t2", assignedTo: "rain", description: "起草", allDeps: ["t1"] },
+  ];
+
+  it("tracks plan → start → done with per-agent tallies", () => {
+    const o = new OrchState();
+    o.plan(plan);
+    expect(o.progress()).toEqual({ done: 0, total: 2 });
+    o.start("t1");
+    expect(o.runningAgents()).toEqual(["fog"]);
+    expect(o.tally("fog").run).toBe(true);
+    o.done("t1", true);
+    expect(o.tally("fog")).toEqual({ ok: 1, fail: 0, run: false });
+    o.start("t2");
+    o.done("t2", false);
+    expect(o.tally("rain").fail).toBe(1);
+    expect(o.progress()).toEqual({ done: 2, total: 2 });
+  });
+
+  it("moves shuttles only while an agent is weaving", () => {
+    const o = new OrchState();
+    o.plan(plan);
+    o.start("t1");
+    expect(o.shuttleX.has("fog")).toBe(true);
+    o.done("t1", true);
+    expect(o.shuttleX.has("fog")).toBe(false);
+  });
+});
+
+/** Headless LoomUI on a fake 80×24 terminal. */
+function makeUI(cols = 80, rows = 24) {
+  const out = { columns: cols, rows, isTTY: false, write: (_: string) => true };
+  const ui = new LoomUI({ out, inp: null, headless: true });
+  ui.start();
+  return ui;
+}
+
+describe("LoomUI frame composition", () => {
+  it("every row is exactly terminal width; frame is exactly terminal height", () => {
+    const ui = makeUI(80, 24);
+    ui.text("你好，世界。Hello world.");
+    ui.line("a styled line");
+    const frame = ui.paint();
+    expect(frame.length).toBe(24);
+    for (const row of frame) expect(visualWidth(row)).toBe(80);
+  });
+
+  it("streams into the open block and shows the agent header", () => {
+    const ui = makeUI();
+    ui.beginStream("rain");
+    ui.streamWrite("江南可采莲，");
+    ui.streamWrite("莲叶何田田。");
+    const frame = ui.paint().map(strip).join("\n");
+    expect(frame).toContain("雨");
+    expect(frame).toContain("江南可采莲，莲叶何田田。");
+    ui.endStream();
+    for (const row of ui.paint()) expect(visualWidth(row)).toBe(80);
+  });
+
+  it("renders the weave chart and rail badges during orchestration", () => {
+    const ui = makeUI(100, 30);
+    ui.orch.plan([
+      { id: "t1", assignedTo: "fog", description: "调研竞品", allDeps: [] },
+      { id: "t2", assignedTo: "frost", description: "审校", allDeps: ["t1"] },
+    ]);
+    ui.orch.start("t1");
+    ui.line(" ≋ ① 霧 调研竞品", "task-t1");
+    ui.line(" · ② 霜 审校 ←①", "task-t2");
+    const frame = ui.paint();
+    expect(frame.length).toBe(30);
+    for (const row of frame) expect(visualWidth(row)).toBe(100);
+    const text = frame.map(strip).join("\n");
+    expect(text).toContain("调研竞品");
+    expect(text).toContain("①");
+  });
+
+  it("updates line blocks in place by id", () => {
+    const ui = makeUI();
+    ui.line("· task running", "task-x");
+    ui.update("task-x", "✓ task done");
+    const text = ui.paint().map(strip).join("\n");
+    expect(text).toContain("✓ task done");
+    expect(text).not.toContain("task running");
+  });
+
+  it("falls back to a notice on tiny terminals", () => {
+    const ui = makeUI(40, 8);
+    const frame = ui.paint();
+    expect(strip(frame[0])).toContain("窗口太小");
+  });
+
+  it("survives many turns and long text without width drift", () => {
+    const ui = makeUI(72, 20);
+    for (let i = 0; i < 50; i++) {
+      ui.text(`第 ${i} 轮：混排 latin text 和中文，外加长串 ${"x".repeat(90)}`);
+      ui.turns++;
+    }
+    for (const row of ui.paint()) expect(visualWidth(row)).toBe(72);
+  });
+});
+
+describe("palette ↑↓ navigation + Enter execution", () => {
+  function key(ui: any, name: string, opts: Record<string, any> = {}) {
+    ui.onKey(opts.str ?? "", { name, ...opts });
+  }
+  function type(ui: any, text: string) {
+    for (const ch of text) ui.onKey(ch, { name: ch });
+  }
+
+  it("Enter runs the ↑↓-highlighted command", async () => {
+    const ui = makeUI() as any;
+    const p = ui.readInput();
+    type(ui, "/");
+    key(ui, "down"); // /fog → /rain
+    key(ui, "down"); // /rain → /frost
+    key(ui, "return");
+    expect(await p).toBe("/frost");
+  });
+
+  it("selection can scroll past the visible window", () => {
+    const ui = makeUI() as any;
+    type(ui, "/");
+    const total = ui.paletteMatches().length;
+    for (let i = 0; i < total + 5; i++) key(ui, "down");
+    expect(ui.paletteIdx).toBe(total - 1); // clamped to last, beyond first 8
+    expect(total).toBeGreaterThan(8);
+    for (const row of ui.paint()) expect(visualWidth(row)).toBe(80);
+  });
+
+  it("argument-taking commands fill the input instead of submitting", () => {
+    const ui = makeUI() as any;
+    let resolved: string | null = null;
+    ui.readInput().then((s: string) => { resolved = s; });
+    type(ui, "/task");
+    key(ui, "return");
+    expect(ui.inputGlyphs.join("")).toBe("/task ");
+    expect(resolved).toBeNull(); // not submitted — waiting for arguments
+  });
+
+  it("typing resets the selection; Esc closes the palette", () => {
+    const ui = makeUI() as any;
+    type(ui, "/");
+    key(ui, "down");
+    expect(ui.paletteIdx).toBe(1);
+    type(ui, "c"); // filter change
+    expect(ui.paletteIdx).toBe(0);
+    key(ui, "escape");
+    expect(ui.inputGlyphs.length).toBe(0);
+  });
+});