@calltelemetry/openclaw-linear 0.9.5 → 0.9.7

package/src/infra/shared-profiles.ts

@@ -5,7 +5,7 @@
  * resolveAgentFromAlias() implementations that were previously in
  * webhook.ts, intent-classify.ts, and tier-assess.ts.
  */
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 
@@ -107,6 +107,64 @@ export function resolveDefaultAgent(api: { pluginConfig?: Record<string, unknown
   return "default";
 }
 
+// ---------------------------------------------------------------------------
+// Profile validation — returns a user-facing error string or null if OK.
+// ---------------------------------------------------------------------------
+
+/**
+ * Validate that agent-profiles.json exists, is parseable, and has at least
+ * one agent.  Returns a human-readable error string suitable for posting
+ * back to Linear, or null when everything looks good.
+ */
+export function validateProfiles(): string | null {
+  if (!existsSync(PROFILES_PATH)) {
+    return (
+      `**Critical setup error:** \`agent-profiles.json\` not found.\n\n` +
+      `The Linear plugin requires this file to route messages to your agent.\n\n` +
+      `**Create it now:**\n` +
+      "```\n" +
+      `cat > ${PROFILES_PATH} << 'EOF'\n` +
+      `{\n` +
+      `  "agents": {\n` +
+      `    "my-agent": {\n` +
+      `      "label": "My Agent",\n` +
+      `      "mission": "AI assistant",\n` +
+      `      "isDefault": true,\n` +
+      `      "mentionAliases": ["my-agent"]\n` +
+      `    }\n` +
+      `  }\n` +
+      `}\n` +
+      `EOF\n` +
+      "```\n\n" +
+      `Then restart the gateway: \`systemctl --user restart openclaw-gateway\`\n\n` +
+      `Run \`openclaw openclaw-linear doctor\` to verify your setup.`
+    );
+  }
+
+  let profiles: Record<string, unknown>;
+  try {
+    const raw = readFileSync(PROFILES_PATH, "utf8");
+    profiles = JSON.parse(raw).agents ?? {};
+  } catch (err) {
+    return (
+      `**Critical setup error:** \`agent-profiles.json\` exists but could not be parsed.\n\n` +
+      `Error: ${err instanceof Error ? err.message : String(err)}\n\n` +
+      `Fix the JSON syntax in \`${PROFILES_PATH}\` and restart the gateway.\n` +
+      `Run \`openclaw openclaw-linear doctor\` to verify.`
+    );
+  }
+
+  if (Object.keys(profiles).length === 0) {
+    return (
+      `**Critical setup error:** \`agent-profiles.json\` has no agents configured.\n\n` +
+      `Add at least one agent entry to the \`"agents"\` object in \`${PROFILES_PATH}\`.\n` +
+      `Run \`openclaw openclaw-linear doctor\` for a guided setup check.`
+    );
+  }
+
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Test-only: reset cache
 // ---------------------------------------------------------------------------

package/src/pipeline/sub-issue-decomposition.test.ts

@@ -0,0 +1,388 @@
+/**
+ * sub-issue-decomposition.test.ts — Mock replay of sub-issue creation flow.
+ *
+ * Uses recorded API responses from the smoke test to verify parent-child
+ * hierarchy creation, parentId resolution, and issue relation handling.
+ *
+ * Run with: npx vitest run src/pipeline/sub-issue-decomposition.test.ts
+ * No credentials required — all API calls use recorded fixtures.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock external dependencies before imports
+vi.mock("openclaw/plugin-sdk", () => ({
+  jsonResult: (data: any) => ({ type: "json", data }),
+}));
+
+vi.mock("../api/linear-api.js", () => ({
+  LinearAgentApi: vi.fn(),
+}));
+
+import { RECORDED } from "../__test__/fixtures/recorded-sub-issue-flow.js";
+import {
+  createPlannerTools,
+  setActivePlannerContext,
+  clearActivePlannerContext,
+  detectCycles,
+  auditPlan,
+  buildPlanSnapshot,
+} from "../tools/planner-tools.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+type ProjectIssue = Parameters<typeof detectCycles>[0][number];
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createReplayApi() {
+  const api = {
+    getTeamStates: vi.fn().mockResolvedValue(RECORDED.teamStates),
+    createIssue: vi.fn(),
+    getIssueDetails: vi.fn(),
+    createIssueRelation: vi.fn().mockResolvedValue(RECORDED.createRelation),
+    getProjectIssues: vi.fn(),
+    getTeamLabels: vi.fn().mockResolvedValue([]),
+    updateIssue: vi.fn().mockResolvedValue(true),
+    updateIssueExtended: vi.fn().mockResolvedValue(true),
+    getViewerId: vi.fn().mockResolvedValue("viewer-1"),
+    createComment: vi.fn().mockResolvedValue("comment-id"),
+    emitActivity: vi.fn().mockResolvedValue(undefined),
+    updateSession: vi.fn().mockResolvedValue(undefined),
+    getProject: vi.fn().mockResolvedValue({
+      id: "proj-1",
+      name: "Test",
+      description: "",
+      state: "started",
+      teams: {
+        nodes: [
+          {
+            id: RECORDED.parentDetails.team.id,
+            name: RECORDED.parentDetails.team.name,
+          },
+        ],
+      },
+    }),
+  };
+
+  // Wire up getIssueDetails to return recorded response by ID
+  api.getIssueDetails.mockImplementation((id: string) => {
+    if (id === RECORDED.createParent.id)
+      return Promise.resolve(RECORDED.parentDetails);
+    if (id === RECORDED.createSubIssue1.id)
+      return Promise.resolve(RECORDED.subIssue1WithRelation);
+    if (id === RECORDED.createSubIssue2.id)
+      return Promise.resolve(RECORDED.subIssue2WithRelation);
+    throw new Error(`Unexpected issue ID in replay: ${id}`);
+  });
+
+  return api;
+}
+
+/** Build a ProjectIssue from recorded detail shapes. */
+function recordedToProjectIssue(
+  detail: typeof RECORDED.parentDetails,
+  overrides?: Partial<ProjectIssue>,
+): ProjectIssue {
+  return {
+    id: detail.id,
+    identifier: detail.identifier,
+    title: detail.title,
+    description: detail.description,
+    estimate: detail.estimate,
+    priority: 0,
+    state: detail.state,
+    parent: detail.parent,
+    labels: detail.labels,
+    relations: detail.relations,
+    ...overrides,
+  } as ProjectIssue;
+}
+
+// ===========================================================================
+// Group A: Direct API hierarchy (mock createIssue / getIssueDetails)
+// ===========================================================================
+
+describe("sub-issue decomposition (recorded replay)", () => {
+  describe("parent-child hierarchy via direct API", () => {
+    it("createIssue with parentId creates a sub-issue", async () => {
+      const api = createReplayApi();
+      api.createIssue.mockResolvedValueOnce(RECORDED.createSubIssue1);
+
+      const result = await api.createIssue({
+        teamId: RECORDED.parentDetails.team.id,
+        title: RECORDED.subIssue1Details.title,
+        parentId: RECORDED.createParent.id,
+        estimate: 2,
+        priority: 3,
+      });
+
+      expect(result.id).toBe(RECORDED.createSubIssue1.id);
+      expect(result.identifier).toBe(RECORDED.createSubIssue1.identifier);
+      expect(api.createIssue).toHaveBeenCalledWith(
+        expect.objectContaining({
+          parentId: RECORDED.createParent.id,
+        }),
+      );
+    });
+
+    it("getIssueDetails of sub-issue returns parent reference", async () => {
+      const api = createReplayApi();
+      const details = await api.getIssueDetails(
+        RECORDED.createSubIssue1.id,
+      );
+
+      expect(details.parent).not.toBeNull();
+      expect(details.parent!.id).toBe(RECORDED.createParent.id);
+      expect(details.parent!.identifier).toBe(
+        RECORDED.createParent.identifier,
+      );
+    });
+
+    it("getIssueDetails of parent returns null parent (root)", async () => {
+      const api = createReplayApi();
+      const details = await api.getIssueDetails(RECORDED.createParent.id);
+
+      expect(details.parent).toBeNull();
+    });
+
+    it("createIssueRelation creates blocks dependency", async () => {
+      const api = createReplayApi();
+      const result = await api.createIssueRelation({
+        issueId: RECORDED.createSubIssue1.id,
+        relatedIssueId: RECORDED.createSubIssue2.id,
+        type: "blocks",
+      });
+
+      expect(result.id).toBe(RECORDED.createRelation.id);
+      expect(api.createIssueRelation).toHaveBeenCalledWith({
+        issueId: RECORDED.createSubIssue1.id,
+        relatedIssueId: RECORDED.createSubIssue2.id,
+        type: "blocks",
+      });
+    });
+
+    it("sub-issue details include blocks relation after linking", async () => {
+      const api = createReplayApi();
+      const details = await api.getIssueDetails(
+        RECORDED.createSubIssue1.id,
+      );
+
+      const blocksRels = details.relations.nodes.filter(
+        (r: any) => r.type === "blocks",
+      );
+      expect(blocksRels.length).toBeGreaterThan(0);
+      expect(
+        blocksRels.some(
+          (r: any) => r.relatedIssue.id === RECORDED.createSubIssue2.id,
+        ),
+      ).toBe(true);
+    });
+  });
+
+  // =========================================================================
+  // Group B: Planner tools (real tool code, mocked API)
+  // =========================================================================
+
+  describe("planner tools: parentIdentifier resolution", () => {
+    let tools: any[];
+    let mockApi: ReturnType<typeof createReplayApi>;
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+      mockApi = createReplayApi();
+      setActivePlannerContext({
+        linearApi: mockApi as any,
+        projectId: "proj-1",
+        teamId: RECORDED.parentDetails.team.id,
+        api: { logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() } } as any,
+      });
+      tools = createPlannerTools();
+    });
+
+    afterEach(() => {
+      clearActivePlannerContext();
+    });
+
+    function findTool(name: string) {
+      const tool = tools.find((t: any) => t.name === name) as any;
+      if (!tool) throw new Error(`Tool '${name}' not found`);
+      return tool;
+    }
+
+    it("plan_create_issue resolves parentIdentifier to parentId", async () => {
+      // Mock getProjectIssues to return the parent issue
+      mockApi.getProjectIssues.mockResolvedValueOnce([
+        recordedToProjectIssue(RECORDED.parentDetails),
+      ]);
+      mockApi.createIssue.mockResolvedValueOnce(RECORDED.createSubIssue1);
+
+      const tool = findTool("plan_create_issue");
+      const result = await tool.execute("call-1", {
+        title: RECORDED.subIssue1Details.title,
+        description: RECORDED.subIssue1Details.description,
+        parentIdentifier: RECORDED.createParent.identifier,
+        estimate: 2,
+        priority: 3,
+      });
+
+      // Verify createIssue was called with resolved parentId (not identifier)
+      expect(mockApi.createIssue).toHaveBeenCalledWith(
+        expect.objectContaining({
+          parentId: RECORDED.createParent.id,
+        }),
+      );
+      expect(result.data.identifier).toBe(
+        RECORDED.createSubIssue1.identifier,
+      );
+    });
+
+    it("plan_link_issues creates blocks relation between resolved IDs", async () => {
+      // Mock getProjectIssues to return both sub-issues
+      mockApi.getProjectIssues.mockResolvedValueOnce([
+        recordedToProjectIssue(RECORDED.subIssue1WithRelation),
+        recordedToProjectIssue(RECORDED.subIssue2WithRelation),
+      ]);
+
+      const tool = findTool("plan_link_issues");
+      const result = await tool.execute("call-2", {
+        fromIdentifier: RECORDED.subIssue1WithRelation.identifier,
+        toIdentifier: RECORDED.subIssue2WithRelation.identifier,
+        type: "blocks",
+      });
+
+      expect(mockApi.createIssueRelation).toHaveBeenCalledWith({
+        issueId: RECORDED.subIssue1WithRelation.id,
+        relatedIssueId: RECORDED.subIssue2WithRelation.id,
+        type: "blocks",
+      });
+      expect(result.data.id).toBe(RECORDED.createRelation.id);
+      expect(result.data.type).toBe("blocks");
+    });
+
+    it("plan_get_project shows hierarchy with parent-child nesting", async () => {
+      // Return all 3 issues (parent + 2 subs)
+      mockApi.getProjectIssues.mockResolvedValueOnce([
+        recordedToProjectIssue(RECORDED.parentDetails),
+        recordedToProjectIssue(RECORDED.subIssue1WithRelation),
+        recordedToProjectIssue(RECORDED.subIssue2WithRelation),
+      ]);
+
+      const tool = findTool("plan_get_project");
+      const result = await tool.execute("call-3", {});
+      const snapshot = result.data?.snapshot ?? result.data?.plan ?? "";
+
+      // All three identifiers should appear
+      expect(snapshot).toContain(RECORDED.createParent.identifier);
+      expect(snapshot).toContain(RECORDED.createSubIssue1.identifier);
+      expect(snapshot).toContain(RECORDED.createSubIssue2.identifier);
+    });
+
+    it("plan_audit passes valid sub-issue hierarchy", async () => {
+      // Build issues that pass audit: descriptions >= 50 chars, estimate, priority set
+      const parent = recordedToProjectIssue(RECORDED.parentDetails, {
+        priority: 2,
+        estimate: 5,
+      });
+      const sub1 = recordedToProjectIssue(RECORDED.subIssue1WithRelation, {
+        priority: 3,
+        estimate: 2,
+      });
+      const sub2 = recordedToProjectIssue(RECORDED.subIssue2WithRelation, {
+        priority: 3,
+        estimate: 3,
+      });
+
+      mockApi.getProjectIssues.mockResolvedValueOnce([parent, sub1, sub2]);
+
+      const tool = findTool("plan_audit");
+      const result = await tool.execute("call-4", {});
+
+      expect(result.data.pass).toBe(true);
+      expect(result.data.problems).toHaveLength(0);
+    });
+  });
+
+  // =========================================================================
+  // Group C: auditPlan pure function with recorded data shapes
+  // =========================================================================
+
+  describe("auditPlan with parent-child relationships", () => {
+    it("issues with parent are not flagged as orphans", () => {
+      const parent = recordedToProjectIssue(RECORDED.parentDetails, {
+        priority: 2,
+        estimate: 5,
+      });
+      const sub1 = recordedToProjectIssue(RECORDED.subIssue1Details, {
+        priority: 3,
+        estimate: 2,
+      });
+      const sub2 = recordedToProjectIssue(RECORDED.subIssue2Details, {
+        priority: 3,
+        estimate: 3,
+      });
+
+      const result = auditPlan([parent, sub1, sub2]);
+
+      // Sub-issues have parent set, so they're not orphans.
+      // Parent may be flagged as orphan (no parent, no relations linking to it)
+      // but sub-issues definitely should NOT be orphans.
+      const orphanWarnings = result.warnings.filter((w) =>
+        w.includes("orphan"),
+      );
+      const subOrphans = orphanWarnings.filter(
+        (w) =>
+          w.includes(RECORDED.subIssue1Details.identifier) ||
+          w.includes(RECORDED.subIssue2Details.identifier),
+      );
+      expect(subOrphans).toHaveLength(0);
+    });
+
+    it("blocks relation between sub-issues produces valid DAG", () => {
+      const sub1 = recordedToProjectIssue(RECORDED.subIssue1WithRelation, {
+        priority: 3,
+        estimate: 2,
+      });
+      const sub2 = recordedToProjectIssue(RECORDED.subIssue2WithRelation, {
+        priority: 3,
+        estimate: 3,
+      });
+
+      const cycles = detectCycles([sub1, sub2]);
+      expect(cycles).toHaveLength(0);
+    });
+
+    it("buildPlanSnapshot nests sub-issues under parent", () => {
+      const parent = recordedToProjectIssue(RECORDED.parentDetails, {
+        priority: 2,
+        estimate: 5,
+      });
+      const sub1 = recordedToProjectIssue(RECORDED.subIssue1WithRelation, {
+        priority: 3,
+        estimate: 2,
+      });
+      const sub2 = recordedToProjectIssue(RECORDED.subIssue2WithRelation, {
+        priority: 3,
+        estimate: 3,
+      });
+
+      const snapshot = buildPlanSnapshot([parent, sub1, sub2]);
+
+      // Parent should appear
+      expect(snapshot).toContain(RECORDED.createParent.identifier);
+      // Sub-issues should appear
+      expect(snapshot).toContain(RECORDED.createSubIssue1.identifier);
+      expect(snapshot).toContain(RECORDED.createSubIssue2.identifier);
+      // Sub-issues should be indented (nested under parent)
+      const lines = snapshot.split("\n");
+      const sub1Line = lines.find((l) =>
+        l.includes(RECORDED.createSubIssue1.identifier),
+      );
+      expect(sub1Line).toBeTruthy();
+      expect(sub1Line!.startsWith("  ")).toBe(true);
+    });
+  });
+});

package/src/pipeline/webhook.test.ts

@@ -14,6 +14,7 @@ const {
   loadAgentProfilesMock,
   buildMentionPatternMock,
   resolveAgentFromAliasMock,
+  validateProfilesMock,
   resetProfilesCacheMock,
   classifyIntentMock,
   extractGuidanceMock,
@@ -24,6 +25,9 @@ const {
   resetGuidanceCacheMock,
   setActiveSessionMock,
   clearActiveSessionMock,
+  getIssueAffinityMock,
+  configureAffinityTtlMock,
+  resetAffinityForTestingMock,
   readDispatchStateMock,
   getActiveDispatchMock,
   registerDispatchMock,
@@ -83,6 +87,7 @@ const {
   }),
   buildMentionPatternMock: vi.fn().mockReturnValue(/@(mal|mason|kaylee|eureka)/i),
   resolveAgentFromAliasMock: vi.fn().mockReturnValue(null),
+  validateProfilesMock: vi.fn().mockReturnValue(null),
   resetProfilesCacheMock: vi.fn(),
   classifyIntentMock: vi.fn().mockResolvedValue({
     intent: "general",
@@ -97,6 +102,9 @@ const {
   resetGuidanceCacheMock: vi.fn(),
   setActiveSessionMock: vi.fn(),
   clearActiveSessionMock: vi.fn(),
+  getIssueAffinityMock: vi.fn().mockReturnValue(null),
+  configureAffinityTtlMock: vi.fn(),
+  resetAffinityForTestingMock: vi.fn(),
   readDispatchStateMock: vi.fn().mockResolvedValue({ activeDispatches: {} }),
   getActiveDispatchMock: vi.fn().mockReturnValue(null),
   registerDispatchMock: vi.fn().mockResolvedValue(undefined),
@@ -148,6 +156,7 @@ vi.mock("../infra/shared-profiles.js", () => ({
   loadAgentProfiles: loadAgentProfilesMock,
   buildMentionPattern: buildMentionPatternMock,
   resolveAgentFromAlias: resolveAgentFromAliasMock,
+  validateProfiles: validateProfilesMock,
   _resetProfilesCacheForTesting: resetProfilesCacheMock,
 }));
 
@@ -167,9 +176,9 @@ vi.mock("./guidance.js", () => ({
 vi.mock("./active-session.js", () => ({
   setActiveSession: setActiveSessionMock,
   clearActiveSession: clearActiveSessionMock,
-  getIssueAffinity: vi.fn().mockReturnValue(null),
-  _configureAffinityTtl: vi.fn(),
-  _resetAffinityForTesting: vi.fn(),
+  getIssueAffinity: getIssueAffinityMock,
+  _configureAffinityTtl: configureAffinityTtlMock,
+  _resetAffinityForTesting: resetAffinityForTestingMock,
 }));
 
 vi.mock("./dispatch-state.js", () => ({
@@ -346,6 +355,7 @@ afterEach(() => {
   });
   buildMentionPatternMock.mockReset().mockReturnValue(/@(mal|mason|kaylee|eureka)/i);
   resolveAgentFromAliasMock.mockReset().mockReturnValue(null);
+  validateProfilesMock.mockReset().mockReturnValue(null);
   classifyIntentMock.mockReset().mockResolvedValue({
     intent: "general",
     reasoning: "Not actionable",
@@ -358,6 +368,9 @@ afterEach(() => {
   isGuidanceEnabledMock.mockReset().mockReturnValue(false);
   setActiveSessionMock.mockReset();
   clearActiveSessionMock.mockReset();
+  getIssueAffinityMock.mockReset().mockReturnValue(null);
+  configureAffinityTtlMock.mockReset();
+  resetAffinityForTestingMock.mockReset();
   readDispatchStateMock.mockReset().mockResolvedValue({ activeDispatches: {} });
   getActiveDispatchMock.mockReset().mockReturnValue(null);
   registerDispatchMock.mockReset().mockResolvedValue(undefined);