capyai 0.4.0 → 0.5.0

package/src/commands/monitoring.ts

@@ -1,5 +1,5 @@
 import { defineCommand } from "citty";
-import { jsonArg } from "./_shared.js";
+import { jsonArg, isThreadId } from "./_shared.js";
 
 export const watch = defineCommand({
   meta: { name: "watch", description: "Poll + notify on completion" },
@@ -14,7 +14,7 @@ export const watch = defineCommand({
     const fmt = await import("../output.js");
 
     const interval = Math.max(1, Math.min(parseInt(args.interval) || config.load().watchInterval, 30));
-    const type = (args.id.length > 20 || (args.id.length > 10 && !args.id.match(/^[A-Z]+-\d+$/))) ? "thread" : "task";
+    const type = isThreadId(args.id) ? "thread" : "task";
     const added = w.add(args.id, type, interval);
 
     if (args.json) { fmt.out({ id: args.id, type, interval, added }); return; }
@@ -70,7 +70,7 @@ export const wait = defineCommand({
 
     const timeoutMs = Math.max(10, parseInt(args.timeout) || 300) * 1000;
     const intervalMs = Math.max(5, Math.min(parseInt(args.interval) || 10, 60)) * 1000;
-    const isThread = args.id.length > 20 || (args.id.length > 10 && !args.id.match(/^[A-Z]+-\d+$/));
+    const isThread = isThreadId(args.id);
     const terminalTask = new Set(["needs_review", "archived", "completed", "failed"]);
     const terminalThread = new Set(["idle", "archived", "completed"]);
     const terminal = isThread ? terminalThread : terminalTask;
@@ -78,19 +78,25 @@ export const wait = defineCommand({
     const start = Date.now();
     if (!args.json) process.stderr.write(`Waiting for ${args.id} (${isThread ? "thread" : "task"})...`);
 
+    let lastStatus = "unknown";
     while (Date.now() - start < timeoutMs) {
-      const data = isThread ? await api.getThread(args.id) : await api.getTask(args.id);
-      if (terminal.has(data.status)) {
-        if (args.json) { fmt.out(data); return; }
-        console.log(`\n${isThread ? "Thread" : "Task"} ${data.status}.`);
-        return;
+      try {
+        const data = isThread ? await api.getThread(args.id) : await api.getTask(args.id);
+        lastStatus = data.status;
+        if (terminal.has(data.status)) {
+          if (args.json) { fmt.out(data); return; }
+          console.log(`\n${isThread ? "Thread" : "Task"} ${data.status}.`);
+          return;
+        }
+      } catch {
+        // transient error during poll, keep trying
       }
       if (!args.json) process.stderr.write(".");
       await new Promise(r => setTimeout(r, intervalMs));
     }
 
-    if (args.json) { fmt.out({ error: { code: "timeout", message: `Timed out after ${args.timeout}s` } }); process.exit(1); }
-    console.error(`\ncapy: timed out after ${args.timeout}s`);
+    if (args.json) { fmt.out({ error: { code: "timeout", message: `Timed out after ${args.timeout}s`, lastStatus } }); process.exit(1); }
+    console.error(`\ncapy: timed out after ${args.timeout}s (last status: ${lastStatus})`);
     process.exit(1);
   },
 });

package/src/commands/quality.ts

@@ -209,13 +209,12 @@ export const approve = defineCommand({
       const approveCmd = cfg.approveCommand;
       if (approveCmd) {
         try {
-          const { execFileSync } = await import("node:child_process");
-          const parts = approveCmd
+          const { execSync } = await import("node:child_process");
+          const expanded = approveCmd
             .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" });
           log.info("Post-approve hook ran.");
         } catch {}
       }

package/src/commands/setup.ts

@@ -133,6 +133,50 @@ export const config = defineCommand({
   },
 });
 
+const projectsList = defineCommand({
+  meta: { name: "list", description: "List projects" },
+  args: { ...jsonArg },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+
+    const projects = await api.listProjectsAuth();
+    if (args.json) { fmt.out(projects); return; }
+    if (!projects.length) { console.log("No projects."); return; }
+    fmt.table(["ID", "NAME", "CODE", "REPOS"], projects.map(p => [
+      p.id.slice(0, 16), p.name, p.taskCode, String(p.repos.length),
+    ]));
+  },
+});
+
+const projectsGet = defineCommand({
+  meta: { name: "get", description: "Project details" },
+  args: {
+    id: { type: "positional", required: false, description: "Project ID (defaults to current)" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const data = await api.getProject(args.id);
+    if (args.json) { fmt.out(data); return; }
+    log.info(`Project: ${data.name}\nID:      ${data.id}\nCode:    ${data.taskCode}`);
+    if (data.repos.length) {
+      console.log(`Repos:`);
+      data.repos.forEach(r => console.log(`  ${r.repoFullName} (${r.branch})`));
+    }
+    if (data.createdAt) console.log(`Created: ${data.createdAt}`);
+  },
+});
+
+export const projects = defineCommand({
+  meta: { name: "projects", description: "List and manage projects" },
+  default: "list",
+  subCommands: { list: projectsList, get: projectsGet },
+});
+
 export const models = defineCommand({
   meta: { name: "models", description: "List available models" },
   args: { ...jsonArg },
@@ -162,6 +206,7 @@ export const tools = defineCommand({
       captain:    { args: "<prompt>",              desc: "Start Captain thread" },
       build:      { args: "<prompt>",              desc: "Start Build agent (isolated)" },
       threads:    { args: "[list|get|msg|stop]",   desc: "Manage threads" },
+      triage:     { args: "[id,...]",               desc: "Actionable triage with diffs + recs" },
       status:     { args: "",                      desc: "Dashboard" },
       list:       { args: "[status]",              desc: "List tasks" },
       get:        { args: "<id>",                  desc: "Task details" },
@@ -178,6 +223,7 @@ export const tools = defineCommand({
       watch:      { args: "<id>",                  desc: "Poll + notify on completion" },
       unwatch:    { args: "<id>",                  desc: "Stop watching" },
       watches:    { args: "",                      desc: "List watches" },
+      projects:   { args: "[list|get]",              desc: "List/get projects" },
       pool:       { args: "[status|set|test|...]", desc: "Manage warm pool VMs" },
       models:     { args: "",                      desc: "List models" },
       tools:      { args: "",                      desc: "This list" },

package/src/commands/tasks.ts

@@ -5,14 +5,16 @@ export const list = defineCommand({
   meta: { name: "list", description: "List tasks", alias: "ls" },
   args: {
     status: { type: "positional", required: false, description: "Filter by status" },
+    limit: { type: "string", description: "Max results (default 30)" },
+    cursor: { type: "string", description: "Pagination cursor from previous response" },
     ...jsonArg,
   },
   async run({ args }) {
     const api = await import("../api.js");
     const fmt = await import("../output.js");
 
-    const data = await api.listTasks({ status: args.status });
-    if (args.json) { fmt.out(data.items || []); return; }
+    const data = await api.listTasks({ status: args.status, limit: args.limit ? parseInt(args.limit) : undefined, cursor: args.cursor });
+    if (args.json) { fmt.out({ items: data.items || [], nextCursor: data.nextCursor, hasMore: data.hasMore }); return; }
     if (!data.items?.length) { console.log("No tasks."); return; }
     fmt.table(["ID", "STATUS", "TITLE", "PR"], data.items.map(t => [
       t.identifier,

package/src/commands/threads.ts

@@ -3,13 +3,17 @@ import { jsonArg } from "./_shared.js";
 
 const list = defineCommand({
   meta: { name: "list", description: "List threads" },
-  args: { ...jsonArg },
+  args: {
+    limit: { type: "string", description: "Max results (default 10)" },
+    cursor: { type: "string", description: "Pagination cursor from previous response" },
+    ...jsonArg,
+  },
   async run({ args }) {
     const api = await import("../api.js");
     const fmt = await import("../output.js");
 
-    const data = await api.listThreads();
-    if (args.json) { fmt.out(data.items || []); return; }
+    const data = await api.listThreads({ limit: args.limit ? parseInt(args.limit) : undefined, cursor: args.cursor });
+    if (args.json) { fmt.out({ items: data.items || [], nextCursor: data.nextCursor, hasMore: data.hasMore }); return; }
     if (!data.items?.length) { console.log("No threads."); return; }
     fmt.table(["ID", "STATUS", "TITLE"], data.items.map(t => [
       t.id.slice(0, 16), t.status, (t.title || "(untitled)").slice(0, 40),

package/src/commands/triage.ts

@@ -0,0 +1,271 @@
+import { defineCommand } from "citty";
+import { jsonArg } from "./_shared.js";
+
+interface TriageTask {
+  identifier: string;
+  title: string;
+  status: string;
+  labels: string[];
+  category: "merged" | "ready" | "needs_pr" | "stuck" | "backlog" | "in_progress";
+  pr?: { number: number; state: string; url?: string };
+  diff?: { files: number; additions: number; deletions: number };
+  jam?: { model: string; status: string; credits: { llm: number; vm: number } };
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+interface TriageResult {
+  summary: { total: number; merged: number; ready: number; needs_pr: number; stuck: number; backlog: number; in_progress: number };
+  tasks: TriageTask[];
+  recommendations: string[];
+}
+
+export const triage = defineCommand({
+  meta: { name: "triage", description: "Actionable status for all tasks with diffs, PR state, and recommendations" },
+  args: {
+    ids: { type: "positional", required: false, description: "Specific task IDs (comma-separated or space-separated)" },
+    brief: { type: "boolean", description: "Fast mode: skip diff fetching, just categorize by status + PR state", default: false },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const github = await import("../github.js");
+    const fmt = await import("../output.js");
+    const { log, spinner } = await import("@clack/prompts");
+
+    const cfg = config.load();
+
+    // Get base task list
+    let tasks: any[];
+    if (args.ids) {
+      const ids = args.ids.split(/[,\s]+/).filter(Boolean);
+      tasks = await Promise.all(ids.map(id => api.getTask(id)));
+    } else {
+      const data = await api.listTasks({ limit: 100 });
+      tasks = data.items || [];
+    }
+
+    if (!tasks.length) {
+      if (args.json) { fmt.out({ summary: { total: 0 }, tasks: [], recommendations: [] }); return; }
+      console.log("No tasks.");
+      return;
+    }
+
+    // Fetch detail + diff in parallel for all tasks
+    const brief = !!args.brief;
+    let results: Awaited<ReturnType<typeof enrichTasks>>;
+    if (!args.json) {
+      const s = spinner();
+      s.start(`Loading ${tasks.length} tasks${brief ? "" : " (details + diffs)"}...`);
+      results = await enrichTasks(api, tasks, cfg, brief);
+      s.stop(`${tasks.length} tasks loaded`);
+    } else {
+      results = await enrichTasks(api, tasks, cfg, brief);
+    }
+
+    // Cross-ref PR state with GitHub
+    for (const r of results) {
+      if (r.pr && r.pr.state === "closed") {
+        const repo = r._raw?.pullRequest?.repoFullName || cfg.repos[0]?.repoFullName;
+        if (repo) {
+          const ghPR = github.getPR(repo, r.pr.number);
+          if (ghPR) r.pr.state = ghPR.state.toLowerCase();
+        }
+      }
+    }
+
+    // Categorize
+    const triaged: TriageTask[] = results.map(r => {
+      let category: TriageTask["category"];
+      if (r.status === "backlog") {
+        category = "backlog";
+      } else if (r.status === "in_progress") {
+        category = "in_progress";
+      } else if (r.pr?.state === "merged") {
+        category = "merged";
+      } else if (r.pr && r.pr.state === "open") {
+        category = "ready";
+      } else if (r.diff && r.diff.files > 0 && !r.pr) {
+        category = "needs_pr";
+      } else if (r.status === "needs_review" && !r.pr && (!r.diff || r.diff.files === 0)) {
+        category = brief ? "needs_pr" : "stuck";
+      } else if (r.status === "needs_review" && r.pr) {
+        category = "ready";
+      } else if (r.status === "needs_review" && !r.pr) {
+        category = "needs_pr";
+      } else {
+        category = "stuck";
+      }
+
+      return {
+        identifier: r.identifier,
+        title: r.title,
+        status: r.status,
+        labels: r.labels || [],
+        category,
+        ...(r.pr ? { pr: { number: r.pr.number, state: r.pr.state, url: r.pr.url } } : {}),
+        ...(r.diff ? { diff: r.diff } : {}),
+        ...(r.jam ? { jam: r.jam } : {}),
+        createdAt: r.createdAt,
+        updatedAt: r.updatedAt,
+      };
+    });
+
+    // Sort: in_progress first, then needs_pr, ready, stuck, backlog, merged
+    const order: Record<string, number> = { in_progress: 0, needs_pr: 1, ready: 2, stuck: 3, backlog: 4, merged: 5 };
+    triaged.sort((a, b) => (order[a.category] ?? 9) - (order[b.category] ?? 9));
+
+    // Build summary
+    const summary = {
+      total: triaged.length,
+      merged: triaged.filter(t => t.category === "merged").length,
+      ready: triaged.filter(t => t.category === "ready").length,
+      needs_pr: triaged.filter(t => t.category === "needs_pr").length,
+      stuck: triaged.filter(t => t.category === "stuck").length,
+      backlog: triaged.filter(t => t.category === "backlog").length,
+      in_progress: triaged.filter(t => t.category === "in_progress").length,
+    };
+
+    // Build recommendations
+    const recs: string[] = [];
+    const needsPr = triaged.filter(t => t.category === "needs_pr");
+    const stuck = triaged.filter(t => t.category === "stuck");
+    const ready = triaged.filter(t => t.category === "ready");
+    const inProgress = triaged.filter(t => t.category === "in_progress");
+
+    if (needsPr.length) {
+      recs.push(`Create PRs: ${needsPr.map(t => t.identifier).join(", ")} (have diffs, no PR)`);
+    }
+    if (ready.length) {
+      recs.push(`Review + approve: ${ready.map(t => t.identifier).join(", ")}`);
+    }
+    if (stuck.length) {
+      // Detect duplicates by similar titles
+      const stuckTitles = stuck.map(t => t.title.replace(/^(Implement |PLW-\d+ (BLOCKER|MEDIUM|LOW): )/i, "").slice(0, 40));
+      const dupes = stuck.filter((t, i) => {
+        const norm = stuckTitles[i];
+        return triaged.some(other =>
+          other.identifier !== t.identifier &&
+          (other.category === "needs_pr" || other.category === "ready" || other.category === "merged") &&
+          other.title.replace(/^(Implement |PLW-\d+ (BLOCKER|MEDIUM|LOW): )/i, "").slice(0, 40) === norm
+        );
+      });
+      if (dupes.length) {
+        recs.push(`Stop duplicates: ${dupes.map(t => t.identifier).join(", ")} (no output, duplicates of working tasks)`);
+      }
+      const realStuck = stuck.filter(t => !dupes.includes(t));
+      if (realStuck.length) {
+        recs.push(`Retry or stop: ${realStuck.map(t => t.identifier).join(", ")} (no diff produced)`);
+      }
+    }
+
+    const result: TriageResult = { summary, tasks: triaged, recommendations: recs };
+
+    if (args.json) { fmt.out(result); return; }
+
+    // Human output
+    const groups: Record<string, TriageTask[]> = {};
+    triaged.forEach(t => { (groups[t.category] = groups[t.category] || []).push(t); });
+
+    const sectionNames: Record<string, string> = {
+      in_progress: "IN PROGRESS",
+      needs_pr: "HAS CODE, NEEDS PR",
+      ready: "READY TO REVIEW",
+      stuck: "STUCK (no output)",
+      backlog: "BACKLOG",
+      merged: "MERGED",
+    };
+
+    for (const cat of ["in_progress", "needs_pr", "ready", "stuck", "backlog", "merged"]) {
+      const items = groups[cat];
+      if (!items?.length) continue;
+
+      fmt.section(`${sectionNames[cat]} (${items.length})`);
+      items.forEach(t => {
+        let line = `  ${fmt.pad(t.identifier, 8)}`;
+
+        if (t.pr) {
+          line += ` PR#${fmt.pad(String(t.pr.number), 4)} [${fmt.pad(t.pr.state, 6)}]`;
+        } else {
+          line += `              `;
+        }
+
+        if (t.diff && t.diff.files > 0) {
+          line += ` +${fmt.pad(String(t.diff.additions), 5)} -${fmt.pad(String(t.diff.deletions), 5)} ${fmt.pad(t.diff.files + " files", 8)}`;
+        } else {
+          line += `                         `;
+        }
+
+        if (t.jam) {
+          line += ` ${fmt.pad(t.jam.model, 12)}`;
+        }
+
+        line += `  ${(t.title || "").slice(0, 45)}`;
+        console.log(line);
+      });
+    }
+
+    console.log();
+    log.info(`Summary: ${summary.total} tasks — ${summary.in_progress} active, ${summary.needs_pr} need PR, ${summary.ready} to review, ${summary.stuck} stuck, ${summary.merged} merged`);
+
+    if (recs.length) {
+      console.log();
+      log.step("Recommendations");
+      recs.forEach((r, i) => console.log(`  ${i + 1}. ${r}`));
+    }
+  },
+});
+
+async function enrichTasks(api: typeof import("../api.js"), tasks: any[], cfg: any, brief = false) {
+  const enriched = await Promise.all(tasks.map(async (task) => {
+    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 {}
+    }
+
+    const lastJam = (detail.jams || []).at(-1);
+    const credits = lastJam?.credits;
+
+    return {
+      identifier: detail.identifier || id,
+      title: detail.title || task.title || "",
+      status: detail.status || task.status,
+      labels: detail.labels || task.labels || [],
+      createdAt: detail.createdAt || task.createdAt,
+      updatedAt: detail.updatedAt || task.updatedAt,
+      pr: detail.pullRequest?.number ? {
+        number: detail.pullRequest.number,
+        state: detail.pullRequest.state || "?",
+        url: detail.pullRequest.url,
+      } : null,
+      diff: diff?.stats ? {
+        files: diff.stats.files || 0,
+        additions: diff.stats.additions || 0,
+        deletions: diff.stats.deletions || 0,
+      } : null,
+      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,
+      _raw: detail,
+    };
+  }));
+
+  return enriched;
+}

package/src/config.ts

@@ -13,10 +13,8 @@ const DEFAULTS: CapyConfig = {
   repos: [],
   defaultModel: "gpt-5.4",
   quality: {
-    minReviewScore: 4,
     requireCI: true,
     requireTests: true,
-    requireLinearLink: true,
     reviewProvider: "greptile",
   },
   watchInterval: 3,
@@ -56,7 +54,7 @@ export function load(): CapyConfig {
 
 export function save(cfg: CapyConfig): void {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n", { mode: 0o600 });
 }
 
 export function get(key: string): unknown {

package/src/github.ts

@@ -42,7 +42,7 @@ export function getCIStatus(repo: string, number: number, prData?: PRData | null
   const checks: StatusCheck[] = pr.statusCheckRollup || [];
   const total = checks.length;
   const passing = checks.filter(c =>
-    c.conclusion === "SUCCESS" || c.conclusion === "NEUTRAL" || c.status === "COMPLETED"
+    c.conclusion === "SUCCESS" || c.conclusion === "NEUTRAL"
   ).length;
   const failing = checks.filter(c =>
     c.conclusion === "FAILURE" || c.conclusion === "ERROR" || c.conclusion === "TIMED_OUT"