@calltelemetry/openclaw-linear 0.7.0 → 0.8.0

package/src/infra/cli.ts

@@ -5,11 +5,11 @@ import type { Command } from "commander";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { createInterface } from "node:readline";
 import { exec } from "node:child_process";
-import { readFileSync, writeFileSync } from "node:fs";
-import { readFileSync as readFileSyncFs, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { resolveLinearToken, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "../api/linear-api.js";
+import { resolveLinearToken, LinearAgentApi, AUTH_PROFILES_PATH, LINEAR_GRAPHQL_URL } from "../api/linear-api.js";
+import { validateRepoPath } from "./multi-repo.js";
 import { LINEAR_OAUTH_AUTH_URL, LINEAR_OAUTH_TOKEN_URL, LINEAR_AGENT_SCOPES } from "../api/auth.js";
 import { listWorktrees } from "./codex-worktree.js";
 import { loadPrompts, clearPromptCache } from "../pipeline/pipeline.js";
@@ -251,6 +251,25 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
       console.log(`\nTo remove one: openclaw openclaw-linear worktrees --prune <path>\n`);
     });
 
+  // --- openclaw openclaw-linear repos ---
+  const repos = linear
+    .command("repos")
+    .description("Validate multi-repo config and sync labels to Linear");
+
+  repos
+    .command("check")
+    .description("Validate repo paths and show what labels would be created (dry run)")
+    .action(async () => {
+      await reposAction(api, { dryRun: true });
+    });
+
+  repos
+    .command("sync")
+    .description("Create missing repo: labels in Linear from your repos config")
+    .action(async () => {
+      await reposAction(api, { dryRun: false });
+    });
+
   // --- openclaw openclaw-linear prompts ---
   const prompts = linear
     .command("prompts")
@@ -258,33 +277,21 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
 
   prompts
     .command("show")
-    .description("Print current prompts.yaml content")
-    .action(async () => {
+    .description("Print resolved prompts (global or per-project)")
+    .option("--worktree <path>", "Show merged prompts for a specific worktree")
+    .action(async (opts: { worktree?: string }) => {
       const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
-      const customPath = pluginConfig?.promptsPath as string | undefined;
+      clearPromptCache();
+      const loaded = loadPrompts(pluginConfig, opts.worktree);
 
-      let resolvedPath: string;
-      if (customPath) {
-        resolvedPath = customPath.startsWith("~")
-          ? customPath.replace("~", process.env.HOME ?? "")
-          : customPath;
+      if (opts.worktree) {
+        console.log(`\nResolved prompts for worktree: ${opts.worktree}\n`);
       } else {
-        const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), "../..");
-        resolvedPath = join(pluginRoot, "prompts.yaml");
+        console.log(`\nGlobal resolved prompts\n`);
       }
 
-      console.log(`\nPrompts file: ${resolvedPath}\n`);
-
-      try {
-        const content = readFileSyncFs(resolvedPath, "utf-8");
-        console.log(content);
-      } catch {
-        console.log("(file not found — using built-in defaults)\n");
-        // Show the loaded defaults
-        clearPromptCache();
-        const loaded = loadPrompts(pluginConfig);
-        console.log(JSON.stringify(loaded, null, 2));
-      }
+      console.log(JSON.stringify(loaded, null, 2));
+      console.log();
     });
 
   prompts
@@ -310,13 +317,14 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
 
   prompts
     .command("validate")
-    .description("Validate prompts.yaml structure")
-    .action(async () => {
+    .description("Validate prompts.yaml structure (global or per-project)")
+    .option("--worktree <path>", "Validate merged prompts for a specific worktree")
+    .action(async (opts: { worktree?: string }) => {
       const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
       clearPromptCache();
 
       try {
-        const loaded = loadPrompts(pluginConfig);
+        const loaded = loadPrompts(pluginConfig, opts.worktree);
         const errors: string[] = [];
 
         if (!loaded.worker?.system) errors.push("Missing worker.system");
@@ -336,13 +344,14 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
           }
         }
 
+        const label = opts.worktree ? `worktree ${opts.worktree}` : "global";
         if (errors.length > 0) {
-          console.log("\nValidation FAILED:\n");
+          console.log(`\nValidation FAILED (${label}):\n`);
           for (const e of errors) console.log(`  - ${e}`);
           console.log();
           process.exitCode = 1;
         } else {
-          console.log("\nValidation PASSED — all sections and template variables present.\n");
+          console.log(`\nValidation PASSED (${label}) — all sections and template variables present.\n`);
         }
       } catch (err) {
         console.error(`\nFailed to load prompts: ${err}\n`);
@@ -350,6 +359,85 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
       }
     });
 
+  prompts
+    .command("init")
+    .description("Scaffold per-project .claw/prompts.yaml in a worktree")
+    .argument("<worktree-path>", "Path to the worktree")
+    .action(async (worktreePath: string) => {
+      const { mkdirSync, writeFileSync: writeFS } = await import("node:fs");
+      const clawDir = join(worktreePath, ".claw");
+      const promptsFile = join(clawDir, "prompts.yaml");
+
+      if (existsSync(promptsFile)) {
+        console.log(`\n  ${promptsFile} already exists.\n`);
+        return;
+      }
+
+      mkdirSync(clawDir, { recursive: true });
+      writeFS(promptsFile, [
+        "# Per-project prompt overrides for Linear Agent pipeline.",
+        "# Only include sections/fields you want to override.",
+        "# Unspecified fields inherit from the global prompts.yaml.",
+        "#",
+        "# Available sections: worker, audit, rework",
+        "# Template variables: {{identifier}}, {{title}}, {{description}}, {{worktreePath}}, {{tier}}, {{attempt}}, {{gaps}}",
+        "",
+        "# worker:",
+        "#   system: \"Custom system prompt for workers in this project.\"",
+        "#   task: \"Implement issue {{identifier}}: {{title}}\\n\\n{{description}}\\n\\nWorktree: {{worktreePath}}\"",
+        "",
+        "# audit:",
+        "#   system: \"Custom audit system prompt for this project.\"",
+        "",
+        "# rework:",
+        "#   addendum: \"Custom rework addendum for this project.\"",
+        "",
+      ].join("\n"), "utf-8");
+
+      console.log(`\n  Created: ${promptsFile}`);
+      console.log(`  Edit this file to customize prompts for this worktree.\n`);
+    });
+
+  prompts
+    .command("diff")
+    .description("Show differences between global and per-project prompts")
+    .argument("<worktree-path>", "Path to the worktree")
+    .action(async (worktreePath: string) => {
+      const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+      clearPromptCache();
+
+      const global = loadPrompts(pluginConfig);
+      const merged = loadPrompts(pluginConfig, worktreePath);
+
+      const projectFile = join(worktreePath, ".claw", "prompts.yaml");
+      if (!existsSync(projectFile)) {
+        console.log(`\n  No per-project prompts at ${projectFile}`);
+        console.log(`  Run 'openclaw openclaw-linear prompts init ${worktreePath}' to create one.\n`);
+        return;
+      }
+
+      console.log(`\nPrompt diff: global vs ${worktreePath}\n`);
+
+      let hasDiffs = false;
+      for (const section of ["worker", "audit", "rework"] as const) {
+        const globalSection = global[section] as Record<string, string>;
+        const mergedSection = merged[section] as Record<string, string>;
+        for (const [key, val] of Object.entries(mergedSection)) {
+          if (globalSection[key] !== val) {
+            hasDiffs = true;
+            console.log(`  ${section}.${key}:`);
+            console.log(`    global:  ${globalSection[key]?.slice(0, 100)}...`);
+            console.log(`    project: ${val.slice(0, 100)}...`);
+            console.log();
+          }
+        }
+      }
+
+      if (!hasDiffs) {
+        console.log("  No differences — per-project prompts match global.\n");
+      }
+    });
+
   // --- openclaw openclaw-linear notify ---
   const notifyCmd = linear
     .command("notify")
@@ -557,3 +645,158 @@ export function registerCli(program: Command, api: OpenClawPluginApi): void {
       }
     });
 }
+
+// ---------------------------------------------------------------------------
+// repos sync / check helper
+// ---------------------------------------------------------------------------
+
+const REPO_LABEL_COLOR = "#5e6ad2"; // Linear indigo
+
+async function reposAction(
+  api: OpenClawPluginApi,
+  opts: { dryRun: boolean },
+): Promise<void> {
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const reposMap = (pluginConfig?.repos as Record<string, string> | undefined) ?? {};
+  const repoNames = Object.keys(reposMap);
+
+  const mode = opts.dryRun ? "Repos Check" : "Repos Sync";
+  console.log(`\n${mode}`);
+  console.log("─".repeat(40));
+
+  // 1. Validate config
+  if (repoNames.length === 0) {
+    console.log(`\n  No "repos" configured in plugin config.`);
+    console.log(`  Add a repos map to openclaw.json → plugins.entries.openclaw-linear.config:`);
+    console.log(`\n    "repos": {`);
+    console.log(`      "api": "/home/claw/repos/api",`);
+    console.log(`      "frontend": "/home/claw/repos/frontend"`);
+    console.log(`    }\n`);
+    return;
+  }
+
+  // 2. Validate each repo path
+  console.log("\n  Repos from config:");
+  const warnings: string[] = [];
+
+  for (const name of repoNames) {
+    const repoPath = reposMap[name];
+    const status = validateRepoPath(repoPath);
+    const pad = name.padEnd(16);
+
+    if (!status.exists) {
+      console.log(`  \u2717 ${pad} ${repoPath} (path not found)`);
+      warnings.push(`"${name}" at ${repoPath} does not exist`);
+    } else if (!status.isGitRepo) {
+      console.log(`  \u2717 ${pad} ${repoPath} (not a git repo)`);
+      warnings.push(`"${name}" at ${repoPath} is not a git repository`);
+    } else if (status.isSubmodule) {
+      console.log(`  \u26a0 ${pad} ${repoPath} (submodule)`);
+      warnings.push(`"${name}" at ${repoPath} is a git submodule`);
+    } else {
+      console.log(`  \u2714 ${pad} ${repoPath} (git repo)`);
+    }
+  }
+
+  // 3. Connect to Linear
+  const tokenInfo = resolveLinearToken(pluginConfig);
+  if (!tokenInfo.accessToken) {
+    console.log(`\n  No Linear token found. Run "openclaw openclaw-linear auth" first.\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const linearApi = new LinearAgentApi(tokenInfo.accessToken, {
+    refreshToken: tokenInfo.refreshToken,
+    expiresAt: tokenInfo.expiresAt,
+    clientId: pluginConfig?.clientId as string | undefined,
+    clientSecret: pluginConfig?.clientSecret as string | undefined,
+  });
+
+  // 4. Get teams
+  let teams: Array<{ id: string; name: string; key: string }>;
+  try {
+    teams = await linearApi.getTeams();
+  } catch (err) {
+    console.log(`\n  Failed to fetch teams: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (teams.length === 0) {
+    console.log(`\n  No teams found in your Linear workspace.\n`);
+    return;
+  }
+
+  // 5. Sync labels per team
+  let totalCreated = 0;
+  let totalExisted = 0;
+
+  for (const team of teams) {
+    console.log(`\n  Team: ${team.name} (${team.key})`);
+
+    let existingLabels: Array<{ id: string; name: string }>;
+    try {
+      existingLabels = await linearApi.getTeamLabels(team.id);
+    } catch (err) {
+      console.log(`    Failed to fetch labels: ${err instanceof Error ? err.message : String(err)}`);
+      continue;
+    }
+
+    const existingNames = new Set(existingLabels.map(l => l.name.toLowerCase()));
+
+    for (const name of repoNames) {
+      const labelName = `repo:${name}`;
+
+      if (existingNames.has(labelName.toLowerCase())) {
+        console.log(`  \u2714 ${labelName.padEnd(24)} already exists`);
+        totalExisted++;
+      } else if (opts.dryRun) {
+        console.log(`  + ${labelName.padEnd(24)} would be created`);
+      } else {
+        try {
+          await linearApi.createLabel(team.id, labelName, {
+            color: REPO_LABEL_COLOR,
+            description: `Multi-repo dispatch: ${name}`,
+          });
+          console.log(`  + ${labelName.padEnd(24)} created`);
+          totalCreated++;
+        } catch (err) {
+          console.log(`  \u2717 ${labelName.padEnd(24)} failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    }
+  }
+
+  // 6. Summary
+  if (opts.dryRun) {
+    const wouldCreate = repoNames.length * teams.length - totalExisted;
+    console.log(`\n  Dry run: ${wouldCreate} label(s) would be created, ${totalExisted} already exist`);
+  } else {
+    console.log(`\n  Summary: ${totalCreated} created, ${totalExisted} already existed`);
+  }
+
+  // 7. Submodule warnings
+  const submoduleWarnings = warnings.filter(w => w.includes("submodule"));
+  if (submoduleWarnings.length > 0) {
+    console.log(`\n  \u26a0 Submodule warning:`);
+    for (const w of submoduleWarnings) {
+      console.log(`    ${w}`);
+    }
+    console.log(`    Multi-repo dispatch uses "git worktree add" which doesn't work on submodules.`);
+    console.log(`    Options:`);
+    console.log(`    1. Clone the repo as a standalone repo instead`);
+    console.log(`    2. Remove it from "repos" config and use the parent repo as codexBaseRepo`);
+  }
+
+  // Other warnings
+  const otherWarnings = warnings.filter(w => !w.includes("submodule"));
+  if (otherWarnings.length > 0) {
+    console.log(`\n  Warnings:`);
+    for (const w of otherWarnings) {
+      console.log(`    \u26a0 ${w}`);
+    }
+  }
+
+  console.log();
+}

package/src/infra/codex-worktree.ts

@@ -3,6 +3,7 @@ import { existsSync, statSync, readdirSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { ensureGitignore } from "../pipeline/artifacts.js";
+import type { RepoConfig } from "./multi-repo.js";
 
 const DEFAULT_BASE_REPO = "/home/claw/ai-workspace";
 const DEFAULT_WORKTREE_BASE_DIR = path.join(homedir(), ".openclaw", "worktrees");
@@ -117,6 +118,88 @@ export function createWorktree(
   return { path: worktreePath, branch, resumed: false };
 }
 
+export interface MultiWorktreeResult {
+  /** Parent directory containing all repo worktrees for this issue. */
+  parentPath: string;
+  worktrees: Array<{
+    repoName: string;
+    path: string;
+    branch: string;
+    resumed: boolean;
+  }>;
+}
+
+/**
+ * Create worktrees for multiple repos.
+ *
+ * Layout: {baseDir}/{issueIdentifier}/{repoName}/
+ * Branch: codex/{issueIdentifier} (same branch name in each repo)
+ *
+ * Each individual repo worktree follows the same idempotent/resume logic
+ * as createWorktree: if the worktree or branch already exists, it resumes.
+ */
+export function createMultiWorktree(
+  identifier: string,
+  repos: RepoConfig[],
+  opts?: { baseDir?: string },
+): MultiWorktreeResult {
+  const baseDir = resolveBaseDir(opts?.baseDir);
+  const parentPath = path.join(baseDir, identifier);
+
+  // Ensure parent directory exists
+  if (!existsSync(parentPath)) {
+    mkdirSync(parentPath, { recursive: true });
+  }
+
+  const branch = `codex/${identifier}`;
+  const worktrees: MultiWorktreeResult["worktrees"] = [];
+
+  for (const repo of repos) {
+    if (!existsSync(repo.path)) {
+      throw new Error(`Repo not found: ${repo.name} at ${repo.path}`);
+    }
+
+    const worktreePath = path.join(parentPath, repo.name);
+
+    // Fetch latest from origin (best effort)
+    try {
+      git(["fetch", "origin"], repo.path);
+    } catch {
+      // Offline or no remote — continue with local state
+    }
+
+    // Idempotent: if worktree already exists, resume it
+    if (existsSync(worktreePath)) {
+      try {
+        git(["rev-parse", "--git-dir"], worktreePath);
+        ensureGitignore(worktreePath);
+        worktrees.push({ repoName: repo.name, path: worktreePath, branch, resumed: true });
+        continue;
+      } catch {
+        // Directory exists but isn't a valid worktree — remove and recreate
+        try {
+          git(["worktree", "remove", "--force", worktreePath], repo.path);
+        } catch { /* best effort */ }
+      }
+    }
+
+    // Check if branch already exists (resume scenario)
+    const exists = branchExistsInRepo(branch, repo.path);
+
+    if (exists) {
+      git(["worktree", "add", worktreePath, branch], repo.path);
+      ensureGitignore(worktreePath);
+      worktrees.push({ repoName: repo.name, path: worktreePath, branch, resumed: true });
+    } else {
+      git(["worktree", "add", "-b", branch, worktreePath], repo.path);
+      ensureGitignore(worktreePath);
+      worktrees.push({ repoName: repo.name, path: worktreePath, branch, resumed: false });
+    }
+  }
+
+  return { parentPath, worktrees };
+}
+
 /**
  * Check if a branch exists in the repo.
  */