capyai 0.4.0 → 0.5.0

package/src/mcp.ts

@@ -5,6 +5,7 @@ import { createRequire } from "node:module";
 import * as api from "./api.js";
 import { CapyError } from "./api.js";
 import * as config from "./config.js";
+import { isThreadId } from "./commands/_shared.js";
 
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
@@ -26,10 +27,6 @@ function structured(data: Record<string, unknown>) {
   return { structuredContent: data, content: [{ type: "text" as const, text: JSON.stringify(data) }] };
 }
 
-function isThreadId(id: string): boolean {
-  return id.length > 20 || (id.length > 10 && !id.match(/^[A-Z]+-\d+$/));
-}
-
 // --- Orchestration ---
 
 server.registerTool("capy_captain", {
@@ -89,12 +86,17 @@ server.registerTool("capy_wait", {
       : new Set(["needs_review", "archived", "completed", "failed"]);
 
     const start = Date.now();
+    let lastData: any = null;
     while (Date.now() - start < timeoutMs) {
-      const data = isThread ? await api.getThread(id) : await api.getTask(id);
-      if (terminal.has(data.status)) return text(data);
+      try {
+        lastData = isThread ? await api.getThread(id) : await api.getTask(id);
+        if (terminal.has(lastData.status)) return text(lastData);
+      } catch {
+        // transient error during poll, keep trying
+      }
       await new Promise(r => setTimeout(r, intervalMs));
     }
-    return { content: [{ type: "text" as const, text: JSON.stringify({ error: { code: "timeout", message: `Timed out after ${timeout || 300}s` } }) }], isError: true as const };
+    return { content: [{ type: "text" as const, text: JSON.stringify({ error: { code: "timeout", message: `Timed out after ${timeout || 300}s`, lastStatus: lastData?.status || "unknown" } }) }], isError: true as const };
   } catch (e) { return err(e); }
 });
 
@@ -103,15 +105,6 @@ server.registerTool("capy_review", {
   inputSchema: {
     id: z.string().describe("Task ID"),
   },
-  outputSchema: {
-    task: z.string(),
-    quality: z.object({
-      pass: z.boolean(),
-      passed: z.number(),
-      total: z.number(),
-      summary: z.string(),
-    }),
-  },
   annotations: { readOnlyHint: true },
 }, async ({ id }) => {
   try {
@@ -134,6 +127,12 @@ server.registerTool("capy_approve", {
   outputSchema: {
     task: z.string(),
     approved: z.boolean(),
+    quality: z.object({
+      pass: z.boolean(),
+      passed: z.number(),
+      total: z.number(),
+      summary: z.string(),
+    }),
   },
   annotations: { openWorldHint: true },
 }, async ({ id, force }) => {
@@ -146,13 +145,12 @@ server.registerTool("capy_approve", {
 
     if (approved && cfg.approveCommand) {
       try {
-        const { execFileSync } = await import("node:child_process");
-        const parts = cfg.approveCommand
+        const { execSync } = await import("node:child_process");
+        const expanded = cfg.approveCommand
           .replace("{task}", task.identifier || task.id)
-          .replace("{title}", task.title || "")
-          .replace("{pr}", String(task.pullRequest?.number || ""))
-          .split(/\s+/);
-        execFileSync(parts[0], parts.slice(1), { encoding: "utf8", timeout: 15000, stdio: "pipe" });
+          .replace("{title}", (task.title || "").replace(/'/g, "'\\''"))
+          .replace("{pr}", String(task.pullRequest?.number || ""));
+        execSync(expanded, { timeout: 15000, stdio: "pipe" });
       } catch {}
     }
 
@@ -200,6 +198,91 @@ server.registerTool("capy_retry", {
   } catch (e) { return err(e); }
 });
 
+server.registerTool("capy_triage", {
+  description: "Actionable triage of all tasks. Categorizes into: merged, ready, needs_pr, stuck, backlog, in_progress. Use brief=true for fast mode (skips diff fetching, ~2x faster).",
+  inputSchema: {
+    ids: z.array(z.string()).optional().describe("Specific task IDs to triage. Omit for all tasks."),
+    brief: z.boolean().optional().describe("Skip diff fetching for speed. Categories based on status + PR state only."),
+  },
+  annotations: { readOnlyHint: true },
+}, async ({ ids, brief }) => {
+  try {
+    const github = await import("./github.js");
+    const cfg = config.load();
+
+    let tasks: any[];
+    if (ids?.length) {
+      tasks = await Promise.all(ids.map(id => api.getTask(id)));
+    } else {
+      const data = await api.listTasks({ limit: 100 });
+      tasks = data.items || [];
+    }
+
+    const enriched = await Promise.all(tasks.map(async (task: any) => {
+      const id = task.identifier || task.id;
+      let detail: any = task;
+      let diff: any = null;
+      try { if (!task.jams) detail = await api.getTask(id); } catch {}
+      if (!brief) { try { diff = await api.getDiff(id); } catch {} }
+
+      if (detail.pullRequest?.number && detail.pullRequest.state === "closed") {
+        const repo = detail.pullRequest.repoFullName || cfg.repos[0]?.repoFullName;
+        if (repo) {
+          const ghPR = github.getPR(repo, detail.pullRequest.number);
+          if (ghPR) detail.pullRequest.state = ghPR.state.toLowerCase();
+        }
+      }
+
+      const lastJam = (detail.jams || []).at(-1);
+      const credits = lastJam?.credits;
+      const pr = detail.pullRequest?.number ? { number: detail.pullRequest.number, state: detail.pullRequest.state || "?", url: detail.pullRequest.url } : null;
+      const diffStats = diff?.stats ? { files: diff.stats.files || 0, additions: diff.stats.additions || 0, deletions: diff.stats.deletions || 0 } : null;
+
+      let category: string;
+      if (detail.status === "backlog") category = "backlog";
+      else if (detail.status === "in_progress") category = "in_progress";
+      else if (pr?.state === "merged") category = "merged";
+      else if (pr && pr.state === "open") category = "ready";
+      else if (diffStats && diffStats.files > 0 && !pr) category = "needs_pr";
+      else if (detail.status === "needs_review" && !pr && (!diffStats || diffStats.files === 0)) category = brief ? "needs_pr" : "stuck";
+      else if (detail.status === "needs_review" && pr) category = "ready";
+      else if (detail.status === "needs_review" && !pr) category = "needs_pr";
+      else category = "stuck";
+
+      return {
+        identifier: detail.identifier || id,
+        title: detail.title || "",
+        status: detail.status,
+        labels: detail.labels || [],
+        category,
+        pr,
+        diff: diffStats,
+        jam: lastJam ? { model: lastJam.model || "?", status: lastJam.status || "?", credits: { llm: typeof credits === "object" ? (credits?.llm ?? 0) : (credits || 0), vm: typeof credits === "object" ? (credits?.vm ?? 0) : 0 } } : null,
+      };
+    }));
+
+    const summary = {
+      total: enriched.length,
+      merged: enriched.filter((t: any) => t.category === "merged").length,
+      ready: enriched.filter((t: any) => t.category === "ready").length,
+      needs_pr: enriched.filter((t: any) => t.category === "needs_pr").length,
+      stuck: enriched.filter((t: any) => t.category === "stuck").length,
+      backlog: enriched.filter((t: any) => t.category === "backlog").length,
+      in_progress: enriched.filter((t: any) => t.category === "in_progress").length,
+    };
+
+    const recs: string[] = [];
+    const needsPr = enriched.filter((t: any) => t.category === "needs_pr");
+    const stuck = enriched.filter((t: any) => t.category === "stuck");
+    const ready = enriched.filter((t: any) => t.category === "ready");
+    if (needsPr.length) recs.push(`Create PRs: ${needsPr.map((t: any) => t.identifier).join(", ")}`);
+    if (ready.length) recs.push(`Review + approve: ${ready.map((t: any) => t.identifier).join(", ")}`);
+    if (stuck.length) recs.push(`Retry or stop: ${stuck.map((t: any) => t.identifier).join(", ")} (no diff produced)`);
+
+    return text({ summary, tasks: enriched, recommendations: recs });
+  } catch (e) { return err(e); }
+});
+
 // --- Status & monitoring ---
 
 server.registerTool("capy_status", {
@@ -382,6 +465,35 @@ server.registerTool("capy_re_review", {
   } catch (e) { return err(e); }
 });
 
+server.registerTool("capy_projects", {
+  description: "List all projects accessible with the current API key",
+  inputSchema: {},
+  annotations: { readOnlyHint: true, idempotentHint: true },
+}, async () => {
+  try {
+    const data = await api.listProjectsAuth();
+    return text(data);
+  } catch (e) { return err(e); }
+});
+
+server.registerTool("capy_project", {
+  description: "Get project details (repos, task code, config)",
+  inputSchema: {
+    id: z.string().optional().describe("Project ID (defaults to current project)"),
+  },
+  outputSchema: {
+    id: z.string(),
+    name: z.string(),
+    taskCode: z.string(),
+  },
+  annotations: { readOnlyHint: true, idempotentHint: true },
+}, async ({ id }) => {
+  try {
+    const data = await api.getProject(id);
+    return structured({ id: data.id, name: data.name, taskCode: data.taskCode, repos: data.repos as unknown as Record<string, unknown>, createdAt: data.createdAt, updatedAt: data.updatedAt });
+  } catch (e) { return err(e); }
+});
+
 server.registerTool("capy_models", {
   description: "List available AI models",
   inputSchema: {},
@@ -423,6 +535,17 @@ server.registerTool("capy_pool_update", {
   } catch (e) { return err(e); }
 });
 
+server.registerTool("capy_pool_test", {
+  description: "Test warm pool VM boot with setup commands",
+  inputSchema: {},
+  annotations: { openWorldHint: true },
+}, async () => {
+  try {
+    const data = await api.testWarmPool();
+    return text(data);
+  } catch (e) { return err(e); }
+});
+
 server.registerTool("capy_pool_instances", {
   description: "List warm pool VM instances",
   inputSchema: {

package/src/types.ts

@@ -1,8 +1,6 @@
 export interface QualityConfig {
-  minReviewScore: number;
   requireCI: boolean;
   requireTests: boolean;
-  requireLinearLink: boolean;
   reviewProvider: string;
 }
 

package/src/watch.ts

@@ -51,11 +51,11 @@ export function list(): WatchEntry[] {
 
 export function notify(text: string): boolean {
   const cfg = config.load();
-  const cmd = cfg.notifyCommand || "openclaw system event --text {text} --mode now";
+  const cmd = cfg.notifyCommand;
+  if (!cmd) return false;
   try {
-    const parts = cmd.replace("{text}", text).split(/\s+/);
-    execFileSync(parts[0], parts.slice(1), {
-      encoding: "utf8", timeout: 15000, stdio: "pipe",
+    execSync(cmd.replace("{text}", text.replace(/'/g, "'\\''")), {
+      timeout: 15000, stdio: "pipe",
     });
     return true;
   } catch { return false; }