@calltelemetry/openclaw-linear 0.6.0 → 0.7.0

package/src/infra/notify.ts

@@ -1,10 +1,14 @@
 /**
- * notify.ts — Simple notification function for dispatch lifecycle events.
+ * notify.ts — Unified notification provider for dispatch lifecycle events.
  *
- * One concrete Discord implementation + noop fallback.
- * No abstract class — add provider abstraction only when a second
- * backend (Slack, email) actually exists.
+ * Uses OpenClaw's native runtime channel API for all providers (Discord, Slack,
+ * Telegram, Signal, etc). One formatter, one send function, config-driven
+ * fan-out with per-event-type toggles.
+ *
+ * Modeled on DevClaw's notify.ts pattern — the runtime handles token resolution,
+ * formatting differences (markdown vs mrkdwn), and delivery per channel.
  */
+import type { PluginRuntime } from "openclaw/plugin-sdk";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -32,58 +36,133 @@ export interface NotifyPayload {
 export type NotifyFn = (kind: NotifyKind, payload: NotifyPayload) => Promise<void>;
 
 // ---------------------------------------------------------------------------
-// Discord implementation
+// Provider config
 // ---------------------------------------------------------------------------
 
-const DISCORD_API = "https://discord.com/api/v10";
+export interface NotifyTarget {
+  /** OpenClaw channel name: "discord", "slack", "telegram", "signal", etc. */
+  channel: string;
+  /** Channel/group/user ID to send to */
+  target: string;
+  /** Optional account ID for multi-account channel setups */
+  accountId?: string;
+}
+
+export interface NotificationsConfig {
+  targets?: NotifyTarget[];
+  events?: Partial<Record<NotifyKind, boolean>>;
+}
+
+// ---------------------------------------------------------------------------
+// Unified message formatter
+// ---------------------------------------------------------------------------
 
-function formatDiscordMessage(kind: NotifyKind, payload: NotifyPayload): string {
-  const prefix = `**${payload.identifier}**`;
+export function formatMessage(kind: NotifyKind, payload: NotifyPayload): string {
+  const id = payload.identifier;
   switch (kind) {
     case "dispatch":
-      return `${prefix} dispatched — ${payload.title}`;
+      return `${id} dispatched — ${payload.title}`;
     case "working":
-      return `${prefix} worker started (attempt ${payload.attempt ?? 0})`;
+      return `${id} worker started (attempt ${payload.attempt ?? 0})`;
     case "auditing":
-      return `${prefix} audit in progress`;
+      return `${id} audit in progress`;
     case "audit_pass":
-      return `${prefix} passed audit. PR ready.`;
+      return `${id} passed audit. PR ready.`;
     case "audit_fail": {
       const gaps = payload.verdict?.gaps?.join(", ") ?? "unspecified";
-      return `${prefix} failed audit (attempt ${payload.attempt ?? 0}). Gaps: ${gaps}`;
+      return `${id} failed audit (attempt ${payload.attempt ?? 0}). Gaps: ${gaps}`;
     }
     case "escalation":
-      return `🚨 ${prefix} needs human review — ${payload.reason ?? "audit failed 2x"}`;
+      return `🚨 ${id} needs human review — ${payload.reason ?? "audit failed 2x"}`;
     case "stuck":
-      return `⏰ ${prefix} stuck — ${payload.reason ?? "stale 2h"}`;
+      return `⏰ ${id} stuck — ${payload.reason ?? "stale 2h"}`;
     case "watchdog_kill":
-      return `⚡ ${prefix} killed by watchdog (${payload.reason ?? "no I/O for 120s"}). ${
+      return `⚡ ${id} killed by watchdog (${payload.reason ?? "no I/O for 120s"}). ${
         payload.attempt != null ? `Retrying (attempt ${payload.attempt}).` : "Will retry."
       }`;
     default:
-      return `${prefix} — ${kind}: ${payload.status}`;
+      return `${id} — ${kind}: ${payload.status}`;
   }
 }
 
-export function createDiscordNotifier(botToken: string, channelId: string): NotifyFn {
+// ---------------------------------------------------------------------------
+// Unified send — routes to OpenClaw runtime channel API
+// ---------------------------------------------------------------------------
+
+export async function sendToTarget(
+  target: NotifyTarget,
+  message: string,
+  runtime: PluginRuntime,
+): Promise<void> {
+  const ch = target.channel;
+  const to = target.target;
+
+  if (ch === "discord") {
+    await runtime.channel.discord.sendMessageDiscord(to, message);
+  } else if (ch === "slack") {
+    await runtime.channel.slack.sendMessageSlack(to, message, {
+      accountId: target.accountId,
+    });
+  } else if (ch === "telegram") {
+    await runtime.channel.telegram.sendMessageTelegram(to, message, { silent: true });
+  } else if (ch === "signal") {
+    await runtime.channel.signal.sendMessageSignal(to, message);
+  } else {
+    // Fallback: use CLI for any channel the runtime doesn't expose directly
+    const { execFileSync } = await import("node:child_process");
+    execFileSync("openclaw", ["message", "send", "--channel", ch, "--target", to, "--message", message, "--json"], {
+      timeout: 30_000,
+      stdio: "ignore",
+    });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Config-driven factory
+// ---------------------------------------------------------------------------
+
+/**
+ * Parse notification config from plugin config.
+ */
+export function parseNotificationsConfig(
+  pluginConfig: Record<string, unknown> | undefined,
+): NotificationsConfig {
+  const raw = pluginConfig?.notifications as NotificationsConfig | undefined;
+  return {
+    targets: raw?.targets ?? [],
+    events: raw?.events ?? {},
+  };
+}
+
+/**
+ * Create a notifier from plugin config. Returns a NotifyFn that:
+ * 1. Checks event toggles (skip suppressed events)
+ * 2. Formats the message
+ * 3. Fans out to all configured targets (failures isolated via Promise.allSettled)
+ */
+export function createNotifierFromConfig(
+  pluginConfig: Record<string, unknown> | undefined,
+  runtime: PluginRuntime,
+): NotifyFn {
+  const config = parseNotificationsConfig(pluginConfig);
+
+  if (!config.targets?.length) return createNoopNotifier();
+
   return async (kind, payload) => {
-    const message = formatDiscordMessage(kind, payload);
-    try {
-      const res = await fetch(`${DISCORD_API}/channels/${channelId}/messages`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bot ${botToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ content: message }),
-      });
-      if (!res.ok) {
-        const body = await res.text().catch(() => "");
-        console.error(`Discord notify failed (${res.status}): ${body}`);
-      }
-    } catch (err) {
-      console.error("Discord notify error:", err);
-    }
+    // Check event toggle — default is enabled (true)
+    if (config.events?.[kind] === false) return;
+
+    const message = formatMessage(kind, payload);
+
+    await Promise.allSettled(
+      config.targets!.map(async (target) => {
+        try {
+          await sendToTarget(target, message, runtime);
+        } catch (err) {
+          console.error(`Notify error (${target.channel}:${target.target}):`, err);
+        }
+      }),
+    );
   };
 }
 

package/src/pipeline/planner.test.ts

@@ -0,0 +1,334 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Mocks (vi.hoisted + vi.mock)
+// ---------------------------------------------------------------------------
+
+const { runAgentMock } = vi.hoisted(() => ({
+  runAgentMock: vi.fn().mockResolvedValue({ success: true, output: "Mock planner response" }),
+}));
+
+vi.mock("../agent/agent.js", () => ({
+  runAgent: runAgentMock,
+}));
+
+vi.mock("../api/linear-api.js", () => ({}));
+
+vi.mock("openclaw/plugin-sdk", () => ({}));
+
+const mockLinearApi = {
+  getProject: vi.fn().mockResolvedValue({
+    id: "proj-1",
+    name: "Test Project",
+    teams: { nodes: [{ id: "team-1", name: "Team" }] },
+  }),
+  getProjectIssues: vi.fn().mockResolvedValue([]),
+  getTeamStates: vi.fn().mockResolvedValue([
+    { id: "st-1", name: "Backlog", type: "backlog" },
+  ]),
+  getTeamLabels: vi.fn().mockResolvedValue([]),
+  createComment: vi.fn().mockResolvedValue("comment-id"),
+  getIssueDetails: vi.fn().mockResolvedValue({
+    id: "issue-1",
+    identifier: "PROJ-1",
+    title: "Root",
+    comments: { nodes: [] },
+    project: { id: "proj-1" },
+    team: { id: "team-1" },
+  }),
+};
+
+vi.mock("./planning-state.js", () => ({
+  registerPlanningSession: vi.fn().mockResolvedValue(undefined),
+  updatePlanningSession: vi.fn().mockResolvedValue({
+    turnCount: 1,
+    projectId: "proj-1",
+    status: "interviewing",
+  }),
+  endPlanningSession: vi.fn().mockResolvedValue(undefined),
+  setPlanningCache: vi.fn(),
+  clearPlanningCache: vi.fn(),
+}));
+
+vi.mock("../tools/planner-tools.js", () => ({
+  setActivePlannerContext: vi.fn(),
+  clearActivePlannerContext: vi.fn(),
+  buildPlanSnapshot: vi.fn().mockReturnValue("_No issues created yet._"),
+  auditPlan: vi.fn().mockReturnValue({ pass: true, problems: [], warnings: [] }),
+}));
+
+// ---------------------------------------------------------------------------
+// Imports (AFTER mocks)
+// ---------------------------------------------------------------------------
+
+import { initiatePlanningSession, handlePlannerTurn, runPlanAudit } from "./planner.js";
+import {
+  registerPlanningSession,
+  updatePlanningSession,
+  endPlanningSession,
+  setPlanningCache,
+} from "./planning-state.js";
+import {
+  setActivePlannerContext,
+  clearActivePlannerContext,
+  auditPlan,
+} from "../tools/planner-tools.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createApi() {
+  return {
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    pluginConfig: {},
+  } as any;
+}
+
+function createCtx(overrides?: Partial<{ api: any; linearApi: any; pluginConfig: any }>) {
+  return {
+    api: createApi(),
+    linearApi: mockLinearApi,
+    pluginConfig: {},
+    ...overrides,
+  };
+}
+
+function createSession(overrides?: Record<string, unknown>) {
+  return {
+    projectId: "proj-1",
+    projectName: "Test Project",
+    rootIssueId: "issue-1",
+    rootIdentifier: "PROJ-1",
+    teamId: "team-1",
+    status: "interviewing" as const,
+    startedAt: new Date().toISOString(),
+    turnCount: 0,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+
+afterEach(() => {
+  vi.clearAllMocks();
+  runAgentMock.mockResolvedValue({ success: true, output: "Mock planner response" });
+  vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+});
+
+// ---------------------------------------------------------------------------
+// initiatePlanningSession
+// ---------------------------------------------------------------------------
+
+describe("initiatePlanningSession", () => {
+  const rootIssue = {
+    id: "issue-1",
+    identifier: "PROJ-1",
+    title: "Root",
+    team: { id: "team-1" },
+  };
+
+  it("registers session in state with projectId and status interviewing", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(registerPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      expect.objectContaining({
+        projectId: "proj-1",
+        status: "interviewing",
+      }),
+      undefined,
+    );
+  });
+
+  it("sets planning cache with the session", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(setPlanningCache).toHaveBeenCalledWith(
+      expect.objectContaining({
+        projectId: "proj-1",
+        projectName: "Test Project",
+        status: "interviewing",
+      }),
+    );
+  });
+
+  it("posts welcome comment containing the project name", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("Test Project"),
+    );
+  });
+
+  it("fetches project metadata and team states", async () => {
+    const ctx = createCtx();
+    await initiatePlanningSession(ctx, "proj-1", rootIssue);
+
+    expect(mockLinearApi.getProject).toHaveBeenCalledWith("proj-1");
+    expect(mockLinearApi.getTeamStates).toHaveBeenCalledWith("team-1");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// handlePlannerTurn
+// ---------------------------------------------------------------------------
+
+describe("handlePlannerTurn", () => {
+  const input = {
+    issueId: "issue-1",
+    commentBody: "Let's add a search feature",
+    commentorName: "Tester",
+  };
+
+  it("increments turn count via updatePlanningSession", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(updatePlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      { turnCount: 1 },
+      undefined,
+    );
+  });
+
+  it("builds plan snapshot from project issues", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(mockLinearApi.getProjectIssues).toHaveBeenCalledWith("proj-1");
+  });
+
+  it("calls runAgent with system prompt", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        message: expect.stringContaining("planning"),
+      }),
+    );
+  });
+
+  it("posts agent response as comment", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+    await handlePlannerTurn(ctx, session, input);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      "Mock planner response",
+    );
+  });
+
+  it("detects finalize plan intent and triggers audit instead of regular turn", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, {
+      issueId: "issue-1",
+      commentBody: "finalize plan",
+      commentorName: "Tester",
+    });
+
+    // Audit path: auditPlan is called, runAgent is NOT called
+    expect(auditPlan).toHaveBeenCalled();
+    expect(runAgentMock).not.toHaveBeenCalled();
+  });
+
+  it("detects abandon intent and ends session as abandoned", async () => {
+    const ctx = createCtx();
+    const session = createSession();
+
+    await handlePlannerTurn(ctx, session, {
+      issueId: "issue-1",
+      commentBody: "abandon",
+      commentorName: "Tester",
+    });
+
+    expect(endPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      "abandoned",
+      undefined,
+    );
+    // Should NOT run the agent
+    expect(runAgentMock).not.toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runPlanAudit
+// ---------------------------------------------------------------------------
+
+describe("runPlanAudit", () => {
+  it("posts success comment on passing audit", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("Approved"),
+    );
+  });
+
+  it("ends session as approved on pass", async () => {
+    vi.mocked(auditPlan).mockReturnValue({ pass: true, problems: [], warnings: [] });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(endPlanningSession).toHaveBeenCalledWith(
+      "proj-1",
+      "approved",
+      undefined,
+    );
+  });
+
+  it("posts problems on failing audit", async () => {
+    vi.mocked(auditPlan).mockReturnValue({
+      pass: false,
+      problems: ["Missing description on PROJ-2"],
+      warnings: [],
+    });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(mockLinearApi.createComment).toHaveBeenCalledWith(
+      "issue-1",
+      expect.stringContaining("Missing description on PROJ-2"),
+    );
+  });
+
+  it("does NOT end session as approved on fail", async () => {
+    vi.mocked(auditPlan).mockReturnValue({
+      pass: false,
+      problems: ["No estimates"],
+      warnings: [],
+    });
+    const ctx = createCtx();
+    const session = createSession();
+
+    await runPlanAudit(ctx, session);
+
+    expect(endPlanningSession).not.toHaveBeenCalledWith(
+      "proj-1",
+      "approved",
+      expect.anything(),
+    );
+  });
+});