@calltelemetry/openclaw-linear 0.9.14 → 0.9.16

package/src/infra/multi-repo.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { homedir } from "node:os";
 import path from "node:path";
-import { resolveRepos, isMultiRepo, validateRepoPath, type RepoResolution } from "./multi-repo.ts";
+import { resolveRepos, isMultiRepo, validateRepoPath, getRepoEntries, buildCandidateRepositories, type RepoResolution } from "./multi-repo.ts";
 
 vi.mock("node:fs", async (importOriginal) => {
   const actual = await importOriginal<typeof import("node:fs")>();
@@ -131,6 +131,132 @@ describe("isMultiRepo", () => {
   });
 });
 
+describe("getRepoEntries", () => {
+  it("normalizes string values to RepoEntry objects", () => {
+    const config = { repos: { api: "/tmp/api", frontend: "/tmp/frontend" } };
+    const entries = getRepoEntries(config);
+    expect(entries.api).toEqual({ path: "/tmp/api" });
+    expect(entries.frontend).toEqual({ path: "/tmp/frontend" });
+  });
+
+  it("passes through object values with github and hostname", () => {
+    const config = {
+      repos: {
+        api: { path: "/tmp/api", github: "org/api", hostname: "github.example.com" },
+        frontend: { path: "/tmp/frontend", github: "org/frontend" },
+      },
+    };
+    const entries = getRepoEntries(config);
+    expect(entries.api).toEqual({ path: "/tmp/api", github: "org/api", hostname: "github.example.com" });
+    expect(entries.frontend).toEqual({ path: "/tmp/frontend", github: "org/frontend", hostname: undefined });
+  });
+
+  it("handles mixed string and object repos", () => {
+    const config = {
+      repos: {
+        api: { path: "/tmp/api", github: "org/api" },
+        legacy: "/tmp/legacy",
+      },
+    };
+    const entries = getRepoEntries(config);
+    expect(entries.api.github).toBe("org/api");
+    expect(entries.legacy).toEqual({ path: "/tmp/legacy" });
+  });
+
+  it("returns empty object when no repos config", () => {
+    expect(getRepoEntries({})).toEqual({});
+    expect(getRepoEntries(undefined)).toEqual({});
+  });
+});
+
+describe("buildCandidateRepositories", () => {
+  it("builds candidates from repos with github field", () => {
+    const config = {
+      repos: {
+        api: { path: "/tmp/api", github: "calltelemetry/cisco-cdr" },
+        frontend: { path: "/tmp/frontend", github: "calltelemetry/ct-quasar" },
+        legacy: "/tmp/legacy",
+      },
+    };
+    const candidates = buildCandidateRepositories(config);
+    expect(candidates).toHaveLength(2);
+    expect(candidates[0]).toEqual({ hostname: "github.com", repositoryFullName: "calltelemetry/cisco-cdr" });
+    expect(candidates[1]).toEqual({ hostname: "github.com", repositoryFullName: "calltelemetry/ct-quasar" });
+  });
+
+  it("uses custom hostname when provided", () => {
+    const config = {
+      repos: {
+        api: { path: "/tmp/api", github: "org/api", hostname: "git.corp.com" },
+      },
+    };
+    const candidates = buildCandidateRepositories(config);
+    expect(candidates[0].hostname).toBe("git.corp.com");
+  });
+
+  it("returns empty array when no repos have github", () => {
+    const config = { repos: { api: "/tmp/api" } };
+    expect(buildCandidateRepositories(config)).toEqual([]);
+  });
+});
+
+describe("resolveRepos with team mapping", () => {
+  const config = {
+    repos: {
+      api: { path: "/tmp/api", github: "org/api" },
+      frontend: { path: "/tmp/frontend", github: "org/frontend" },
+    },
+    teamMappings: {
+      API: { repos: ["api"], defaultAgent: "kaylee" },
+      UAT: { repos: ["api", "frontend"] },
+      MED: { context: "Media team" },
+    },
+  };
+
+  it("uses team mapping when no body markers or labels", () => {
+    const result = resolveRepos("Plain description", [], config, "API");
+    expect(result.source).toBe("team_mapping");
+    expect(result.repos).toHaveLength(1);
+    expect(result.repos[0].name).toBe("api");
+    expect(result.repos[0].path).toBe("/tmp/api");
+  });
+
+  it("team mapping resolves multi-repo teams", () => {
+    const result = resolveRepos("Plain description", [], config, "UAT");
+    expect(result.source).toBe("team_mapping");
+    expect(result.repos).toHaveLength(2);
+    expect(result.repos[0].name).toBe("api");
+    expect(result.repos[1].name).toBe("frontend");
+  });
+
+  it("body markers take priority over team mapping", () => {
+    const result = resolveRepos("<!-- repos: frontend -->", [], config, "API");
+    expect(result.source).toBe("issue_body");
+    expect(result.repos[0].name).toBe("frontend");
+  });
+
+  it("labels take priority over team mapping", () => {
+    const result = resolveRepos("No markers", ["repo:frontend"], config, "API");
+    expect(result.source).toBe("labels");
+    expect(result.repos[0].name).toBe("frontend");
+  });
+
+  it("falls back to config_default when team has no repos", () => {
+    const result = resolveRepos("Plain description", [], config, "MED");
+    expect(result.source).toBe("config_default");
+  });
+
+  it("falls back to config_default when teamKey is unknown", () => {
+    const result = resolveRepos("Plain description", [], config, "UNKNOWN");
+    expect(result.source).toBe("config_default");
+  });
+
+  it("falls back to config_default when no teamKey provided", () => {
+    const result = resolveRepos("Plain description", [], config);
+    expect(result.source).toBe("config_default");
+  });
+});
+
 describe("validateRepoPath", () => {
   beforeEach(() => {
     vi.restoreAllMocks();

package/src/infra/multi-repo.ts

@@ -1,10 +1,11 @@
 /**
  * multi-repo.ts — Multi-repo resolution for dispatches spanning multiple git repos.
  *
- * Three-tier resolution:
+ * Four-tier resolution:
  * 1. Issue body markers: <!-- repos: api, frontend --> or [repos: api, frontend]
  * 2. Linear labels: repo:api, repo:frontend
- * 3. Config default: Falls back to single codexBaseRepo
+ * 3. Team mapping: teamMappings[teamKey].repos from plugin config
+ * 4. Config default: Falls back to single codexBaseRepo
  */
 
 import { existsSync, statSync } from "node:fs";
@@ -18,7 +19,55 @@ export interface RepoConfig {
 
 export interface RepoResolution {
   repos: RepoConfig[];
-  source: "issue_body" | "labels" | "config_default";
+  source: "issue_body" | "labels" | "team_mapping" | "config_default";
+}
+
+/**
+ * Enriched repo entry — filesystem path + optional GitHub identity.
+ * Supports both plain string paths (backward compat) and objects.
+ */
+export interface RepoEntry {
+  path: string;
+  github?: string;      // "owner/repo" format
+  hostname?: string;    // defaults to "github.com"
+}
+
+/**
+ * Parse the repos config, normalizing both string and object formats.
+ * String values become { path: value }, objects pass through.
+ */
+export function getRepoEntries(pluginConfig?: Record<string, unknown>): Record<string, RepoEntry> {
+  const repos = pluginConfig?.repos as Record<string, string | Record<string, unknown>> | undefined;
+  if (!repos) return {};
+  const result: Record<string, RepoEntry> = {};
+  for (const [name, value] of Object.entries(repos)) {
+    if (typeof value === "string") {
+      result[name] = { path: value };
+    } else if (value && typeof value === "object") {
+      result[name] = {
+        path: (value as any).path as string,
+        github: (value as any).github as string | undefined,
+        hostname: (value as any).hostname as string | undefined,
+      };
+    }
+  }
+  return result;
+}
+
+/**
+ * Build candidate repositories for Linear's issueRepositorySuggestions API.
+ * Extracts GitHub identity from enriched repo entries.
+ */
+export function buildCandidateRepositories(
+  pluginConfig?: Record<string, unknown>,
+): Array<{ hostname: string; repositoryFullName: string }> {
+  const entries = getRepoEntries(pluginConfig);
+  return Object.values(entries)
+    .filter(e => e.github)
+    .map(e => ({
+      hostname: e.hostname ?? "github.com",
+      repositoryFullName: e.github!,
+    }));
 }
 
 /**
@@ -28,6 +77,7 @@ export function resolveRepos(
   description: string | null | undefined,
   labels: string[],
   pluginConfig?: Record<string, unknown>,
+  teamKey?: string,
 ): RepoResolution {
   // 1. Check issue body for repo markers
   // Match: <!-- repos: name1, name2 --> or [repos: name1, name2]
@@ -62,7 +112,21 @@ export function resolveRepos(
     return { repos, source: "labels" };
   }
 
-  // 3. Config default: single repo
+  // 3. Team mapping: teamMappings[teamKey].repos
+  if (teamKey) {
+    const teamMappings = pluginConfig?.teamMappings as Record<string, Record<string, unknown>> | undefined;
+    const teamRepoNames = teamMappings?.[teamKey]?.repos as string[] | undefined;
+    if (teamRepoNames && teamRepoNames.length > 0) {
+      const repoMap = getRepoMap(pluginConfig);
+      const repos = teamRepoNames.map(name => ({
+        name,
+        path: repoMap[name] ?? resolveRepoPath(name, pluginConfig),
+      }));
+      return { repos, source: "team_mapping" };
+    }
+  }
+
+  // 4. Config default: single repo
   const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? path.join(homedir(), "ai-workspace");
   return {
     repos: [{ name: "default", path: baseRepo }],
@@ -71,8 +135,12 @@ export function resolveRepos(
 }
 
 function getRepoMap(pluginConfig?: Record<string, unknown>): Record<string, string> {
-  const repos = pluginConfig?.repos as Record<string, string> | undefined;
-  return repos ?? {};
+  const entries = getRepoEntries(pluginConfig);
+  const result: Record<string, string> = {};
+  for (const [name, entry] of Object.entries(entries)) {
+    result[name] = entry.path;
+  }
+  return result;
 }
 
 function resolveRepoPath(name: string, pluginConfig?: Record<string, unknown>): string {