@calltelemetry/openclaw-linear 0.7.1 → 0.8.1

package/src/pipeline/intent-classify.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+const { runAgentMock } = vi.hoisted(() => ({
+  runAgentMock: vi.fn().mockResolvedValue({
+    success: true,
+    output: '{"intent":"general","reasoning":"test"}',
+  }),
+}));
+
+vi.mock("../agent/agent.js", () => ({
+  runAgent: runAgentMock,
+}));
+
+vi.mock("../api/linear-api.js", () => ({}));
+vi.mock("openclaw/plugin-sdk", () => ({}));
+
+// ---------------------------------------------------------------------------
+// Imports (AFTER mocks)
+// ---------------------------------------------------------------------------
+
+import { classifyIntent, regexFallback, type IntentContext } from "./intent-classify.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createApi(overrides?: Record<string, unknown>) {
+  return {
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    pluginConfig: overrides ?? {},
+  } as any;
+}
+
+function createCtx(overrides?: Partial<IntentContext>): IntentContext {
+  return {
+    commentBody: "hello world",
+    issueTitle: "Test Issue",
+    issueStatus: "In Progress",
+    isPlanning: false,
+    agentNames: ["mal", "kaylee", "inara"],
+    hasProject: false,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+
+afterEach(() => {
+  vi.clearAllMocks();
+  runAgentMock.mockResolvedValue({
+    success: true,
+    output: '{"intent":"general","reasoning":"test"}',
+  });
+});
+
+// ---------------------------------------------------------------------------
+// classifyIntent — LLM path
+// ---------------------------------------------------------------------------
+
+describe("classifyIntent", () => {
+  it("parses valid intent from LLM response", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: '{"intent":"request_work","reasoning":"user wants something built"}',
+    });
+
+    const result = await classifyIntent(createApi(), createCtx({ commentBody: "fix the bug" }));
+
+    expect(result.intent).toBe("request_work");
+    expect(result.reasoning).toBe("user wants something built");
+    expect(result.fromFallback).toBe(false);
+  });
+
+  it("parses intent with extra text around JSON", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: 'Here is my analysis:\n{"intent":"question","reasoning":"user asking for help"}\nDone.',
+    });
+
+    const result = await classifyIntent(createApi(), createCtx());
+    expect(result.intent).toBe("question");
+    expect(result.fromFallback).toBe(false);
+  });
+
+  it("populates agentId for ask_agent with valid name", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: '{"intent":"ask_agent","agentId":"Kaylee","reasoning":"user addressing kaylee"}',
+    });
+
+    const result = await classifyIntent(createApi(), createCtx({
+      commentBody: "hey kaylee look at this",
+    }));
+
+    expect(result.intent).toBe("ask_agent");
+    expect(result.agentId).toBe("kaylee");
+  });
+
+  it("clears agentId for ask_agent with hallucinated name", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: '{"intent":"ask_agent","agentId":"wash","reasoning":"user wants wash"}',
+    });
+
+    const result = await classifyIntent(createApi(), createCtx());
+
+    expect(result.intent).toBe("ask_agent");
+    expect(result.agentId).toBeUndefined();
+  });
+
+  it("falls back to regex when LLM returns invalid JSON", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: "I cannot determine the intent",
+    });
+
+    const result = await classifyIntent(createApi(), createCtx());
+    expect(result.fromFallback).toBe(true);
+  });
+
+  it("falls back to regex when LLM returns invalid intent enum", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: '{"intent":"destroy_everything","reasoning":"chaos"}',
+    });
+
+    const result = await classifyIntent(createApi(), createCtx());
+    expect(result.fromFallback).toBe(true);
+  });
+
+  it("falls back to regex when LLM call fails", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: false,
+      output: "Agent error",
+    });
+
+    const result = await classifyIntent(createApi(), createCtx());
+    expect(result.fromFallback).toBe(true);
+  });
+
+  it("falls back to regex when LLM call throws", async () => {
+    runAgentMock.mockRejectedValueOnce(new Error("timeout"));
+
+    const result = await classifyIntent(createApi(), createCtx());
+    expect(result.fromFallback).toBe(true);
+  });
+
+  it("uses 12s timeout for classification", async () => {
+    await classifyIntent(createApi(), createCtx());
+
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        timeoutMs: 12_000,
+      }),
+    );
+  });
+
+  it("includes context in the prompt", async () => {
+    await classifyIntent(createApi(), createCtx({
+      commentBody: "what can I do?",
+      issueTitle: "Auth Feature",
+      isPlanning: true,
+    }));
+
+    const call = runAgentMock.mock.calls[0][0];
+    expect(call.message).toContain("Auth Feature");
+    expect(call.message).toContain("Planning mode: true");
+    expect(call.message).toContain("what can I do?");
+  });
+
+  it("uses classifierAgentId from pluginConfig when configured", async () => {
+    await classifyIntent(
+      createApi({ classifierAgentId: "haiku-classifier" }),
+      createCtx(),
+      { classifierAgentId: "haiku-classifier" },
+    );
+
+    expect(runAgentMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        agentId: "haiku-classifier",
+      }),
+    );
+  });
+
+  it("truncates long comments to 500 chars", async () => {
+    const longComment = "x".repeat(1000);
+    await classifyIntent(createApi(), createCtx({ commentBody: longComment }));
+
+    const call = runAgentMock.mock.calls[0][0];
+    expect(call.message).not.toContain("x".repeat(501));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// regexFallback
+// ---------------------------------------------------------------------------
+
+describe("regexFallback", () => {
+  describe("planning mode active", () => {
+    it("detects finalize intent", () => {
+      const result = regexFallback(createCtx({
+        isPlanning: true,
+        commentBody: "finalize the plan",
+      }));
+      expect(result.intent).toBe("plan_finalize");
+      expect(result.fromFallback).toBe(true);
+    });
+
+    it("detects approve plan intent", () => {
+      const result = regexFallback(createCtx({
+        isPlanning: true,
+        commentBody: "approve plan",
+      }));
+      expect(result.intent).toBe("plan_finalize");
+    });
+
+    it("detects abandon intent", () => {
+      const result = regexFallback(createCtx({
+        isPlanning: true,
+        commentBody: "abandon planning",
+      }));
+      expect(result.intent).toBe("plan_abandon");
+      expect(result.fromFallback).toBe(true);
+    });
+
+    it("detects cancel planning", () => {
+      const result = regexFallback(createCtx({
+        isPlanning: true,
+        commentBody: "cancel planning",
+      }));
+      expect(result.intent).toBe("plan_abandon");
+    });
+
+    it("defaults to plan_continue for unmatched text", () => {
+      const result = regexFallback(createCtx({
+        isPlanning: true,
+        commentBody: "add a search feature please",
+      }));
+      expect(result.intent).toBe("plan_continue");
+      expect(result.fromFallback).toBe(true);
+    });
+  });
+
+  describe("not planning", () => {
+    it("detects plan_start when issue has project", () => {
+      const result = regexFallback(createCtx({
+        hasProject: true,
+        commentBody: "plan this project",
+      }));
+      expect(result.intent).toBe("plan_start");
+      expect(result.fromFallback).toBe(true);
+    });
+
+    it("does NOT detect plan_start without project", () => {
+      const result = regexFallback(createCtx({
+        hasProject: false,
+        commentBody: "plan this project",
+      }));
+      expect(result.intent).toBe("general");
+    });
+
+    it("detects agent name in comment", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "hey kaylee check this out",
+      }));
+      expect(result.intent).toBe("ask_agent");
+      expect(result.agentId).toBe("kaylee");
+    });
+
+    it("returns general for no pattern match", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "thanks for the update",
+        agentNames: [],
+      }));
+      expect(result.intent).toBe("general");
+      expect(result.fromFallback).toBe(true);
+    });
+  });
+});

package/src/pipeline/intent-classify.ts

@@ -0,0 +1,259 @@
+/**
+ * intent-classify.ts — LLM-based intent classification for Linear comments.
+ *
+ * Replaces static regex pattern matching with a lightweight LLM classifier.
+ * Follows the tier-assess.ts pattern: runAgent() subprocess call, JSON parsing,
+ * regex fallback on any failure.
+ *
+ * Cost: one short agent turn (~300 tokens). Latency: ~2-5s.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type Intent =
+  | "plan_start"
+  | "plan_finalize"
+  | "plan_abandon"
+  | "plan_continue"
+  | "ask_agent"
+  | "request_work"
+  | "question"
+  | "general";
+
+export interface IntentResult {
+  intent: Intent;
+  agentId?: string;
+  reasoning: string;
+  fromFallback: boolean;
+}
+
+export interface IntentContext {
+  commentBody: string;
+  issueTitle: string;
+  issueStatus?: string;
+  isPlanning: boolean;
+  /** Names of available agents (e.g. ["mal", "kaylee", "inara"]) */
+  agentNames: string[];
+  /** Whether the issue belongs to a project */
+  hasProject: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Valid intents (for validation)
+// ---------------------------------------------------------------------------
+
+const VALID_INTENTS: Set<string> = new Set([
+  "plan_start",
+  "plan_finalize",
+  "plan_abandon",
+  "plan_continue",
+  "ask_agent",
+  "request_work",
+  "question",
+  "general",
+]);
+
+// ---------------------------------------------------------------------------
+// Classifier prompt
+// ---------------------------------------------------------------------------
+
+const CLASSIFY_PROMPT = `You are an intent classifier for a developer tool. Respond ONLY with JSON.
+
+Intents:
+- plan_start: user wants to begin project planning
+- plan_finalize: user wants to approve/finalize the plan (e.g. "looks good", "ship it", "approve plan")
+- plan_abandon: user wants to cancel/stop planning (e.g. "nevermind", "cancel this", "stop planning")
+- plan_continue: regular message during planning (default when planning is active)
+- ask_agent: user is addressing a specific agent by name
+- request_work: user wants something built, fixed, or implemented
+- question: user asking for information or help
+- general: none of the above, automated messages, or noise
+
+Rules:
+- plan_start ONLY if the issue belongs to a project (hasProject=true)
+- If planning mode is active and no clear finalize/abandon intent, default to plan_continue
+- For ask_agent, set agentId to the matching name from Available agents
+- One sentence reasoning`;
+
+// ---------------------------------------------------------------------------
+// Classify
+// ---------------------------------------------------------------------------
+
+/**
+ * Classify a comment's intent using a lightweight model.
+ *
+ * Uses `classifierAgentId` from plugin config (should point to a small/fast
+ * model like Haiku for low latency and cost). Falls back to the default
+ * agent if not configured.
+ *
+ * Falls back to regex patterns if the LLM call fails or returns invalid JSON.
+ */
+export async function classifyIntent(
+  api: OpenClawPluginApi,
+  ctx: IntentContext,
+  pluginConfig?: Record<string, unknown>,
+): Promise<IntentResult> {
+  const contextBlock = [
+    `Issue: "${ctx.issueTitle}" (status: ${ctx.issueStatus ?? "unknown"})`,
+    `Planning mode: ${ctx.isPlanning}`,
+    `Has project: ${ctx.hasProject}`,
+    `Available agents: ${ctx.agentNames.join(", ") || "none"}`,
+    `Comment: "${ctx.commentBody.slice(0, 500)}"`,
+  ].join("\n");
+
+  const message = `${CLASSIFY_PROMPT}\n\nContext:\n${contextBlock}\n\nRespond ONLY with: {"intent":"<intent>","agentId":"<if ask_agent>","reasoning":"<one sentence>"}`;
+
+  try {
+    const { runAgent } = await import("../agent/agent.js");
+    const classifierAgent = resolveClassifierAgent(api, pluginConfig);
+    const result = await runAgent({
+      api,
+      agentId: classifierAgent,
+      sessionId: `intent-classify-${Date.now()}`,
+      message,
+      timeoutMs: 12_000, // 12s — fast classification
+    });
+
+    if (result.output) {
+      const parsed = parseIntentResponse(result.output, ctx);
+      if (parsed) {
+        api.logger.info(`Intent classified: ${parsed.intent}${parsed.agentId ? ` (agent: ${parsed.agentId})` : ""} — ${parsed.reasoning}`);
+        return parsed;
+      }
+    }
+
+    if (!result.success) {
+      api.logger.warn(`Intent classifier agent failed: ${result.output.slice(0, 200)}`);
+    } else {
+      api.logger.warn(`Intent classifier: could not parse response: ${result.output.slice(0, 200)}`);
+    }
+  } catch (err) {
+    api.logger.warn(`Intent classifier error: ${err}`);
+  }
+
+  // Fallback to regex
+  const fallback = regexFallback(ctx);
+  api.logger.info(`Intent classifier fallback: ${fallback.intent} — ${fallback.reasoning}`);
+  return fallback;
+}
+
+// ---------------------------------------------------------------------------
+// Response parsing
+// ---------------------------------------------------------------------------
+
+function parseIntentResponse(raw: string, ctx: IntentContext): IntentResult | null {
+  // Extract JSON using indexOf/lastIndexOf (more robust than regex for nested JSON)
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+
+  try {
+    const parsed = JSON.parse(raw.slice(start, end + 1));
+    const intent = parsed.intent as string;
+
+    if (!VALID_INTENTS.has(intent)) return null;
+
+    // Validate agentId for ask_agent
+    let agentId: string | undefined;
+    if (intent === "ask_agent" && parsed.agentId) {
+      const normalized = String(parsed.agentId).toLowerCase();
+      // Only accept agent names that actually exist
+      if (ctx.agentNames.some((n) => n.toLowerCase() === normalized)) {
+        agentId = normalized;
+      }
+      // If hallucinated name, clear agentId but keep the intent
+    }
+
+    return {
+      intent: intent as Intent,
+      agentId,
+      reasoning: parsed.reasoning ?? "no reasoning provided",
+      fromFallback: false,
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Regex fallback (moved from planner.ts + webhook.ts)
+// ---------------------------------------------------------------------------
+
+// Planning intent patterns
+const PLAN_START_PATTERN = /\b(plan|planning)\s+(this\s+)(project|out)\b|\bplan\s+this\s+out\b/i;
+const FINALIZE_PATTERN = /\b(finalize\s+(the\s+)?plan\b|done\s+planning\b(?!\s+\w)|approve\s+(the\s+)?plan\b|plan\s+looks\s+good\b|ready\s+to\s+finalize\b|let'?s\s+finalize\b)/i;
+const ABANDON_PATTERN = /\b(abandon\s+plan(ning)?|cancel\s+plan(ning)?|stop\s+planning|exit\s+planning|quit\s+planning)\b/i;
+
+export function regexFallback(ctx: IntentContext): IntentResult {
+  const text = ctx.commentBody;
+
+  // Planning-specific patterns (only when planning is active or issue has project)
+  if (ctx.isPlanning) {
+    if (FINALIZE_PATTERN.test(text)) {
+      return { intent: "plan_finalize", reasoning: "regex: finalize pattern matched", fromFallback: true };
+    }
+    if (ABANDON_PATTERN.test(text)) {
+      return { intent: "plan_abandon", reasoning: "regex: abandon pattern matched", fromFallback: true };
+    }
+    // Default to plan_continue during planning
+    return { intent: "plan_continue", reasoning: "regex: planning mode active, default continue", fromFallback: true };
+  }
+
+  // Plan start (only if issue has a project)
+  if (ctx.hasProject && PLAN_START_PATTERN.test(text)) {
+    return { intent: "plan_start", reasoning: "regex: plan start pattern matched", fromFallback: true };
+  }
+
+  // Agent name detection
+  if (ctx.agentNames.length > 0) {
+    const lower = text.toLowerCase();
+    for (const name of ctx.agentNames) {
+      if (lower.includes(name.toLowerCase())) {
+        return { intent: "ask_agent", agentId: name.toLowerCase(), reasoning: `regex: agent name "${name}" found in comment`, fromFallback: true };
+      }
+    }
+  }
+
+  // Default: general (no match)
+  return { intent: "general", reasoning: "regex: no pattern matched", fromFallback: true };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the agent to use for intent classification.
+ *
+ * Priority: pluginConfig.classifierAgentId → defaultAgentId → profile default.
+ * Configure classifierAgentId to point to a small/fast model (e.g. Haiku)
+ * for low-latency, low-cost classification.
+ */
+function resolveClassifierAgent(api: OpenClawPluginApi, pluginConfig?: Record<string, unknown>): string {
+  // 1. Explicit classifier agent
+  const classifierAgent = pluginConfig?.classifierAgentId ?? (api as any).pluginConfig?.classifierAgentId;
+  if (typeof classifierAgent === "string" && classifierAgent) return classifierAgent;
+
+  // 2. Fall back to default agent
+  return resolveDefaultAgent(api);
+}
+
+function resolveDefaultAgent(api: OpenClawPluginApi): string {
+  const fromConfig = (api as any).pluginConfig?.defaultAgentId;
+  if (typeof fromConfig === "string" && fromConfig) return fromConfig;
+
+  try {
+    const profilesPath = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
+    const raw = readFileSync(profilesPath, "utf8");
+    const profiles = JSON.parse(raw).agents ?? {};
+    const defaultAgent = Object.entries(profiles).find(([, p]: [string, any]) => p.isDefault);
+    if (defaultAgent) return defaultAgent[0];
+  } catch { /* fall through */ }
+
+  return "default";
+}

package/src/pipeline/pipeline.test.ts

@@ -223,4 +223,73 @@ describe("loadPrompts", () => {
     expect(first).not.toBe(second);
     expect(first).toEqual(second);
   });
+
+  it("merges global overlay with defaults (section-level shallow merge)", () => {
+    // Use promptsPath in pluginConfig to load custom YAML from a temp file
+    const { writeFileSync, mkdtempSync } = require("node:fs");
+    const { join } = require("node:path");
+    const { tmpdir } = require("node:os");
+    const dir = mkdtempSync(join(tmpdir(), "claw-prompt-"));
+    const yamlPath = join(dir, "prompts.yaml");
+    writeFileSync(yamlPath, "worker:\n  system: custom worker system\n");
+
+    clearPromptCache();
+    const prompts = loadPrompts({ promptsPath: yamlPath });
+    // Worker system should be overridden
+    expect(prompts.worker.system).toBe("custom worker system");
+    // Worker task should still be default
+    expect(prompts.worker.task).toContain("{{identifier}}");
+    // Audit should be completely default
+    expect(prompts.audit.system).toContain("auditor");
+    clearPromptCache();
+  });
+
+  it("merges per-project overlay on top of global (three layers)", () => {
+    const { writeFileSync, mkdtempSync, mkdirSync } = require("node:fs");
+    const { join } = require("node:path");
+    const { tmpdir } = require("node:os");
+
+    // Layer 2: global override via promptsPath
+    const globalDir = mkdtempSync(join(tmpdir(), "claw-prompt-global-"));
+    const globalYaml = join(globalDir, "prompts.yaml");
+    writeFileSync(globalYaml, "worker:\n  system: global system\n");
+
+    // Layer 3: per-project override in worktree/.claw/prompts.yaml
+    const worktreeDir = mkdtempSync(join(tmpdir(), "claw-prompt-wt-"));
+    mkdirSync(join(worktreeDir, ".claw"), { recursive: true });
+    writeFileSync(join(worktreeDir, ".claw", "prompts.yaml"), "audit:\n  system: project auditor\n");
+
+    clearPromptCache();
+    const prompts = loadPrompts({ promptsPath: globalYaml }, worktreeDir);
+    // Layer 2: global override
+    expect(prompts.worker.system).toBe("global system");
+    // Layer 3: per-project override
+    expect(prompts.audit.system).toBe("project auditor");
+    // Layer 1: defaults retained where not overridden
+    expect(prompts.rework.addendum).toContain("PREVIOUS AUDIT FAILED");
+    clearPromptCache();
+  });
+
+  it("clearPromptCache clears both global and project caches", () => {
+    const { writeFileSync, mkdtempSync, mkdirSync } = require("node:fs");
+    const { join } = require("node:path");
+    const { tmpdir } = require("node:os");
+
+    // Per-project YAML only (no global — uses defaults for global)
+    const worktreeDir = mkdtempSync(join(tmpdir(), "claw-prompt-cache-"));
+    mkdirSync(join(worktreeDir, ".claw"), { recursive: true });
+    writeFileSync(join(worktreeDir, ".claw", "prompts.yaml"), "worker:\n  system: cached project\n");
+
+    clearPromptCache();
+    const first = loadPrompts(undefined, worktreeDir);
+    expect(first.worker.system).toBe("cached project");
+    // Same ref from cache
+    expect(loadPrompts(undefined, worktreeDir)).toBe(first);
+    // Clear both caches
+    clearPromptCache();
+    const second = loadPrompts(undefined, worktreeDir);
+    expect(second).not.toBe(first);
+    expect(second.worker.system).toBe("cached project");
+    clearPromptCache();
+  });
 });