@calltelemetry/openclaw-linear 0.3.0 → 0.4.0

package/src/codex-worktree.ts

@@ -0,0 +1,264 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, statSync, readdirSync } from "node:fs";
+
+const DEFAULT_BASE_REPO = "/home/claw/ai-workspace";
+
+export interface WorktreeInfo {
+  path: string;
+  branch: string;
+}
+
+export interface WorktreeStatus {
+  filesChanged: string[];
+  hasUncommitted: boolean;
+  lastCommit: string | null;
+}
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 30_000,
+  }).trim();
+}
+
+/**
+ * Create a git worktree for isolated Codex work.
+ * Branch: codex/{issueIdentifier}
+ * Path: /tmp/codex-{issueIdentifier}-{timestamp}
+ */
+export function createWorktree(
+  issueIdentifier: string,
+  baseRepo?: string,
+): WorktreeInfo {
+  const repo = baseRepo ?? DEFAULT_BASE_REPO;
+  if (!existsSync(repo)) {
+    throw new Error(`Base repo not found: ${repo}`);
+  }
+
+  const branch = `codex/${issueIdentifier}`;
+  const ts = Date.now();
+  const worktreePath = `/tmp/codex-${issueIdentifier}-${ts}`;
+
+  // Ensure we're on a clean base — fetch latest
+  try {
+    git(["fetch", "origin"], repo);
+  } catch {
+    // Offline or no remote — continue with local state
+  }
+
+  // Delete stale branch if it exists (from a previous run)
+  try {
+    git(["branch", "-D", branch], repo);
+  } catch {
+    // Branch doesn't exist — fine
+  }
+
+  // Create worktree with new branch off HEAD
+  git(["worktree", "add", "-b", branch, worktreePath], repo);
+
+  return { path: worktreePath, branch };
+}
+
+/**
+ * Get the status of a worktree: changed files, uncommitted work, last commit.
+ */
+export function getWorktreeStatus(worktreePath: string): WorktreeStatus {
+  if (!existsSync(worktreePath)) {
+    return { filesChanged: [], hasUncommitted: false, lastCommit: null };
+  }
+
+  const diffOutput = git(
+    ["diff", "--name-only", "HEAD"],
+    worktreePath,
+  );
+  const stagedOutput = git(
+    ["diff", "--name-only", "--cached"],
+    worktreePath,
+  );
+  const untrackedOutput = git(
+    ["ls-files", "--others", "--exclude-standard"],
+    worktreePath,
+  );
+
+  const allFiles = new Set<string>();
+  for (const line of [...diffOutput.split("\n"), ...stagedOutput.split("\n"), ...untrackedOutput.split("\n")]) {
+    const trimmed = line.trim();
+    if (trimmed) allFiles.add(trimmed);
+  }
+
+  const hasUncommitted = allFiles.size > 0;
+
+  let lastCommit: string | null = null;
+  try {
+    lastCommit = git(["log", "-1", "--oneline"], worktreePath);
+  } catch {
+    // No commits yet
+  }
+
+  return {
+    filesChanged: [...allFiles],
+    hasUncommitted,
+    lastCommit,
+  };
+}
+
+/**
+ * Remove a worktree and optionally delete its branch.
+ */
+export function removeWorktree(
+  worktreePath: string,
+  opts?: { deleteBranch?: boolean; baseRepo?: string },
+): void {
+  const repo = opts?.baseRepo ?? DEFAULT_BASE_REPO;
+
+  if (existsSync(worktreePath)) {
+    git(["worktree", "remove", "--force", worktreePath], repo);
+  }
+
+  if (opts?.deleteBranch) {
+    // Extract branch name from the worktree path convention
+    try {
+      const branches = git(["branch", "--list", "codex/*"], repo);
+      // Only delete if it looks like a codex branch
+      for (const b of branches.split("\n")) {
+        const name = b.trim().replace(/^\* /, "");
+        if (name && worktreePath.includes(name.replace("codex/", ""))) {
+          git(["branch", "-D", name], repo);
+          break;
+        }
+      }
+    } catch {
+      // Best effort
+    }
+  }
+}
+
+/**
+ * Push the worktree branch and create a GitHub PR via `gh`.
+ */
+export function createPullRequest(
+  worktreePath: string,
+  title: string,
+  body: string,
+): { prUrl: string } {
+  // Commit any uncommitted changes first
+  const status = getWorktreeStatus(worktreePath);
+  if (status.hasUncommitted) {
+    git(["add", "-A"], worktreePath);
+    git(
+      [
+        "-c", "user.name=claw",
+        "-c", "user.email=claw@calltelemetry.com",
+        "commit", "-m", title,
+      ],
+      worktreePath,
+    );
+  }
+
+  // Get branch name
+  const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath);
+
+  // Push branch
+  git(["push", "-u", "origin", branch], worktreePath);
+
+  // Create PR via gh CLI
+  const prUrl = execFileSync(
+    "gh",
+    ["pr", "create", "--title", title, "--body", body, "--head", branch],
+    { cwd: worktreePath, encoding: "utf8", timeout: 30_000 },
+  ).trim();
+
+  return { prUrl };
+}
+
+export interface WorktreeEntry {
+  path: string;
+  branch: string;
+  ageMs: number;
+  hasChanges: boolean;
+}
+
+/**
+ * List all codex worktrees under /tmp.
+ */
+export function listWorktrees(baseRepo?: string): WorktreeEntry[] {
+  const repo = baseRepo ?? DEFAULT_BASE_REPO;
+  const entries: WorktreeEntry[] = [];
+
+  // Find /tmp/codex-* directories
+  let dirs: string[];
+  try {
+    dirs = readdirSync("/tmp")
+      .filter((d) => d.startsWith("codex-"))
+      .map((d) => `/tmp/${d}`);
+  } catch {
+    return [];
+  }
+
+  for (const dir of dirs) {
+    if (!existsSync(dir)) continue;
+    try {
+      const stat = statSync(dir);
+      if (!stat.isDirectory()) continue;
+
+      let branch = "unknown";
+      try {
+        branch = git(["rev-parse", "--abbrev-ref", "HEAD"], dir);
+      } catch {}
+
+      let hasChanges = false;
+      try {
+        const status = getWorktreeStatus(dir);
+        hasChanges = status.hasUncommitted;
+      } catch {}
+
+      entries.push({
+        path: dir,
+        branch,
+        ageMs: Date.now() - stat.mtimeMs,
+        hasChanges,
+      });
+    } catch {
+      // Skip unreadable dirs
+    }
+  }
+
+  return entries.sort((a, b) => b.ageMs - a.ageMs);
+}
+
+/**
+ * Remove codex worktrees older than maxAgeMs.
+ * Returns list of removed paths.
+ */
+export function pruneStaleWorktrees(
+  maxAgeMs: number = 24 * 60 * 60_000,
+  opts?: { baseRepo?: string; dryRun?: boolean },
+): { removed: string[]; skipped: string[]; errors: string[] } {
+  const repo = opts?.baseRepo ?? DEFAULT_BASE_REPO;
+  const worktrees = listWorktrees(repo);
+  const removed: string[] = [];
+  const skipped: string[] = [];
+  const errors: string[] = [];
+
+  for (const wt of worktrees) {
+    if (wt.ageMs < maxAgeMs) {
+      skipped.push(wt.path);
+      continue;
+    }
+
+    if (opts?.dryRun) {
+      removed.push(wt.path);
+      continue;
+    }
+
+    try {
+      removeWorktree(wt.path, { deleteBranch: true, baseRepo: repo });
+      removed.push(wt.path);
+    } catch (err) {
+      errors.push(`${wt.path}: ${err}`);
+    }
+  }
+
+  return { removed, skipped, errors };
+}

package/src/gemini-tool.ts

@@ -0,0 +1,238 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { ActivityContent } from "./linear-api.js";
+import {
+  buildLinearApi,
+  resolveSession,
+  extractPrompt,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_BASE_REPO,
+  type CliToolParams,
+  type CliResult,
+} from "./cli-shared.js";
+
+const GEMINI_BIN = "/home/claw/.npm-global/bin/gemini";
+
+/**
+ * Map a Gemini CLI stream-json JSONL event to a Linear activity.
+ *
+ * Gemini event types:
+ *   init → message(user) → message(assistant) → tool_use → tool_result → result
+ */
+function mapGeminiEventToActivity(event: any): ActivityContent | null {
+  const type = event?.type;
+
+  // Assistant message (delta text)
+  if (type === "message" && event.role === "assistant") {
+    const text = event.content;
+    if (text) return { type: "thought", body: text.slice(0, 1000) };
+    return null;
+  }
+
+  // Tool use — running a command or tool
+  if (type === "tool_use") {
+    const toolName = event.tool_name ?? "tool";
+    const params = event.parameters ?? {};
+    let paramSummary: string;
+    if (params.command) {
+      paramSummary = String(params.command).slice(0, 200);
+    } else if (params.file_path) {
+      paramSummary = String(params.file_path);
+    } else if (params.description) {
+      paramSummary = String(params.description).slice(0, 200);
+    } else {
+      paramSummary = JSON.stringify(params).slice(0, 200);
+    }
+    return { type: "action", action: `Running ${toolName}`, parameter: paramSummary };
+  }
+
+  // Tool result
+  if (type === "tool_result") {
+    const status = event.status ?? "unknown";
+    const output = event.output ?? "";
+    const truncated = output.length > 300 ? output.slice(0, 300) + "..." : output;
+    return {
+      type: "action",
+      action: `Tool ${status}`,
+      parameter: truncated || "(no output)",
+    };
+  }
+
+  // Final result
+  if (type === "result") {
+    const stats = event.stats;
+    const parts: string[] = ["Gemini completed"];
+    if (stats) {
+      if (stats.duration_ms) parts.push(`${Math.round(stats.duration_ms / 1000)}s`);
+      if (stats.total_tokens) parts.push(`${stats.total_tokens} tokens`);
+      if (stats.tool_calls) parts.push(`${stats.tool_calls} tool calls`);
+    }
+    return { type: "thought", body: parts.join(" — ") };
+  }
+
+  return null;
+}
+
+/**
+ * Run Gemini CLI with JSONL streaming, mapping events to Linear activities.
+ */
+export async function runGemini(
+  api: OpenClawPluginApi,
+  params: CliToolParams,
+  pluginConfig?: Record<string, unknown>,
+): Promise<CliResult> {
+  api.logger.info(`gemini_run params: ${JSON.stringify(params).slice(0, 500)}`);
+
+  const prompt = extractPrompt(params);
+  if (!prompt) {
+    return {
+      success: false,
+      output: `gemini_run error: no prompt provided. Received keys: ${Object.keys(params).join(", ")}`,
+      error: "missing prompt",
+    };
+  }
+
+  const { model, timeoutMs } = params;
+  const { agentSessionId, issueIdentifier } = resolveSession(params);
+
+  api.logger.info(`gemini_run: session=${agentSessionId ?? "none"}, issue=${issueIdentifier ?? "none"}`);
+
+  const timeout = timeoutMs ?? (pluginConfig?.geminiTimeoutMs as number) ?? DEFAULT_TIMEOUT_MS;
+  const workingDir = params.workingDir ?? (pluginConfig?.geminiBaseRepo as string) ?? DEFAULT_BASE_REPO;
+
+  const linearApi = buildLinearApi(api, agentSessionId);
+
+  if (linearApi && agentSessionId) {
+    await linearApi.emitActivity(agentSessionId, {
+      type: "thought",
+      body: `Starting Gemini: "${prompt.slice(0, 100)}${prompt.length > 100 ? "..." : ""}"`,
+    }).catch(() => {});
+  }
+
+  // Build gemini command — no -C flag, use cwd in spawn options
+  const args = [
+    "-p", prompt,
+    "-o", "stream-json",
+    "--yolo",
+  ];
+  if (model ?? pluginConfig?.geminiModel) {
+    args.push("-m", (model ?? pluginConfig?.geminiModel) as string);
+  }
+
+  api.logger.info(`Gemini exec: ${GEMINI_BIN} ${args.join(" ").slice(0, 200)}...`);
+
+  return new Promise<CliResult>((resolve) => {
+    const child = spawn(GEMINI_BIN, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd: workingDir,
+      env: { ...process.env },
+      timeout: 0,
+    });
+
+    let killed = false;
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+      setTimeout(() => { if (!child.killed) child.kill("SIGKILL"); }, 5_000);
+    }, timeout);
+
+    const collectedMessages: string[] = [];
+    const collectedCommands: string[] = [];
+    let stderrOutput = "";
+
+    const rl = createInterface({ input: child.stdout! });
+    rl.on("line", (line) => {
+      if (!line.trim()) return;
+
+      let event: any;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        // Non-JSON lines (e.g. "YOLO mode" warnings) — skip
+        return;
+      }
+
+      // Collect assistant text for final output
+      if (event.type === "message" && event.role === "assistant") {
+        const text = event.content;
+        if (text) collectedMessages.push(text);
+      }
+
+      // Collect tool use/result for final output
+      if (event.type === "tool_use") {
+        const toolName = event.tool_name ?? "tool";
+        const cmd = event.parameters?.command ?? event.parameters?.description ?? "";
+        if (cmd) collectedCommands.push(`\`${toolName}\`: ${String(cmd).slice(0, 200)}`);
+      }
+
+      if (event.type === "tool_result") {
+        const output = event.output ?? "";
+        const status = event.status ?? "unknown";
+        const truncOutput = output.length > 500 ? output.slice(0, 500) + "..." : output;
+        if (truncOutput) {
+          collectedCommands.push(
+            `→ ${status}${truncOutput ? "\n```\n" + truncOutput + "\n```" : ""}`
+          );
+        }
+      }
+
+      // Stream activity to Linear
+      const activity = mapGeminiEventToActivity(event);
+      if (activity && linearApi && agentSessionId) {
+        linearApi.emitActivity(agentSessionId, activity).catch((err) => {
+          api.logger.warn(`Failed to emit Gemini activity: ${err}`);
+        });
+      }
+    });
+
+    child.stderr?.on("data", (chunk) => {
+      stderrOutput += chunk.toString();
+    });
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      rl.close();
+
+      const parts: string[] = [];
+      if (collectedMessages.length > 0) parts.push(collectedMessages.join("\n\n"));
+      if (collectedCommands.length > 0) parts.push(collectedCommands.join("\n\n"));
+      const output = parts.join("\n\n") || stderrOutput || "(no output)";
+
+      if (killed) {
+        api.logger.warn(`Gemini timed out after ${timeout}ms`);
+        resolve({
+          success: false,
+          output: `Gemini timed out after ${Math.round(timeout / 1000)}s. Partial output:\n${output}`,
+          error: "timeout",
+        });
+        return;
+      }
+
+      if (code !== 0) {
+        api.logger.warn(`Gemini exited with code ${code}`);
+        resolve({
+          success: false,
+          output: `Gemini failed (exit ${code}):\n${output}`,
+          error: `exit ${code}`,
+        });
+        return;
+      }
+
+      api.logger.info(`Gemini completed successfully`);
+      resolve({ success: true, output });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      rl.close();
+      api.logger.error(`Gemini spawn error: ${err}`);
+      resolve({
+        success: false,
+        output: `Failed to start Gemini: ${err.message}`,
+        error: err.message,
+      });
+    });
+  });
+}
+

package/src/orchestration-tools.ts

@@ -0,0 +1,134 @@
+import type { AnyAgentTool, OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { jsonResult } from "openclaw/plugin-sdk";
+import { runAgent } from "./agent.js";
+
+/**
+ * Create orchestration tools that let agents delegate work to other crew agents.
+ *
+ * - spawn_agent: Fire-and-forget parallel delegation (non-blocking)
+ * - ask_agent: Synchronous question-answer with another agent
+ */
+export function createOrchestrationTools(
+  api: OpenClawPluginApi,
+  _ctx: Record<string, unknown>,
+): AnyAgentTool[] {
+  return [
+    {
+      name: "spawn_agent",
+      label: "Spawn Agent",
+      description:
+        "Delegate a task to another crew agent. Runs in the background — does not block. " +
+        "Use this when you want to parallelize work (e.g., ask kaylee to investigate DB performance " +
+        "while you continue working on something else).",
+      parameters: {
+        type: "object",
+        properties: {
+          agentId: {
+            type: "string",
+            description:
+              "Which agent to dispatch (e.g., 'kaylee', 'inara', 'mal'). Must match an agent ID in openclaw.json.",
+          },
+          task: {
+            type: "string",
+            description: "Description of what the sub-agent should do.",
+          },
+          timeoutSeconds: {
+            type: "number",
+            description: "Max runtime in seconds (default: 300).",
+          },
+        },
+        required: ["agentId", "task"],
+      },
+      execute: async (_toolCallId: string, { agentId, task, timeoutSeconds }: {
+        agentId: string;
+        task: string;
+        timeoutSeconds?: number;
+      }) => {
+        const timeout = (timeoutSeconds ?? 300) * 1000;
+        const sessionId = `spawn-${agentId}-${Date.now()}`;
+
+        api.logger.info(`spawn_agent: dispatching ${agentId} — "${task.slice(0, 80)}..."`);
+
+        // Fire and forget — don't await the full result
+        const resultPromise = runAgent({
+          api,
+          agentId,
+          sessionId,
+          message: task,
+          timeoutMs: timeout,
+        });
+
+        // Store the promise so it can be retrieved later if needed
+        resultPromise.catch((err) => {
+          api.logger.error(`spawn_agent ${agentId} failed: ${err}`);
+        });
+
+        return jsonResult({
+          message: `Dispatched task to agent '${agentId}'. It is running in the background.`,
+          agentId,
+          sessionId,
+        });
+      },
+    } as unknown as AnyAgentTool,
+
+    {
+      name: "ask_agent",
+      label: "Ask Agent",
+      description:
+        "Ask another crew agent a question and wait for their reply. " +
+        "Use this when you need a specific answer before proceeding " +
+        "(e.g., 'wash, would this schema change break existing tests?').",
+      parameters: {
+        type: "object",
+        properties: {
+          agentId: {
+            type: "string",
+            description:
+              "Which agent to ask (e.g., 'kaylee', 'inara', 'mal'). Must match an agent ID in openclaw.json.",
+          },
+          message: {
+            type: "string",
+            description: "The question or request for the other agent.",
+          },
+          timeoutSeconds: {
+            type: "number",
+            description: "How long to wait for a reply in seconds (default: 120).",
+          },
+        },
+        required: ["agentId", "message"],
+      },
+      execute: async (_toolCallId: string, { agentId, message, timeoutSeconds }: {
+        agentId: string;
+        message: string;
+        timeoutSeconds?: number;
+      }) => {
+        const timeout = (timeoutSeconds ?? 120) * 1000;
+        const sessionId = `ask-${agentId}-${Date.now()}`;
+
+        api.logger.info(`ask_agent: asking ${agentId} — "${message.slice(0, 80)}..."`);
+
+        const result = await runAgent({
+          api,
+          agentId,
+          sessionId,
+          message,
+          timeoutMs: timeout,
+        });
+
+        if (!result.success) {
+          return jsonResult({
+            message: `Agent '${agentId}' failed to respond.`,
+            error: result.output.slice(0, 1000),
+            agentId,
+          });
+        }
+
+        return jsonResult({
+          message: `Response from agent '${agentId}':`,
+          agentId,
+          response: result.output,
+        });
+      },
+    } as unknown as AnyAgentTool,
+  ];
+}