@calltelemetry/openclaw-linear 0.8.7 → 0.9.0

package/src/infra/shared-profiles.test.ts

@@ -0,0 +1,262 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Mocks
+// ---------------------------------------------------------------------------
+
+const { mockReadFileSync } = vi.hoisted(() => ({
+  mockReadFileSync: vi.fn(),
+}));
+
+vi.mock("node:fs", () => ({
+  readFileSync: mockReadFileSync,
+}));
+
+// ---------------------------------------------------------------------------
+// Imports (AFTER mocks)
+// ---------------------------------------------------------------------------
+
+import {
+  loadAgentProfiles,
+  buildMentionPattern,
+  resolveAgentFromAlias,
+  resolveDefaultAgent,
+  _resetProfilesCacheForTesting,
+  type AgentProfile,
+} from "./shared-profiles.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const PROFILES_JSON = JSON.stringify({
+  agents: {
+    mal: {
+      label: "Mal",
+      mission: "Product owner",
+      mentionAliases: ["mason", "mal"],
+      appAliases: ["ctclaw"],
+      isDefault: true,
+      avatarUrl: "https://example.com/mal.png",
+    },
+    kaylee: {
+      label: "Kaylee",
+      mission: "Builder",
+      mentionAliases: ["eureka", "kaylee"],
+      avatarUrl: "https://example.com/kaylee.png",
+    },
+    inara: {
+      label: "Inara",
+      mission: "Content",
+      mentionAliases: ["forge", "inara"],
+    },
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  _resetProfilesCacheForTesting();
+  mockReadFileSync.mockReturnValue(PROFILES_JSON);
+});
+
+afterEach(() => {
+  _resetProfilesCacheForTesting();
+});
+
+// ---------------------------------------------------------------------------
+// loadAgentProfiles
+// ---------------------------------------------------------------------------
+
+describe("loadAgentProfiles", () => {
+  it("loads and parses profiles from JSON file", () => {
+    const profiles = loadAgentProfiles();
+
+    expect(profiles).toHaveProperty("mal");
+    expect(profiles).toHaveProperty("kaylee");
+    expect(profiles).toHaveProperty("inara");
+    expect(profiles.mal.label).toBe("Mal");
+    expect(profiles.mal.isDefault).toBe(true);
+  });
+
+  it("caches profiles for 5 seconds", () => {
+    loadAgentProfiles();
+    loadAgentProfiles();
+    loadAgentProfiles();
+
+    // Should only read file once (subsequent calls hit cache)
+    expect(mockReadFileSync).toHaveBeenCalledTimes(1);
+  });
+
+  it("reloads after cache expires", () => {
+    const now = Date.now();
+    vi.spyOn(Date, "now").mockReturnValue(now);
+
+    loadAgentProfiles();
+    expect(mockReadFileSync).toHaveBeenCalledTimes(1);
+
+    // Advance past TTL (5s)
+    vi.spyOn(Date, "now").mockReturnValue(now + 6_000);
+
+    loadAgentProfiles();
+    expect(mockReadFileSync).toHaveBeenCalledTimes(2);
+
+    vi.restoreAllMocks();
+  });
+
+  it("returns empty object when file is missing", () => {
+    mockReadFileSync.mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+
+    const profiles = loadAgentProfiles();
+    expect(profiles).toEqual({});
+  });
+
+  it("returns empty object when JSON is invalid", () => {
+    mockReadFileSync.mockReturnValue("not valid json{{{");
+
+    const profiles = loadAgentProfiles();
+    expect(profiles).toEqual({});
+  });
+
+  it("returns empty object when agents key is missing", () => {
+    mockReadFileSync.mockReturnValue(JSON.stringify({ version: 1 }));
+
+    const profiles = loadAgentProfiles();
+    expect(profiles).toEqual({});
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildMentionPattern
+// ---------------------------------------------------------------------------
+
+describe("buildMentionPattern", () => {
+  it("builds regex matching all mention aliases", () => {
+    const profiles = loadAgentProfiles();
+    const pattern = buildMentionPattern(profiles);
+
+    expect(pattern).not.toBeNull();
+    // Use .match() instead of .test() to avoid global regex lastIndex statefulness
+    expect("@mason".match(pattern!)).not.toBeNull();
+    expect("@mal".match(pattern!)).not.toBeNull();
+    expect("@eureka".match(pattern!)).not.toBeNull();
+    expect("@kaylee".match(pattern!)).not.toBeNull();
+    expect("@forge".match(pattern!)).not.toBeNull();
+    expect("@inara".match(pattern!)).not.toBeNull();
+  });
+
+  it("does NOT match appAliases", () => {
+    const profiles = loadAgentProfiles();
+    const pattern = buildMentionPattern(profiles);
+
+    // appAliases like "ctclaw" should not be in the mention pattern
+    expect("@ctclaw".match(pattern!)).toBeNull();
+  });
+
+  it("is case-insensitive", () => {
+    const profiles = loadAgentProfiles();
+    const pattern = buildMentionPattern(profiles);
+
+    expect("@Mason".match(pattern!)).not.toBeNull();
+    expect("@KAYLEE".match(pattern!)).not.toBeNull();
+  });
+
+  it("returns null when no profiles have aliases", () => {
+    const pattern = buildMentionPattern({});
+    expect(pattern).toBeNull();
+  });
+
+  it("returns null when all aliases are empty arrays", () => {
+    const pattern = buildMentionPattern({
+      agent1: { label: "A", mission: "test", mentionAliases: [] },
+    });
+    expect(pattern).toBeNull();
+  });
+
+  it("escapes regex special chars in aliases", () => {
+    const profiles: Record<string, AgentProfile> = {
+      test: {
+        label: "Test",
+        mission: "test",
+        mentionAliases: ["agent.name", "agent+plus"],
+      },
+    };
+    const pattern = buildMentionPattern(profiles);
+    expect(pattern).not.toBeNull();
+    // Should match literal dot, not "any char"
+    expect(pattern!.test("@agent.name")).toBe(true);
+    expect(pattern!.test("@agentXname")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveAgentFromAlias
+// ---------------------------------------------------------------------------
+
+describe("resolveAgentFromAlias", () => {
+  it("resolves known alias to agent", () => {
+    const profiles = loadAgentProfiles();
+    const result = resolveAgentFromAlias("mason", profiles);
+
+    expect(result).toEqual({ agentId: "mal", label: "Mal" });
+  });
+
+  it("resolves case-insensitively", () => {
+    const profiles = loadAgentProfiles();
+    const result = resolveAgentFromAlias("EUREKA", profiles);
+
+    expect(result).toEqual({ agentId: "kaylee", label: "Kaylee" });
+  });
+
+  it("returns null for unknown alias", () => {
+    const profiles = loadAgentProfiles();
+    const result = resolveAgentFromAlias("wash", profiles);
+
+    expect(result).toBeNull();
+  });
+
+  it("returns null for empty profiles", () => {
+    const result = resolveAgentFromAlias("anything", {});
+    expect(result).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveDefaultAgent
+// ---------------------------------------------------------------------------
+
+describe("resolveDefaultAgent", () => {
+  it("returns defaultAgentId from pluginConfig when set", () => {
+    const api = { pluginConfig: { defaultAgentId: "kaylee" } } as any;
+    const result = resolveDefaultAgent(api);
+    expect(result).toBe("kaylee");
+  });
+
+  it("falls back to isDefault profile when no config", () => {
+    const api = { pluginConfig: {} } as any;
+    const result = resolveDefaultAgent(api);
+    expect(result).toBe("mal");
+  });
+
+  it("returns 'default' when no config and no profiles", () => {
+    mockReadFileSync.mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+
+    const api = { pluginConfig: {} } as any;
+    const result = resolveDefaultAgent(api);
+    expect(result).toBe("default");
+  });
+
+  it("ignores empty string in pluginConfig", () => {
+    const api = { pluginConfig: { defaultAgentId: "" } } as any;
+    const result = resolveDefaultAgent(api);
+    // Should fall through to profile default
+    expect(result).toBe("mal");
+  });
+});

package/src/infra/shared-profiles.ts

@@ -0,0 +1,116 @@
+/**
+ * shared-profiles.ts — Shared agent profile loader with TTL cache.
+ *
+ * Consolidates the duplicate loadAgentProfiles() / buildMentionPattern() /
+ * resolveAgentFromAlias() implementations that were previously in
+ * webhook.ts, intent-classify.ts, and tier-assess.ts.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface AgentProfile {
+  label: string;
+  mission: string;
+  mentionAliases: string[];
+  appAliases?: string[];
+  isDefault?: boolean;
+  avatarUrl?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Cached profile loader (5s TTL)
+// ---------------------------------------------------------------------------
+
+const PROFILES_PATH = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
+
+let profilesCache: { data: Record<string, AgentProfile>; loadedAt: number } | null = null;
+const PROFILES_CACHE_TTL_MS = 5_000;
+
+export function loadAgentProfiles(): Record<string, AgentProfile> {
+  const now = Date.now();
+  if (profilesCache && now - profilesCache.loadedAt < PROFILES_CACHE_TTL_MS) {
+    return profilesCache.data;
+  }
+  try {
+    const raw = readFileSync(PROFILES_PATH, "utf8");
+    const data = JSON.parse(raw).agents ?? {};
+    profilesCache = { data, loadedAt: now };
+    return data;
+  } catch {
+    return {};
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Mention pattern builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a regex that matches @mentions for all agent mentionAliases.
+ * appAliases are excluded — those trigger AgentSessionEvent instead.
+ */
+export function buildMentionPattern(profiles: Record<string, AgentProfile>): RegExp | null {
+  const aliases: string[] = [];
+  for (const [, profile] of Object.entries(profiles)) {
+    aliases.push(...profile.mentionAliases);
+  }
+  if (aliases.length === 0) return null;
+  const escaped = aliases.map(a => a.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`@(${escaped.join("|")})`, "gi");
+}
+
+// ---------------------------------------------------------------------------
+// Agent resolver
+// ---------------------------------------------------------------------------
+
+/**
+ * Given a mention alias string (e.g. "kaylee"), resolve which agent it
+ * belongs to. Returns { agentId, label } or null if no match.
+ */
+export function resolveAgentFromAlias(
+  alias: string,
+  profiles: Record<string, AgentProfile>,
+): { agentId: string; label: string } | null {
+  const lower = alias.toLowerCase();
+  for (const [agentId, profile] of Object.entries(profiles)) {
+    if (profile.mentionAliases.some(a => a.toLowerCase() === lower)) {
+      return { agentId, label: profile.label };
+    }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Default agent resolver (shared helper for intent-classify / tier-assess)
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the default agent ID from plugin config or agent profiles.
+ * Falls back to "default" if nothing is configured.
+ */
+export function resolveDefaultAgent(api: { pluginConfig?: Record<string, unknown> }): string {
+  const fromConfig = (api as any).pluginConfig?.defaultAgentId;
+  if (typeof fromConfig === "string" && fromConfig) return fromConfig;
+
+  try {
+    const raw = readFileSync(PROFILES_PATH, "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";
+}
+
+// ---------------------------------------------------------------------------
+// Test-only: reset cache
+// ---------------------------------------------------------------------------
+
+/** @internal — test-only; clears the profiles cache. */
+export function _resetProfilesCacheForTesting(): void {
+  profilesCache = null;
+}

package/src/infra/template.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { renderTemplate } from "./template.js";
+
+// ---------------------------------------------------------------------------
+// renderTemplate
+// ---------------------------------------------------------------------------
+
+describe("renderTemplate", () => {
+  it("replaces a single variable", () => {
+    const result = renderTemplate("Hello {{name}}!", { name: "World" });
+    expect(result).toBe("Hello World!");
+  });
+
+  it("replaces multiple different variables", () => {
+    const template = "Issue {{identifier}}: {{title}} ({{status}})";
+    const result = renderTemplate(template, {
+      identifier: "ENG-123",
+      title: "Fix bug",
+      status: "In Progress",
+    });
+    expect(result).toBe("Issue ENG-123: Fix bug (In Progress)");
+  });
+
+  it("replaces all occurrences of the same variable", () => {
+    const template = "{{name}} said hello to {{name}}";
+    const result = renderTemplate(template, { name: "Alice" });
+    expect(result).toBe("Alice said hello to Alice");
+  });
+
+  it("leaves unmatched placeholders intact", () => {
+    const result = renderTemplate("Hello {{name}} and {{other}}", { name: "World" });
+    expect(result).toBe("Hello World and {{other}}");
+  });
+
+  it("handles empty vars object", () => {
+    const result = renderTemplate("Hello {{name}}!", {});
+    expect(result).toBe("Hello {{name}}!");
+  });
+
+  it("replaces with empty string when value is empty", () => {
+    const result = renderTemplate("Hello {{name}}!", { name: "" });
+    expect(result).toBe("Hello !");
+  });
+
+  it("handles template with no placeholders", () => {
+    const result = renderTemplate("No variables here", { name: "World" });
+    expect(result).toBe("No variables here");
+  });
+
+  it("handles empty template", () => {
+    const result = renderTemplate("", { name: "World" });
+    expect(result).toBe("");
+  });
+
+  it("handles null/undefined values gracefully", () => {
+    const result = renderTemplate("Value: {{key}}", { key: undefined as unknown as string });
+    expect(result).toBe("Value: ");
+  });
+
+  it("works with multiline templates", () => {
+    const template = "Issue: {{identifier}}\nTitle: {{title}}\nWorktree: {{worktreePath}}";
+    const result = renderTemplate(template, {
+      identifier: "CT-42",
+      title: "Implement auth",
+      worktreePath: "/home/claw/worktrees/ct-42",
+    });
+    expect(result).toBe("Issue: CT-42\nTitle: Implement auth\nWorktree: /home/claw/worktrees/ct-42");
+  });
+
+  it("handles special regex characters in values", () => {
+    // Note: replaceAll treats $$ as an escape for a literal $ in the replacement.
+    // This is standard JS behavior (not a bug). Values with $ may be altered.
+    const result = renderTemplate("Pattern: {{pattern}}", {
+      pattern: "hello.world+test",
+    });
+    expect(result).toBe("Pattern: hello.world+test");
+  });
+
+  it("handles variables with numeric values as strings", () => {
+    const result = renderTemplate("Attempt {{attempt}} of {{max}}", {
+      attempt: "3",
+      max: "5",
+    });
+    expect(result).toBe("Attempt 3 of 5");
+  });
+});

package/src/infra/template.ts

@@ -0,0 +1,18 @@
+/**
+ * template.ts — Shared template renderer for {{key}} interpolation.
+ *
+ * Used by pipeline.ts and planner.ts to render prompt templates with
+ * issue context variables.
+ */
+
+/**
+ * Replaces all {{key}} occurrences in `template` with corresponding values
+ * from `vars`. Missing keys are replaced with empty string.
+ */
+export function renderTemplate(template: string, vars: Record<string, string>): string {
+  let result = template;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value ?? "");
+  }
+  return result;
+}

package/src/infra/validation.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect } from "vitest";
+import {
+  isValidIssueId,
+  isValidUuid,
+  isValidTeamId,
+  sanitizeForPrompt,
+} from "./validation.js";
+
+// ---------------------------------------------------------------------------
+// isValidUuid
+// ---------------------------------------------------------------------------
+
+describe("isValidUuid", () => {
+  it("accepts valid lowercase UUID", () => {
+    expect(isValidUuid("08cba264-d774-4afd-bc93-ee8213d12ef8")).toBe(true);
+  });
+
+  it("accepts valid uppercase UUID", () => {
+    expect(isValidUuid("08CBA264-D774-4AFD-BC93-EE8213D12EF8")).toBe(true);
+  });
+
+  it("accepts mixed-case UUID", () => {
+    expect(isValidUuid("08CbA264-d774-4aFd-Bc93-ee8213D12ef8")).toBe(true);
+  });
+
+  it("rejects short string", () => {
+    expect(isValidUuid("abc-123")).toBe(false);
+  });
+
+  it("rejects empty string", () => {
+    expect(isValidUuid("")).toBe(false);
+  });
+
+  it("rejects UUID without dashes", () => {
+    expect(isValidUuid("08cba264d7744afdbc93ee8213d12ef8")).toBe(false);
+  });
+
+  it("rejects UUID with extra chars", () => {
+    expect(isValidUuid("08cba264-d774-4afd-bc93-ee8213d12ef8x")).toBe(false);
+  });
+
+  it("rejects non-hex characters", () => {
+    expect(isValidUuid("08cba264-d774-4afd-bc93-ee8213d12xyz")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isValidIssueId
+// ---------------------------------------------------------------------------
+
+describe("isValidIssueId", () => {
+  it("accepts standard Linear identifier like ENG-123", () => {
+    expect(isValidIssueId("ENG-123")).toBe(true);
+  });
+
+  it("accepts lowercase Linear identifier like eng-456", () => {
+    expect(isValidIssueId("eng-456")).toBe(true);
+  });
+
+  it("accepts single-letter prefix like A-1", () => {
+    expect(isValidIssueId("A-1")).toBe(true);
+  });
+
+  it("accepts long prefix like PROJECT-99999", () => {
+    expect(isValidIssueId("PROJECT-99999")).toBe(true);
+  });
+
+  it("accepts valid UUID", () => {
+    expect(isValidIssueId("08cba264-d774-4afd-bc93-ee8213d12ef8")).toBe(true);
+  });
+
+  it("rejects empty string", () => {
+    expect(isValidIssueId("")).toBe(false);
+  });
+
+  it("rejects plain number", () => {
+    expect(isValidIssueId("12345")).toBe(false);
+  });
+
+  it("rejects string with spaces", () => {
+    expect(isValidIssueId("ENG 123")).toBe(false);
+  });
+
+  it("rejects identifier starting with number", () => {
+    expect(isValidIssueId("123-ABC")).toBe(false);
+  });
+
+  it("rejects identifier with only prefix (no number)", () => {
+    expect(isValidIssueId("ENG-")).toBe(false);
+  });
+
+  it("rejects identifier with only number (no prefix)", () => {
+    expect(isValidIssueId("-123")).toBe(false);
+  });
+
+  it("rejects random text", () => {
+    expect(isValidIssueId("not an issue id")).toBe(false);
+  });
+
+  it("rejects identifier with special chars", () => {
+    expect(isValidIssueId("ENG-123!")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isValidTeamId
+// ---------------------------------------------------------------------------
+
+describe("isValidTeamId", () => {
+  it("accepts valid UUID", () => {
+    expect(isValidTeamId("08cba264-d774-4afd-bc93-ee8213d12ef8")).toBe(true);
+  });
+
+  it("rejects non-UUID", () => {
+    expect(isValidTeamId("team-1")).toBe(false);
+  });
+
+  it("rejects empty string", () => {
+    expect(isValidTeamId("")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// sanitizeForPrompt
+// ---------------------------------------------------------------------------
+
+describe("sanitizeForPrompt", () => {
+  it("escapes template variables", () => {
+    const result = sanitizeForPrompt("Hello {{name}} world");
+    expect(result).toBe("Hello { {escaped} } world");
+  });
+
+  it("escapes multiple template variables", () => {
+    const result = sanitizeForPrompt("{{a}} and {{b}} and {{c}}");
+    expect(result).toBe("{ {escaped} } and { {escaped} } and { {escaped} }");
+  });
+
+  it("truncates to maxLength", () => {
+    const long = "x".repeat(5000);
+    const result = sanitizeForPrompt(long, 100);
+    expect(result.length).toBe(100);
+  });
+
+  it("uses default maxLength of 4000", () => {
+    const long = "x".repeat(5000);
+    const result = sanitizeForPrompt(long);
+    expect(result.length).toBe(4000);
+  });
+
+  it("returns text unchanged when no templates and under limit", () => {
+    const result = sanitizeForPrompt("Normal text with no templates");
+    expect(result).toBe("Normal text with no templates");
+  });
+
+  it("handles empty string", () => {
+    const result = sanitizeForPrompt("");
+    expect(result).toBe("");
+  });
+
+  it("escapes before truncating (template at boundary)", () => {
+    // Template at position that would be cut
+    const text = "x".repeat(3998) + "{{y}}";
+    const result = sanitizeForPrompt(text, 4000);
+    // After escaping {{y}} → { {escaped} }, string becomes longer,
+    // then truncation to 4000 chars applies
+    expect(result.length).toBe(4000);
+    expect(result).not.toContain("{{");
+  });
+
+  it("handles nested-looking braces", () => {
+    const result = sanitizeForPrompt("{{{{deep}}}}");
+    // The outer {{...}} matches "{{deep}}" first, inner {{ and }} are left
+    expect(result).not.toContain("{{deep}}");
+  });
+});