capyai 0.2.1 → 0.3.1

package/README.md

@@ -72,7 +72,7 @@ Env vars: `CAPY_API_KEY`, `CAPY_PROJECT_ID`, `CAPY_SERVER`, `CAPY_ENV_FILE`, `GR
 
 ## Requirements
 
-Node.js 18+ or Bun. GitHub CLI (`gh`) for quality gate checks.
+[Bun](https://bun.sh) runtime. GitHub CLI (`gh`) for quality gate checks.
 
 ## License
 

package/bin/capy.js

@@ -1,61 +1,20 @@
 #!/usr/bin/env node
 
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
 
-const cmd = process.argv[2];
-
-if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
-  const { version } = require("../package.json");
-  console.log(`capy — agent orchestrator with quality gates
-
-Usage: capy <command> [args] [flags]
-
-Agents:
-  captain <prompt>         Start Captain thread
-  build <prompt>           Start Build agent
-  threads [list|get|msg|stop|messages]
-
-Tasks:
-  status                   Dashboard
-  list [status]            List tasks
-  get <id>                 Task details
-  start/stop/msg <id>      Control tasks
-  diff <id>                View diff
-  pr <id> [title]          Create PR
-
-Quality:
-  review <id>              Gate check
-  re-review <id>           Trigger Greptile re-review
-  approve <id> [--force]   Approve if gates pass
-  retry <id> [--fix="..."] Retry with context
-
-Monitoring:
-  watch/unwatch <id>       Auto-poll + notify
-  watches                  List watches
-
-Config:
-  init                     Interactive setup
-  config [key] [value]     Get/set config
-  models                   List models
-  tools                    All commands + env vars
-
-Flags:
-  --json  --model=<id>  --opus  --sonnet  --fast
-
-v${version}
-`);
-  process.exit(0);
-}
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const tsEntry = join(__dirname, "capy.ts");
 
 try {
-  const { run } = await import("../dist/capy.js");
-  await run(cmd, process.argv.slice(3));
+  execFileSync("bun", ["run", tsEntry, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    env: process.env,
+  });
 } catch (e) {
-  if (e.code === "ERR_MODULE_NOT_FOUND" || e.code === "MODULE_NOT_FOUND") {
-    console.error("capy: not built. Run: bun run build");
-    process.exit(1);
-  }
-  console.error(e.message);
+  if (e.status != null) process.exit(e.status);
+  console.error("capy requires Bun. Install: curl -fsSL https://bun.sh/install | bash");
+  console.error("Then: bun i -g capyai && capy --help");
   process.exit(1);
 }

package/bin/capy.ts

@@ -1,62 +1,42 @@
 #!/usr/bin/env bun
 
+import { defineCommand, runMain } from "citty";
 import { createRequire } from "node:module";
+
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 
-const cmd = process.argv[2];
-
-if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
-  console.log(`capy — agent orchestrator with quality gates
-
-Usage: capy <command> [args] [flags]
-
-Agents:
-  captain <prompt>         Start Captain thread
-  build <prompt>           Start Build agent
-  threads [list|get|msg|stop|messages]
-
-Tasks:
-  status                   Dashboard
-  list [status]            List tasks
-  get <id>                 Task details
-  start/stop/msg <id>      Control tasks
-  diff <id>                View diff
-  pr <id> [title]          Create PR
-
-Quality:
-  review <id>              Gate check
-  re-review <id>           Trigger Greptile re-review
-  approve <id> [--force]   Approve if gates pass
-  retry <id> [--fix="..."] Retry with context
-
-Monitoring:
-  watch/unwatch <id>       Auto-poll + notify
-  watches                  List watches
-
-Config:
-  init                     Interactive setup
-  config [key] [value]     Get/set config
-  models                   List models
-  tools                    All commands + env vars
-
-Flags:
-  --json  --model=<id>  --opus  --sonnet  --fast
-
-v${version}
-`);
-  process.exit(0);
-}
-
-try {
-  const { run } = await import("../src/cli.js");
-  await run(cmd, process.argv.slice(3));
-} catch (e: unknown) {
-  const err = e as Error & { code?: string };
-  if (err.code === "MODULE_NOT_FOUND" || err.code === "ERR_MODULE_NOT_FOUND") {
-    console.error("capy: broken install. Reinstall: npm i -g capy-cli");
-    process.exit(1);
-  }
-  console.error(err.message);
-  process.exit(1);
-}
+const main = defineCommand({
+  meta: {
+    name: "capy",
+    version,
+    description: "Agent orchestrator with quality gates",
+  },
+  subCommands: {
+    captain:     () => import("../src/commands/agents.js").then(m => m.captain),
+    build:       () => import("../src/commands/agents.js").then(m => m.build),
+    threads:     () => import("../src/commands/threads.js").then(m => m.default),
+    list:        () => import("../src/commands/tasks.js").then(m => m.list),
+    get:         () => import("../src/commands/tasks.js").then(m => m.get),
+    start:       () => import("../src/commands/tasks.js").then(m => m.start),
+    stop:        () => import("../src/commands/tasks.js").then(m => m.stop),
+    msg:         () => import("../src/commands/tasks.js").then(m => m.msg),
+    diff:        () => import("../src/commands/diff-pr.js").then(m => m.diff),
+    pr:          () => import("../src/commands/diff-pr.js").then(m => m.pr),
+    models:      () => import("../src/commands/setup.js").then(m => m.models),
+    tools:       () => import("../src/commands/setup.js").then(m => m.tools),
+    status:      () => import("../src/commands/setup.js").then(m => m.status),
+    review:      () => import("../src/commands/quality.js").then(m => m.review),
+    "re-review": () => import("../src/commands/quality.js").then(m => m.reReview),
+    approve:     () => import("../src/commands/quality.js").then(m => m.approve),
+    retry:       () => import("../src/commands/quality.js").then(m => m.retry),
+    watch:       () => import("../src/commands/monitoring.js").then(m => m.watch),
+    unwatch:     () => import("../src/commands/monitoring.js").then(m => m.unwatch),
+    watches:     () => import("../src/commands/monitoring.js").then(m => m.watches),
+    _poll:       () => import("../src/commands/monitoring.js").then(m => m._poll),
+    init:        () => import("../src/commands/setup.js").then(m => m.init),
+    config:      () => import("../src/commands/setup.js").then(m => m.config),
+  },
+});
+
+runMain(main);

package/package.json

@@ -1,19 +1,17 @@
 {
   "name": "capyai",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "type": "module",
   "description": "Unofficial Capy.ai CLI for agent orchestration with quality gates",
   "bin": {
     "capy": "./bin/capy.js"
   },
   "scripts": {
-    "build": "bun build bin/capy.ts --outdir dist --target node",
-    "prepublishOnly": "bun run build"
+    "typecheck": "tsc --noEmit"
   },
   "files": [
     "bin/",
-    "src/",
-    "dist/"
+    "src/"
   ],
   "engines": {
     "node": ">=18"
@@ -32,5 +30,9 @@
     "coding-agent",
     "orchestration",
     "cli"
-  ]
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "citty": "^0.2.2"
+  }
 }

package/src/api.ts

@@ -1,15 +1,10 @@
 import * as config from "./config.js";
 import type { Task, Thread, ThreadMessage, DiffData, Model, ListResponse, PullRequestRef } from "./types.js";
 
-async function request(method: string, path: string, body?: unknown): Promise<any> {
-  const cfg = config.load();
-  if (!cfg.apiKey) {
-    console.error("capy: API key not configured. Run: capy init");
-    process.exit(1);
-  }
-  const url = `${cfg.server}${path}`;
+async function rawRequest(apiKey: string, server: string, method: string, path: string, body?: unknown): Promise<any> {
+  const url = `${server}${path}`;
   const headers: Record<string, string> = {
-    "Authorization": `Bearer ${cfg.apiKey}`,
+    "Authorization": `Bearer ${apiKey}`,
     "Accept": "application/json",
   };
   const init: RequestInit = { method, headers };
@@ -40,6 +35,34 @@ async function request(method: string, path: string, body?: unknown): Promise<an
   }
 }
 
+async function request(method: string, path: string, body?: unknown): Promise<any> {
+  const cfg = config.load();
+  if (!cfg.apiKey) {
+    console.error("capy: API key not configured. Run: capy init");
+    process.exit(1);
+  }
+  return rawRequest(cfg.apiKey, cfg.server, method, path, body);
+}
+
+// --- Init helpers (accept key directly, before config is saved) ---
+export interface Project {
+  id: string;
+  name: string;
+  description?: string | null;
+  taskCode: string;
+  repos: { repoFullName: string; branch: string }[];
+}
+
+export async function listProjects(apiKey: string, server = "https://capy.ai/api/v1"): Promise<Project[]> {
+  const data = await rawRequest(apiKey, server, "GET", "/projects");
+  return data.items || [];
+}
+
+export async function listModelsWithKey(apiKey: string, server = "https://capy.ai/api/v1"): Promise<Model[]> {
+  const data = await rawRequest(apiKey, server, "GET", "/models");
+  return data.models || [];
+}
+
 // --- Threads ---
 export async function createThread(prompt: string, model?: string, repos?: unknown[]): Promise<Thread> {
   const cfg = config.load();

package/src/commands/_shared.ts

@@ -0,0 +1,32 @@
+import type { ArgsDef } from "citty";
+
+export const modelArgs = {
+  model:  { type: "string",  description: "Model ID override" },
+  opus:   { type: "boolean", description: "Use claude-opus-4-6" },
+  sonnet: { type: "boolean", description: "Use claude-sonnet-4-6" },
+  mini:   { type: "boolean", description: "Use gpt-5.4-mini" },
+  fast:   { type: "boolean", description: "Use gpt-5.4-fast" },
+  kimi:   { type: "boolean", description: "Use kimi-k2.5" },
+  glm:    { type: "boolean", description: "Use glm-5" },
+  gemini: { type: "boolean", description: "Use gemini-3.1-pro" },
+  grok:   { type: "boolean", description: "Use grok-4.1-fast" },
+  qwen:   { type: "boolean", description: "Use qwen-3-coder" },
+} as const satisfies ArgsDef;
+
+export const jsonArg = {
+  json: { type: "boolean", description: "Machine-readable JSON output", default: false },
+} as const satisfies ArgsDef;
+
+export function resolveModel(args: Record<string, unknown>): string | null {
+  if (args.model) return String(args.model);
+  if (args.opus)   return "claude-opus-4-6";
+  if (args.sonnet) return "claude-sonnet-4-6";
+  if (args.mini)   return "gpt-5.4-mini";
+  if (args.fast)   return "gpt-5.4-fast";
+  if (args.kimi)   return "kimi-k2.5";
+  if (args.glm)    return "glm-5";
+  if (args.gemini) return "gemini-3.1-pro";
+  if (args.grok)   return "grok-4.1-fast";
+  if (args.qwen)   return "qwen-3-coder";
+  return null;
+}

package/src/commands/agents.ts

@@ -0,0 +1,48 @@
+import { defineCommand } from "citty";
+import { modelArgs, jsonArg, resolveModel } from "./_shared.js";
+
+export const captain = defineCommand({
+  meta: { name: "captain", description: "Start Captain thread", alias: "plan" },
+  args: {
+    prompt: { type: "positional", description: "Task prompt", required: true },
+    ...modelArgs,
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const { out, IS_JSON } = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const cfg = config.load();
+    const model = resolveModel(args) || cfg.defaultModel;
+    const data = await api.createThread(args.prompt, model);
+
+    if (IS_JSON) { out(data); return; }
+    log.success(`Captain started: https://capy.ai/project/${cfg.projectId}/captain/${data.id}`);
+    log.info(`Thread: ${data.id}  Model: ${model}`);
+  },
+});
+
+export const build = defineCommand({
+  meta: { name: "build", description: "Start Build agent (isolated)", alias: "run" },
+  args: {
+    prompt: { type: "positional", description: "Task prompt", required: true },
+    ...modelArgs,
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const config = await import("../config.js");
+    const { out, IS_JSON } = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const cfg = config.load();
+    const model = resolveModel(args) || cfg.defaultModel;
+    const data = await api.createTask(args.prompt, model);
+
+    if (IS_JSON) { out(data); return; }
+    log.success(`Build started: https://capy.ai/project/${cfg.projectId}/tasks/${data.id}`);
+    log.info(`ID: ${data.identifier}  Model: ${model}`);
+  },
+});

package/src/commands/diff-pr.ts

@@ -0,0 +1,46 @@
+import { defineCommand } from "citty";
+import { jsonArg } from "./_shared.js";
+
+export const diff = defineCommand({
+  meta: { name: "diff", description: "View task diff" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    mode: { type: "string", description: "Diff mode", default: "run" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+
+    const data = await api.getDiff(args.id, args.mode);
+    if (args.json) { fmt.out(data); return; }
+    console.log(`Diff (${data.source || "unknown"}): +${data.stats?.additions || 0} -${data.stats?.deletions || 0} in ${data.stats?.files || 0} files\n`);
+    if (data.files) {
+      data.files.forEach(f => {
+        console.log(`--- ${f.path} (${f.state}) +${f.additions} -${f.deletions}`);
+        if (f.patch) console.log(f.patch);
+        console.log();
+      });
+    }
+  },
+});
+
+export const pr = defineCommand({
+  meta: { name: "pr", description: "Create a PR" },
+  args: {
+    id: { type: "positional", description: "Task ID", required: true },
+    title: { type: "positional", description: "PR title" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const fmt = await import("../output.js");
+    const { log } = await import("@clack/prompts");
+
+    const body = args.title ? { title: args.title } : {};
+    const data = await api.createPR(args.id, body);
+    if (args.json) { fmt.out(data); return; }
+    log.success(`PR: ${data.url}`);
+    log.info(`#${data.number} ${data.title} (${data.headRef} \u2192 ${data.baseRef})`);
+  },
+});

package/src/commands/monitoring.ts

@@ -0,0 +1,95 @@
+import { defineCommand } from "citty";
+import { jsonArg } from "./_shared.js";
+
+export const watch = defineCommand({
+  meta: { name: "watch", description: "Poll + notify on completion" },
+  args: {
+    id: { type: "positional", description: "Task or thread ID", required: true },
+    interval: { type: "string", description: "Poll interval in minutes (1-30)", default: "3" },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const w = await import("../watch.js");
+    const config = await import("../config.js");
+    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 added = w.add(args.id, type, interval);
+
+    if (args.json) { fmt.out({ id: args.id, type, interval, added }); return; }
+    if (added) {
+      console.log(`Watching ${args.id} (${type}) every ${interval}min. Will notify when done.`);
+    } else {
+      console.log(`Already watching ${args.id}.`);
+    }
+  },
+});
+
+export const unwatch = defineCommand({
+  meta: { name: "unwatch", description: "Stop watching" },
+  args: {
+    id: { type: "positional", description: "Task or thread ID", required: true },
+    ...jsonArg,
+  },
+  async run({ args }) {
+    const w = await import("../watch.js");
+    const fmt = await import("../output.js");
+
+    w.remove(args.id);
+    if (args.json) { fmt.out({ id: args.id, status: "removed" }); return; }
+    console.log(`Stopped watching ${args.id}.`);
+  },
+});
+
+export const watches = defineCommand({
+  meta: { name: "watches", description: "List active watches" },
+  args: { ...jsonArg },
+  async run({ args }) {
+    const w = await import("../watch.js");
+    const fmt = await import("../output.js");
+
+    const entries = w.list();
+    if (args.json) { fmt.out(entries); return; }
+    if (!entries.length) { console.log("No active watches."); return; }
+    entries.forEach(e => console.log(`${fmt.pad(e.id.slice(0, 20), 22)} type=${e.type}  every ${e.intervalMin}min  since ${e.created}`));
+  },
+});
+
+export const _poll = defineCommand({
+  meta: { name: "_poll", description: "Internal cron poll", hidden: true },
+  args: {
+    id: { type: "positional", description: "ID", required: true },
+    type: { type: "positional", description: "task or thread" },
+  },
+  async run({ args }) {
+    const api = await import("../api.js");
+    const w = await import("../watch.js");
+
+    const type = args.type || "task";
+
+    if (type === "thread") {
+      const data = await api.getThread(args.id);
+      if (data.status === "idle" || data.status === "archived") {
+        const taskLines = (data.tasks || []).map(t => `  ${t.identifier}: ${t.title} [${t.status}]`).join("\n");
+        const prLines = (data.pullRequests || []).map(p => `  PR#${p.number}: ${p.url} [${p.state}]`).join("\n");
+        let msg = `[Capy] Captain thread finished.\nTitle: ${data.title || "(untitled)"}\nStatus: ${data.status}`;
+        if (taskLines) msg += `\n\nTasks:\n${taskLines}`;
+        if (prLines) msg += `\n\nPRs:\n${prLines}`;
+        msg += `\n\nRun: capy review <task-id> for each task, then capy approve <task-id> if quality passes.`;
+        w.notify(msg);
+        w.remove(args.id);
+      }
+      return;
+    }
+
+    const data = await api.getTask(args.id);
+    if (data.status === "needs_review" || data.status === "archived") {
+      let msg = `[Capy] Task ${data.identifier} ready.\nTitle: ${data.title}\nStatus: ${data.status}`;
+      if (data.pullRequest) msg += `\nPR: ${data.pullRequest.url || "#" + data.pullRequest.number}`;
+      msg += `\n\nRun: capy review ${data.identifier}, then capy approve ${data.identifier} if quality passes.`;
+      w.notify(msg);
+      w.remove(args.id);
+    }
+  },
+});