skyloom 1.17.0 → 1.18.1

package/tests/logger.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { getLogger, setLogSink, setLogFile, silenceLogs } from "../src/core/logger";
+
+afterEach(() => { silenceLogs(); }); // never leak to the terminal between tests
+
+describe("logger · sink routing", () => {
+  it("routes log lines to a custom sink instead of stderr", () => {
+    const lines: string[] = [];
+    setLogSink((l) => lines.push(l));
+    getLogger("test-sink").warn("hello_world", { a: 1 });
+    expect(lines.length).toBe(1);
+    const entry = JSON.parse(lines[0]);
+    expect(entry.msg).toBe("hello_world");
+    expect(entry.level).toBe("warn");
+    expect(entry.a).toBe(1);
+  });
+
+  it("silenceLogs discards output (keeps a TUI clean)", () => {
+    let count = 0;
+    setLogSink(() => { count++; });
+    silenceLogs();
+    getLogger("test-silence").error("should_be_dropped");
+    expect(count).toBe(0);
+  });
+
+  it("setLogFile appends log lines to a file, not the terminal", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-log-"));
+    const file = path.join(dir, "sky.log");
+    try {
+      const resolved = setLogFile(file);
+      expect(resolved).toBe(file);
+      getLogger("test-file").warn("to_file", { n: 7 });
+      const content = fs.readFileSync(file, "utf8");
+      expect(content).toContain("to_file");
+      expect(content).toContain('"n":7');
+    } finally {
+      silenceLogs();
+      try { fs.rmSync(dir, { recursive: true, force: true }); } catch {}
+    }
+  });
+});

package/tests/patch.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { parsePatch, applyPatch } from "../src/core/patch";
+
+describe("patch · parsePatch", () => {
+  it("parses update / add / delete operations", () => {
+    const text = [
+      "*** Begin Patch",
+      "*** Update File: a.ts",
+      "<<<<<<< SEARCH",
+      "const x = 1;",
+      "=======",
+      "const x = 2;",
+      ">>>>>>> REPLACE",
+      "*** Add File: b.ts",
+      "export const y = 3;",
+      "*** Delete File: c.ts",
+      "*** End Patch",
+    ].join("\n");
+    const r = parsePatch(text) as any;
+    expect(r.error).toBeUndefined();
+    expect(r.ops).toHaveLength(3);
+    expect(r.ops[0]).toMatchObject({ op: "update", path: "a.ts" });
+    expect(r.ops[0].blocks[0]).toEqual({ search: "const x = 1;", replace: "const x = 2;" });
+    expect(r.ops[1]).toMatchObject({ op: "add", path: "b.ts", content: "export const y = 3;\n" });
+    expect(r.ops[2]).toMatchObject({ op: "delete", path: "c.ts" });
+  });
+
+  it("errors on an unterminated SEARCH", () => {
+    const text = "*** Update File: a.ts\n<<<<<<< SEARCH\nfoo\n";
+    expect((parsePatch(text) as any).error).toContain("Unterminated SEARCH");
+  });
+
+  it("errors on stray content outside a file section", () => {
+    expect((parsePatch("hello world") as any).error).toContain("Unexpected line");
+  });
+});
+
+describe("patch · applyPatch (atomic, multi-file)", () => {
+  let dir: string;
+  beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), "sky-patch-")); });
+  afterEach(() => { try { fs.rmSync(dir, { recursive: true, force: true }); } catch {} });
+
+  function write(name: string, content: string) {
+    const p = path.join(dir, name);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, content);
+  }
+  const read = (name: string) => fs.readFileSync(path.join(dir, name), "utf8");
+
+  it("applies update + add + delete in one shot", () => {
+    write("a.ts", "const x = 1;\nkeep me\n");
+    write("c.ts", "delete me\n");
+    const patch = [
+      "*** Update File: a.ts",
+      "<<<<<<< SEARCH",
+      "const x = 1;",
+      "=======",
+      "const x = 42;",
+      ">>>>>>> REPLACE",
+      "*** Add File: sub/b.ts",
+      "export const y = 3;",
+      "*** Delete File: c.ts",
+    ].join("\n");
+    const out = applyPatch(patch, { cwd: dir });
+    expect(out).toContain("Applied patch");
+    expect(read("a.ts")).toBe("const x = 42;\nkeep me\n");
+    expect(read("sub/b.ts")).toBe("export const y = 3;\n");
+    expect(fs.existsSync(path.join(dir, "c.ts"))).toBe(false);
+  });
+
+  it("applies multiple blocks to one file", () => {
+    write("m.ts", "alpha\nbeta\ngamma\n");
+    const patch = [
+      "*** Update File: m.ts",
+      "<<<<<<< SEARCH", "alpha", "=======", "ALPHA", ">>>>>>> REPLACE",
+      "<<<<<<< SEARCH", "gamma", "=======", "GAMMA", ">>>>>>> REPLACE",
+    ].join("\n");
+    applyPatch(patch, { cwd: dir });
+    expect(read("m.ts")).toBe("ALPHA\nbeta\nGAMMA\n");
+  });
+
+  it("is atomic: a failing block leaves ALL files untouched", () => {
+    write("a.ts", "good\n");
+    write("b.ts", "target\n");
+    const patch = [
+      "*** Update File: a.ts",
+      "<<<<<<< SEARCH", "good", "=======", "changed", ">>>>>>> REPLACE",
+      "*** Update File: b.ts",
+      "<<<<<<< SEARCH", "NOT THERE", "=======", "x", ">>>>>>> REPLACE",
+    ].join("\n");
+    const out = applyPatch(patch, { cwd: dir });
+    expect(out).toContain("SEARCH block not found");
+    expect(read("a.ts")).toBe("good\n");   // first file NOT written
+    expect(read("b.ts")).toBe("target\n");
+  });
+
+  it("rejects an ambiguous SEARCH block", () => {
+    write("d.ts", "dup\ndup\n");
+    const patch = ["*** Update File: d.ts", "<<<<<<< SEARCH", "dup", "=======", "x", ">>>>>>> REPLACE"].join("\n");
+    expect(applyPatch(patch, { cwd: dir })).toContain("ambiguous");
+  });
+
+  it("refuses to Add over an existing file", () => {
+    write("exists.ts", "already\n");
+    const patch = "*** Add File: exists.ts\nnew content\n";
+    const out = applyPatch(patch, { cwd: dir });
+    expect(out).toContain("already exists");
+    expect(read("exists.ts")).toBe("already\n");
+  });
+
+  it("treats $-patterns in replacement literally", () => {
+    write("e.ts", "VAL\n");
+    const patch = ["*** Update File: e.ts", "<<<<<<< SEARCH", "VAL", "=======", "$1$&x", ">>>>>>> REPLACE"].join("\n");
+    applyPatch(patch, { cwd: dir });
+    expect(read("e.ts")).toBe("$1$&x\n");
+  });
+
+  it("honors the fence check by aborting", () => {
+    write("a.ts", "good\n");
+    const patch = ["*** Update File: a.ts", "<<<<<<< SEARCH", "good", "=======", "bad", ">>>>>>> REPLACE"].join("\n");
+    const out = applyPatch(patch, { cwd: dir, fenceCheck: () => "路径越界" });
+    expect(out).toContain("路径越界");
+    expect(read("a.ts")).toBe("good\n");
+  });
+});

package/tests/protocol.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest";
+import { engineeringProtocol } from "../src/core/protocol";
+
+describe("protocol · engineeringProtocol", () => {
+  it("zh protocol covers the senior-engineer discipline and names real tools", () => {
+    const p = engineeringProtocol("zh");
+    expect(p).toContain("工程标准");
+    expect(p).toContain("根因");          // root-cause, not symptom
+    expect(p).toContain("最小");          // minimal diffs
+    expect(p).toContain("先理解");        // understand before changing
+    expect(p).toContain("get_diagnostics"); // verify loop wired to real tool
+    expect(p).toContain("code_search");
+  });
+
+  it("en protocol mirrors the zh one", () => {
+    const p = engineeringProtocol("en");
+    expect(p).toContain("Engineering Standard");
+    expect(p).toContain("Root cause");
+    expect(p).toContain("Minimal");
+    expect(p).toContain("get_diagnostics");
+    expect(p).toContain("code_search");
+  });
+
+  it("defaults to zh", () => {
+    expect(engineeringProtocol()).toBe(engineeringProtocol("zh"));
+  });
+});

package/tests/search.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { searchCode, formatSearchResult } from "../src/core/search";
+
+describe("search · searchCode (pure JS)", () => {
+  let root: string;
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "sky-search-"));
+    fs.writeFileSync(path.join(root, "a.ts"), "const Foo = 1;\nexport function useFoo() { return Foo; }\n");
+    fs.writeFileSync(path.join(root, "b.js"), "// foo lower\nconst x = 2;\n");
+    fs.mkdirSync(path.join(root, "sub"));
+    fs.writeFileSync(path.join(root, "sub", "c.ts"), "import { useFoo } from '../a';\n");
+    // should be ignored by default
+    fs.mkdirSync(path.join(root, "node_modules", "dep"), { recursive: true });
+    fs.writeFileSync(path.join(root, "node_modules", "dep", "x.ts"), "const Foo = 999;\n");
+  });
+  afterEach(() => { try { fs.rmSync(root, { recursive: true, force: true }); } catch {} });
+
+  it("finds matches with file:line", () => {
+    const res = searchCode({ pattern: "useFoo", root });
+    const files = res.matches.map((m) => m.file).sort();
+    expect(files).toContain("a.ts");
+    expect(files).toContain("sub/c.ts");
+    const a = res.matches.find((m) => m.file === "a.ts")!;
+    expect(a.line).toBe(2);
+    expect(a.text).toContain("useFoo");
+  });
+
+  it("skips node_modules by default", () => {
+    const res = searchCode({ pattern: "Foo", root });
+    expect(res.matches.some((m) => m.file.includes("node_modules"))).toBe(false);
+  });
+
+  it("restricts by glob", () => {
+    const res = searchCode({ pattern: "foo", root, glob: "**/*.ts", ignoreCase: true });
+    expect(res.matches.some((m) => m.file === "b.js")).toBe(false);
+    expect(res.matches.some((m) => m.file === "a.ts")).toBe(true);
+  });
+
+  it("honors ignoreCase", () => {
+    // b.js contains lowercase "foo"; capital "Foo" only matches case-insensitively.
+    expect(searchCode({ pattern: "Foo", root, glob: "b.js" }).matches.length).toBe(0);
+    expect(searchCode({ pattern: "Foo", root, glob: "b.js", ignoreCase: true }).matches.length).toBe(1);
+  });
+
+  it("returns context lines", () => {
+    const res = searchCode({ pattern: "useFoo", root, glob: "a.ts", context: 1 });
+    const m = res.matches[0];
+    expect(m.before).toEqual(["const Foo = 1;"]);
+  });
+
+  it("treats pattern as literal when regex=false", () => {
+    fs.writeFileSync(path.join(root, "d.ts"), "a.b.c\n");
+    const asRegex = searchCode({ pattern: "a.b", root, glob: "d.ts" });          // '.' = any char
+    const literal = searchCode({ pattern: "a.b", root, glob: "d.ts", regex: false });
+    expect(asRegex.matches.length).toBe(1);
+    expect(literal.matches.length).toBe(1);
+    const noLit = searchCode({ pattern: "axb", root, glob: "d.ts", regex: false });
+    expect(noLit.matches.length).toBe(0);
+  });
+
+  it("caps results and flags truncation", () => {
+    fs.writeFileSync(path.join(root, "many.ts"), Array.from({ length: 50 }, () => "hit").join("\n"));
+    const res = searchCode({ pattern: "hit", root, glob: "many.ts", maxResults: 10 });
+    expect(res.matches.length).toBe(10);
+    expect(res.truncated).toBe(true);
+  });
+
+  it("reports an invalid regex instead of throwing", () => {
+    const res = searchCode({ pattern: "(", root });
+    expect(res.error).toContain("invalid regex");
+  });
+});
+
+describe("search · formatSearchResult", () => {
+  it("renders file:line and a no-match message", () => {
+    expect(formatSearchResult({ matches: [], filesScanned: 3, truncated: false })).toBe("No matches found.");
+    const s = formatSearchResult({
+      matches: [{ file: "a.ts", line: 2, text: "  return Foo;" }],
+      filesScanned: 1, truncated: false,
+    });
+    expect(s).toContain("a.ts:2:");
+    expect(s).toContain("return Foo");
+  });
+});

package/tests/tool.test.ts

@@ -16,6 +16,7 @@ function makeTool(overrides: Partial<ToolDefinition> & { name: string }): ToolDe
     maxRetries: overrides.maxRetries,
     retryDelay: overrides.retryDelay,
     timeout: overrides.timeout,
+    validateOutput: overrides.validateOutput,
   };
 }
 
@@ -184,6 +185,49 @@ describe('ToolRegistry · input validation + coercion', () => {
   });
 });
 
+describe('ToolRegistry · output validation', () => {
+  let registry: ToolRegistry;
+  beforeEach(() => { registry = new ToolRegistry(); });
+
+  it('fails the call when validateOutput rejects the result', async () => {
+    registry.register(makeTool({
+      name: 'guarded',
+      maxRetries: 0,
+      handler: async () => 'garbage',
+      validateOutput: (r) => (r === 'garbage' ? 'looks like garbage' : null),
+    }));
+    const res = await registry.execute('guarded', {});
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('invalid tool output');
+    expect(res.error).toContain('looks like garbage');
+  });
+
+  it('passes when validateOutput accepts the result', async () => {
+    registry.register(makeTool({
+      name: 'ok',
+      handler: async () => 'fine',
+      validateOutput: () => null,
+    }));
+    const res = await registry.execute('ok', {});
+    expect(res.success).toBe(true);
+    expect(res.result).toBe('fine');
+  });
+
+  it('retries a rejected output through the normal retry path', async () => {
+    let n = 0;
+    registry.register(makeTool({
+      name: 'retryout',
+      maxRetries: 1,
+      retryDelay: 0,
+      handler: async () => `v${++n}`,
+      validateOutput: (r) => (r === 'v1' ? 'first is bad' : null),
+    }));
+    const res = await registry.execute('retryout', {});
+    expect(res.success).toBe(true);
+    expect(res.result).toBe('v2');
+  });
+});
+
 describe('stableStringify', () => {
   it('produces an order-independent key for objects', async () => {
     const { stableStringify } = await import('../src/core/tool');

package/tests/websearch.test.ts

@@ -140,6 +140,30 @@ describe("websearch · waterfall", () => {
     expect(formatSearchResults(res)).toContain("No search results");
   });
 
+  it("flags that all providers errored/timed out for a clear message", async () => {
+    const http = stubHttp([
+      { match: "s.jina.ai", throws: "timeout" },
+      { match: "duckduckgo", throws: "timeout" }, { match: "bing", throws: "timeout" },
+      { match: "baidu", throws: "timeout" }, { match: "sogou", throws: "timeout" },
+    ]);
+    const res = await webSearch("q", { env: {}, http });
+    expect(res.errors).toBeGreaterThan(0);
+    expect(formatSearchResults(res)).toMatch(/errored or timed out/);
+  });
+
+  it("stops the waterfall once the time budget is exceeded", async () => {
+    // jina resolves (empty) but slowly; the budget then cuts off the scrapers.
+    const http = {
+      calls: [] as string[],
+      async getJson(url: string) { this.calls.push(url); await new Promise((r) => setTimeout(r, 30)); return { data: [] }; },
+      async getText(url: string) { this.calls.push(url); return ""; },
+      async postJson(url: string) { this.calls.push(url); return {}; },
+    };
+    const res = await webSearch("q", { env: {}, http: http as any, budgetMs: 5 });
+    expect(res.provider).toBe("none");
+    expect(res.tried).toEqual(["jina"]); // scrapers skipped — out of budget
+  });
+
   it("rejects an empty query", async () => {
     await expect(webSearch("   ", {})).rejects.toThrow(/query/);
   });