skyloom 1.23.0 → 1.25.0

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");
+  });
+});