@calltelemetry/openclaw-linear 0.9.1 → 0.9.2

package/src/pipeline/planner.test.ts

@@ -4,8 +4,9 @@ import { describe, it, expect, vi, afterEach } from "vitest";
 // Mocks (vi.hoisted + vi.mock)
 // ---------------------------------------------------------------------------
 
-const { runAgentMock } = vi.hoisted(() => ({
+const { runAgentMock, loadRawPromptYamlMock } = vi.hoisted(() => ({
   runAgentMock: vi.fn().mockResolvedValue({ success: true, output: "Mock planner response" }),
+  loadRawPromptYamlMock: vi.fn().mockReturnValue(null),
 }));
 
 vi.mock("../agent/agent.js", () => ({
@@ -16,6 +17,10 @@ vi.mock("../api/linear-api.js", () => ({}));
 
 vi.mock("openclaw/plugin-sdk", () => ({}));
 
+vi.mock("./pipeline.js", () => ({
+  loadRawPromptYaml: loadRawPromptYamlMock,
+}));
+
 // Mock CLI tool runners for cross-model review
 vi.mock("../tools/claude-tool.js", () => ({
   runClaude: vi.fn().mockResolvedValue({ success: true, output: "Claude review feedback" }),
@@ -135,6 +140,7 @@ function createSession(overrides?: Record<string, unknown>) {
 afterEach(() => {
   vi.clearAllMocks();
   runAgentMock.mockResolvedValue({ success: true, output: "Mock planner response" });
+  loadRawPromptYamlMock.mockReturnValue(null);
   vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
 });
 
@@ -305,10 +311,10 @@ describe("runPlanAudit", () => {
 
     await runPlanAudit(ctx, session);
 
-    // Agent should run with a review prompt
+    // Agent should run with a review prompt containing cross-model feedback
     expect(runAgentMock).toHaveBeenCalledWith(
       expect.objectContaining({
-        message: expect.stringContaining("Plan Review"),
+        message: expect.stringContaining("passed checks"),
       }),
     );
   });
@@ -450,4 +456,452 @@ describe("runCrossModelReview", () => {
     const result = await runCrossModelReview(api, "claude", "test snapshot");
     expect(result).toContain("review unavailable");
   });
+
+  it("returns '(no feedback)' when runner returns success with no output", async () => {
+    vi.mocked(runGemini).mockResolvedValueOnce({ success: true, output: undefined } as any);
+    const api = createApi();
+    const result = await runCrossModelReview(api, "gemini", "test snapshot");
+    expect(result).toBe("(no feedback)");
+  });
+
+  it("passes pluginConfig to runner", async () => {
+    const api = createApi();
+    const cfg = { someKey: "someValue" };
+    await runCrossModelReview(api, "codex", "test snapshot", cfg);
+    expect(runCodex).toHaveBeenCalledWith(api, expect.any(Object), cfg);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// initiatePlanningSession — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("initiatePlanningSession — additional branches", () => {
+  it("falls back to project teams when rootIssue.team is missing", async () => {
+    const rootIssue = {
+      id: "issue-1",
+      identifier: "PROJ-1",
+      title: "Root",
+      // No team property
+    };
+
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    // Should use team from project.teams.nodes[0].id = "team-1"
+    expect(registerPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      expect.objectContaining({
+        teamId: "team-1",
+      }),
+      undefined,
+    );
+  });
+
+  it("throws error when no team can be determined", async () => {
+    const rootIssue = {
+      id: "issue-1",
+      identifier: "PROJ-1",
+      title: "Root",
+    };
+
+    mockLinearApi.getProject.mockResolvedValueOnce({
+      id: "proj-no-team",
+      name: "No Team Project",
+      teams: { nodes: [] },
+    });
+
+    const ctx = createCtx();
+    await expect(
+      initiatePlanningSession(ctx, "proj-no-team", rootIssue),
+    ).rejects.toThrow("Cannot determine team");
+  });
+
+  it("uses planningStatePath from pluginConfig", async () => {
+    const rootIssue = {
+      id: "issue-1",
+      identifier: "PROJ-1",
+      title: "Root",
+      team: { id: "team-1" },
+    };
+
+    const ctx = createCtx({
+      pluginConfig: { planningStatePath: "/tmp/custom-state.json" },
+    });
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(registerPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      expect.any(Object),
+      "/tmp/custom-state.json",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// handlePlannerTurn — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("handlePlannerTurn — additional branches", () => {
+  const input = {
+    issueId: "issue-1",
+    commentBody: "Continue planning",
+    commentorName: "Tester",
+  };
+
+  it("does not post comment when agent returns no output", async () => {
+    runAgentMock.mockResolvedValueOnce({ success: true, output: "" });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, input);
+
+    // createComment should NOT be called (empty output is falsy)
+    expect(mockLinearApi.createComment).not.toHaveBeenCalled();
+  });
+
+  it("does not post comment when agent returns null output", async () => {
+    runAgentMock.mockResolvedValueOnce({ success: true, output: null });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(mockLinearApi.createComment).not.toHaveBeenCalled();
+  });
+
+  it("clears planner context even when agent throws", async () => {
+    runAgentMock.mockRejectedValueOnce(new Error("agent crash"));
+    const ctx = createCtx();
+    const session = createSession();
+
+    await expect(
+      handlePlannerTurn(ctx, session, input),
+    ).rejects.toThrow("agent crash");
+
+    expect(clearActivePlannerContext).toHaveBeenCalled();
+  });
+
+  it("uses defaultAgentId from pluginConfig", async () => {
+    const ctx = createCtx({
+      pluginConfig: { defaultAgentId: "custom-agent" },
+    });
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        agentId: "custom-agent",
+      }),
+    );
+  });
+
+  it("continues even when comment history fetch fails", async () => {
+    mockLinearApi.getIssueDetails.mockRejectedValueOnce(new Error("API failure"));
+    const ctx = createCtx();
+    const session = createSession();
+
+    // Should not throw — best-effort comment history
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("uses planningStatePath from pluginConfig", async () => {
+    const ctx = createCtx({
+      pluginConfig: { planningStatePath: "/tmp/custom-state.json" },
+    });
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(updatePlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      { turnCount: 1 },
+      "/tmp/custom-state.json",
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runPlanAudit — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("runPlanAudit — additional branches", () => {
+  it("includes warnings in failure comment when present", async () => {
+    vi.mocked(auditPlan).mockReturnValue({
+      pass: false,
+      problems: ["Missing estimate on PROJ-3"],
+      warnings: ["PROJ-4 is an orphan issue"],
+    });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("PROJ-4 is an orphan issue"),
+    );
+  });
+
+  it("failure comment does not include warnings section when none", async () => {
+    vi.mocked(auditPlan).mockReturnValue({
+      pass: false,
+      problems: ["Missing estimate on PROJ-3"],
+      warnings: [],
+    });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.not.stringContaining("**Warnings:**"),
+    );
+  });
+
+  it("does not post review agent comment when output is empty", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    runAgentMock.mockResolvedValueOnce({ success: true, output: "" });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    // First call is "Plan Passed Checks" message, there should be no second call for agent output
+    const commentCalls = mockLinearApi.createComment.mock.calls;
+    const agentOutputCalls = commentCalls.filter(
+      (call: any[]) => !String(call[1]).includes("Plan Passed Checks"),
+    );
+    expect(agentOutputCalls).toHaveLength(0);
+  });
+
+  it("clears planner context even if review agent throws", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    runAgentMock.mockRejectedValueOnce(new Error("agent failure"));
+    const ctx = createCtx();
+    const session = createSession();
+
+    await expect(runPlanAudit(ctx, session)).rejects.toThrow("agent failure");
+
+    expect(clearActivePlannerContext).toHaveBeenCalled();
+  });
+
+  it("uses custom plannerReviewModel from pluginConfig", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx({
+      pluginConfig: { plannerReviewModel: "claude" },
+    });
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(runClaude).toHaveBeenCalled();
+  });
+
+  it("uses defaultAgentId from pluginConfig for review agent", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx({
+      pluginConfig: { defaultAgentId: "my-agent" },
+    });
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        agentId: "my-agent",
+      }),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveReviewModel — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("resolveReviewModel — additional branches", () => {
+  it("ignores invalid plannerReviewModel and falls through", () => {
+    expect(resolveReviewModel({
+      plannerReviewModel: "invalid-model",
+      agents: { defaults: { model: { primary: "anthropic/claude-sonnet-4" } } },
+    } as any)).toBe("codex"); // falls through to primary model logic
+  });
+
+  it("returns 'gemini' for kimi model", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "openrouter/moonshotai/kimi-k2.5" } } },
+    } as any)).toBe("gemini");
+  });
+
+  it("returns 'gemini' for mistral model", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "mistral/mistral-large" } } },
+    } as any)).toBe("gemini");
+  });
+
+  it("returns 'codex' for anthropic model (without claude in name)", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "anthropic/some-model" } } },
+    } as any)).toBe("codex");
+  });
+
+  it("returns 'gemini' for openai model (without codex in name)", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "openai/gpt-5" } } },
+    } as any)).toBe("gemini");
+  });
+
+  it("returns 'codex' for google model (without gemini in name)", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: { model: { primary: "google/palm-3" } } },
+    } as any)).toBe("codex");
+  });
+
+  it("returns 'gemini' when pluginConfig is undefined", () => {
+    expect(resolveReviewModel(undefined)).toBe("gemini");
+  });
+
+  it("returns 'gemini' when agents.defaults.model is undefined", () => {
+    expect(resolveReviewModel({
+      agents: { defaults: {} },
+    } as any)).toBe("gemini");
+  });
+
+  it("respects plannerReviewModel 'codex'", () => {
+    expect(resolveReviewModel({
+      plannerReviewModel: "codex",
+    } as any)).toBe("codex");
+  });
+
+  it("respects plannerReviewModel 'claude'", () => {
+    expect(resolveReviewModel({
+      plannerReviewModel: "claude",
+    } as any)).toBe("claude");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// loadPlannerPrompts — custom YAML prompts branch
+// ---------------------------------------------------------------------------
+
+describe("loadPlannerPrompts — via handlePlannerTurn", () => {
+  const input = {
+    issueId: "issue-1",
+    commentBody: "Continue planning",
+    commentorName: "Tester",
+  };
+
+  it("uses custom planner prompts from YAML when available", async () => {
+    loadRawPromptYamlMock.mockReturnValue({
+      planner: {
+        system: "Custom system prompt",
+        interview: "Custom interview: {{userMessage}}",
+        // leave other keys undefined to test ?? fallback
+      },
+    });
+
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining("Custom system prompt"),
+      }),
+    );
+  });
+
+  it("uses default welcome when YAML planner.welcome is undefined", async () => {
+    loadRawPromptYamlMock.mockReturnValue({
+      planner: {
+        welcome: "Custom welcome for **{{projectName}}**!",
+      },
+    });
+
+    const rootIssue = {
+      id: "issue-1",
+      identifier: "PROJ-1",
+      title: "Root",
+      team: { id: "team-1" },
+    };
+
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("Custom welcome"),
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// handlePlannerTurn — comment history with null/missing nodes
+// ---------------------------------------------------------------------------
+
+describe("handlePlannerTurn — comment history edge cases", () => {
+  const input = {
+    issueId: "issue-1",
+    commentBody: "Continue",
+    commentorName: "Tester",
+  };
+
+  it("handles null comments.nodes gracefully", async () => {
+    mockLinearApi.getIssueDetails.mockResolvedValueOnce({
+      id: "issue-1",
+      identifier: "PROJ-1",
+      title: "Root",
+      comments: { nodes: null },
+    });
+
+    const ctx = createCtx();
+    const session = createSession();
+
+    // Should not throw — the ?. operator handles null
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("handles undefined comments gracefully", async () => {
+    mockLinearApi.getIssueDetails.mockResolvedValueOnce({
+      id: "issue-1",
+      identifier: "PROJ-1",
+      title: "Root",
+      // no comments property
+    });
+
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("handles comments with missing user name", async () => {
+    mockLinearApi.getIssueDetails.mockResolvedValueOnce({
+      id: "issue-1",
+      identifier: "PROJ-1",
+      title: "Root",
+      comments: {
+        nodes: [
+          { body: "A comment", user: null },
+          { body: "Another comment", user: { name: "Alice" } },
+        ],
+      },
+    });
+
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalled();
+  });
 });

package/src/pipeline/planning-state.test.ts

@@ -1,7 +1,7 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { mkdtempSync } from "node:fs";
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { mkdtempSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { tmpdir } from "node:os";
+import { tmpdir, homedir } from "node:os";
 import {
   readPlanningState,
   writePlanningState,
@@ -234,3 +234,164 @@ describe("setPlanningCache / getActivePlanningByProjectId", () => {
     expect(cleared).toBeNull();
   });
 });
+
+// ---------------------------------------------------------------------------
+// readPlanningState — additional branch coverage
+// ---------------------------------------------------------------------------
+
+describe("readPlanningState — corrupted file recovery", () => {
+  it("recovers from corrupted JSON (SyntaxError)", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "claw-ps-corrupt-"));
+    const p = join(dir, "state.json");
+    // Write invalid JSON
+    writeFileSync(p, "{ not valid json !!!", "utf-8");
+
+    const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const state = await readPlanningState(p);
+
+    expect(state.sessions).toEqual({});
+    expect(state.processedEvents).toEqual([]);
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("corrupted"));
+    consoleSpy.mockRestore();
+  });
+
+  it("fills in missing sessions field from parsed data", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "claw-ps-nosessions-"));
+    const p = join(dir, "state.json");
+    // Valid JSON but missing sessions
+    writeFileSync(p, JSON.stringify({ processedEvents: ["e1"] }), "utf-8");
+
+    const state = await readPlanningState(p);
+    expect(state.sessions).toEqual({});
+    expect(state.processedEvents).toEqual(["e1"]);
+  });
+
+  it("fills in missing processedEvents field from parsed data", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "claw-ps-noevents-"));
+    const p = join(dir, "state.json");
+    // Valid JSON but missing processedEvents
+    writeFileSync(p, JSON.stringify({ sessions: { "p1": { projectId: "p1" } } }), "utf-8");
+
+    const state = await readPlanningState(p);
+    expect(state.sessions).toBeDefined();
+    expect(state.sessions["p1"]).toBeDefined();
+    expect(state.processedEvents).toEqual([]);
+  });
+
+  it("re-throws non-ENOENT, non-SyntaxError errors", async () => {
+    // Use a path where the parent is a file (causes ENOTDIR)
+    const dir = mkdtempSync(join(tmpdir(), "claw-ps-errthrow-"));
+    const filePath = join(dir, "afile");
+    writeFileSync(filePath, "data", "utf-8");
+    // Trying to read a path that treats a file as a directory
+    const badPath = join(filePath, "subdir", "state.json");
+
+    await expect(readPlanningState(badPath)).rejects.toThrow();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// writePlanningState — truncation
+// ---------------------------------------------------------------------------
+
+describe("writePlanningState — processedEvents truncation", () => {
+  it("truncates processedEvents to last 200 when exceeding limit", async () => {
+    const p = tmpStatePath();
+    const events = Array.from({ length: 250 }, (_, i) => `evt-${i}`);
+    const data: PlanningState = {
+      sessions: {},
+      processedEvents: events,
+    };
+    await writePlanningState(data, p);
+    const state = await readPlanningState(p);
+    expect(state.processedEvents).toHaveLength(200);
+    // Should keep the last 200 (evt-50 through evt-249)
+    expect(state.processedEvents[0]).toBe("evt-50");
+    expect(state.processedEvents[199]).toBe("evt-249");
+  });
+
+  it("does not truncate when at or below 200", async () => {
+    const p = tmpStatePath();
+    const events = Array.from({ length: 200 }, (_, i) => `evt-${i}`);
+    const data: PlanningState = {
+      sessions: {},
+      processedEvents: events,
+    };
+    await writePlanningState(data, p);
+    const state = await readPlanningState(p);
+    expect(state.processedEvents).toHaveLength(200);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// endPlanningSession — missing session branch
+// ---------------------------------------------------------------------------
+
+describe("endPlanningSession — additional branches", () => {
+  it("does nothing when session does not exist", async () => {
+    const p = tmpStatePath();
+    // End a session that was never registered — should not throw
+    await endPlanningSession("nonexistent-proj", "abandoned", p);
+
+    const state = await readPlanningState(p);
+    expect(state.sessions).toEqual({});
+  });
+
+  it("clears planning cache even when session is missing", async () => {
+    const p = tmpStatePath();
+    const session = makePlanningSession({ projectId: "cache-test" });
+    setPlanningCache(session);
+
+    // End session that exists in cache but not in file
+    await endPlanningSession("cache-test", "abandoned", p);
+
+    // Cache should be cleared
+    expect(getActivePlanningByProjectId("cache-test")).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getActivePlanningByProjectId — cache miss
+// ---------------------------------------------------------------------------
+
+describe("getActivePlanningByProjectId — additional branches", () => {
+  it("returns null for project not in cache", () => {
+    const result = getActivePlanningByProjectId("never-cached-project");
+    expect(result).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// writePlanningState — directory creation
+// ---------------------------------------------------------------------------
+
+describe("writePlanningState — directory creation", () => {
+  it("creates parent directory if it does not exist", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "claw-ps-newdir-"));
+    const p = join(dir, "subdir", "deep", "state.json");
+    const data: PlanningState = {
+      sessions: {},
+      processedEvents: ["e1"],
+    };
+    await writePlanningState(data, p);
+    const state = await readPlanningState(p);
+    expect(state.processedEvents).toEqual(["e1"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveStatePath — tilde expansion
+// ---------------------------------------------------------------------------
+
+describe("resolveStatePath (via readPlanningState)", () => {
+  it("expands ~/... path to homedir", async () => {
+    // This exercises the `configPath.startsWith("~/")` branch.
+    // We can't easily test the exact path but we can verify it doesn't crash
+    // and resolves to a real path by using a non-existent file under ~.
+    const tildeFile = "~/nonexistent-claw-test-dir-12345/state.json";
+    // readPlanningState with ENOENT should return empty state
+    const state = await readPlanningState(tildeFile);
+    expect(state.sessions).toEqual({});
+    expect(state.processedEvents).toEqual([]);
+  });
+});