capyai 0.2.0

package/src/config.ts

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { CapyConfig, QualityConfig } from "./types.js";
+
+export const CONFIG_DIR = path.join(process.env.HOME || "/root", ".capy");
+export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+export const WATCH_DIR = path.join(CONFIG_DIR, "watches");
+
+const DEFAULTS: CapyConfig = {
+  apiKey: "",
+  projectId: "",
+  server: "https://capy.ai/api/v1",
+  repos: [],
+  defaultModel: "gpt-5.4",
+  quality: {
+    minReviewScore: 4,
+    requireCI: true,
+    requireTests: true,
+    requireLinearLink: true,
+    reviewProvider: "greptile",
+  },
+  watchInterval: 3,
+  notifyCommand: "",
+};
+
+export function load(): CapyConfig {
+  const envPath = process.env.CAPY_ENV_FILE || path.join(CONFIG_DIR, ".env");
+  try {
+    fs.readFileSync(envPath, "utf8").split("\n").forEach(line => {
+      const t = line.trim();
+      if (!t || t.startsWith("#")) return;
+      const eq = t.indexOf("=");
+      if (eq === -1) return;
+      const k = t.slice(0, eq).trim();
+      const v = t.slice(eq + 1).trim();
+      if (!process.env[k]) process.env[k] = v;
+    });
+  } catch {}
+
+  let cfg: Partial<CapyConfig>;
+  try {
+    cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    cfg = {};
+  }
+
+  const merged: CapyConfig = { ...DEFAULTS, ...cfg } as CapyConfig;
+  merged.quality = { ...DEFAULTS.quality, ...(cfg.quality || {}) } as QualityConfig;
+
+  if (process.env.CAPY_API_KEY) merged.apiKey = process.env.CAPY_API_KEY;
+  if (process.env.CAPY_PROJECT_ID) merged.projectId = process.env.CAPY_PROJECT_ID;
+  if (process.env.CAPY_SERVER) merged.server = process.env.CAPY_SERVER;
+
+  return merged;
+}
+
+export function save(cfg: CapyConfig): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+}
+
+export function get(key: string): unknown {
+  const cfg = load() as Record<string, unknown>;
+  if (key.includes(".")) {
+    const parts = key.split(".");
+    let val: unknown = cfg;
+    for (const p of parts) {
+      val = (val as Record<string, unknown>)?.[p];
+    }
+    return val;
+  }
+  return cfg[key];
+}
+
+export function set(key: string, value: string): void {
+  const cfg = load() as Record<string, unknown>;
+  if (key.includes(".")) {
+    const parts = key.split(".");
+    let obj: Record<string, unknown> = cfg;
+    for (let i = 0; i < parts.length - 1; i++) {
+      if (!obj[parts[i]]) obj[parts[i]] = {};
+      obj = obj[parts[i]] as Record<string, unknown>;
+    }
+    let parsed: unknown = value;
+    if (value === "true") parsed = true;
+    else if (value === "false") parsed = false;
+    else if (/^\d+$/.test(value)) parsed = parseInt(value);
+    obj[parts[parts.length - 1]] = parsed;
+  } else {
+    cfg[key] = value;
+  }
+  save(cfg as CapyConfig);
+}

package/src/format.ts

@@ -0,0 +1,45 @@
+import type { Credits } from "./types.js";
+
+export const IS_JSON = process.argv.includes("--json");
+
+export function pad(s: string | number, n: number): string {
+  return (String(s) + " ".repeat(n)).slice(0, n);
+}
+
+export function out(data: unknown): void {
+  if (IS_JSON) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (typeof data === "string") {
+    console.log(data);
+  } else if (data !== null && data !== undefined) {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+
+export function table(headers: string[], rows: (string | number | null | undefined)[][]): void {
+  if (IS_JSON) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  const widths = headers.map((h, i) =>
+    Math.max(h.length, ...rows.map(r => String(r[i] || "").length))
+  );
+  console.log(headers.map((h, i) => pad(h, widths[i] + 2)).join(""));
+  console.log("-".repeat(widths.reduce((a, b) => a + b + 2, 0)));
+  rows.forEach(r => {
+    console.log(r.map((c, i) => pad(String(c || ""), widths[i] + 2)).join(""));
+  });
+}
+
+export function credits(c: Credits | number | null | undefined): string {
+  if (!c) return "0";
+  if (typeof c === "number") return String(c);
+  return `llm=${c.llm || 0} vm=${c.vm || 0}`;
+}
+
+export function section(title: string): void {
+  if (!IS_JSON) {
+    console.log(`\n${title}`);
+    console.log("-".repeat(80));
+  }
+}

package/src/github.ts

@@ -0,0 +1,112 @@
+import { execFileSync } from "node:child_process";
+import type { PRData, CIStatus, GreptileReview, DiffFile, StatusCheck } from "./types.js";
+
+function gh(args: string[], opts: { timeout?: number } = {}): any | null {
+  try {
+    return JSON.parse(execFileSync("gh", args, {
+      encoding: "utf8",
+      timeout: opts.timeout || 15000,
+      maxBuffer: 5 * 1024 * 1024,
+    }));
+  } catch {
+    return null;
+  }
+}
+
+export function getPR(repo: string, number: number): PRData | null {
+  return gh(["pr", "view", String(number), "--repo", repo, "--json",
+    "state,mergeable,mergedAt,closedAt,headRefName,baseRefName,title,body,url,number,additions,deletions,changedFiles,reviewDecision,statusCheckRollup,reviews,comments"]);
+}
+
+export function getPRReviewComments(repo: string, number: number): any[] {
+  try {
+    const out = execFileSync("gh", ["api", `repos/${repo}/pulls/${number}/comments`, "--paginate"], {
+      encoding: "utf8", timeout: 15000, maxBuffer: 5 * 1024 * 1024,
+    });
+    return JSON.parse(out);
+  } catch { return []; }
+}
+
+export function getPRIssueComments(repo: string, number: number): any[] {
+  try {
+    const out = execFileSync("gh", ["api", `repos/${repo}/issues/${number}/comments`, "--paginate"], {
+      encoding: "utf8", timeout: 15000, maxBuffer: 5 * 1024 * 1024,
+    });
+    return JSON.parse(out);
+  } catch { return []; }
+}
+
+export function getCIStatus(repo: string, number: number, prData?: PRData | null): CIStatus | null {
+  const pr = prData || getPR(repo, number);
+  if (!pr) return null;
+  const checks: StatusCheck[] = pr.statusCheckRollup || [];
+  const total = checks.length;
+  const passing = checks.filter(c =>
+    c.conclusion === "SUCCESS" || c.conclusion === "NEUTRAL" || c.status === "COMPLETED"
+  ).length;
+  const failing = checks.filter(c =>
+    c.conclusion === "FAILURE" || c.conclusion === "ERROR" || c.conclusion === "TIMED_OUT"
+  );
+  const pending = checks.filter(c =>
+    c.status === "IN_PROGRESS" || c.status === "QUEUED" || c.status === "PENDING"
+  );
+  return {
+    total,
+    passing,
+    failing: failing.map(c => ({ name: c.name || c.context || "", conclusion: c.conclusion })),
+    pending: pending.map(c => ({ name: c.name || c.context || "", status: c.status })),
+    allGreen: total > 0 && failing.length === 0 && pending.length === 0,
+    noChecks: total === 0,
+  };
+}
+
+export function parseGreptileReview(comments: any[]): GreptileReview | null {
+  const greptile = comments.find((c: any) =>
+    (c.user?.login || "").toLowerCase().includes("greptile") ||
+    (c.body || "").includes("Confidence Score")
+  );
+  if (!greptile) return null;
+
+  const body: string = greptile.body || "";
+  const scoreMatch = body.match(/(?:Confidence\s*Score|confidence)[:\s]*(\d(?:\.\d)?)\s*\/\s*5/i);
+  const score = scoreMatch ? parseFloat(scoreMatch[1]) : null;
+
+  const logicCount = (body.match(/\bLogic\b/gi) || []).length;
+  const syntaxCount = (body.match(/\bSyntax\b/gi) || []).length;
+  const styleCount = (body.match(/\bStyle\b/gi) || []).length;
+
+  return {
+    score,
+    issueCount: logicCount + syntaxCount + styleCount,
+    logic: logicCount,
+    syntax: syntaxCount,
+    style: styleCount,
+    body: body.slice(0, 2000),
+    url: greptile.html_url,
+  };
+}
+
+export function diffHasTests(files: DiffFile[]): boolean {
+  if (!files) return false;
+  return files.some(f => {
+    const p = (f.path || f.filename || "").toLowerCase();
+    return p.includes("test") || p.includes("spec") || p.includes("__tests__") ||
+           p.endsWith(".test.ts") || p.endsWith(".test.js") || p.endsWith("_test.go") ||
+           p.endsWith(".spec.ts") || p.endsWith(".spec.js");
+  });
+}
+
+export function getUnresolvedThreads(repo: string, number: number): { body: string; author: string }[] {
+  try {
+    const query = `query { repository(owner:"${repo.split("/")[0]}", name:"${repo.split("/")[1]}") { pullRequest(number:${number}) { reviewThreads(first:100) { nodes { isResolved isOutdated comments(first:1) { nodes { body author { login } } } } } } } }`;
+    const out = execFileSync("gh", ["api", "graphql", "-f", `query=${query}`], {
+      encoding: "utf8", timeout: 15000,
+    });
+    const data = JSON.parse(out);
+    const threads = data?.data?.repository?.pullRequest?.reviewThreads?.nodes || [];
+    return threads.filter((t: any) => !t.isResolved && !t.isOutdated).map((t: any) => ({
+      body: t.comments?.nodes?.[0]?.body?.slice(0, 200) || "",
+      author: t.comments?.nodes?.[0]?.author?.login || "unknown",
+    }));
+  } catch { return []; }
+}

package/src/greptile.ts

@@ -0,0 +1,151 @@
+import * as config from "./config.js";
+import type { UnaddressedIssue } from "./types.js";
+
+const MCP_URL = "https://api.greptile.com/mcp";
+
+async function mcp(method: string, params: Record<string, unknown>): Promise<any> {
+  const cfg = config.load();
+  const apiKey = cfg.greptileApiKey || process.env.GREPTILE_API_KEY || "";
+  if (!apiKey) {
+    console.error("capy: GREPTILE_API_KEY not set. Run: capy config greptileApiKey <key>");
+    process.exit(1);
+  }
+
+  const body = {
+    jsonrpc: "2.0",
+    id: Date.now(),
+    method: "tools/call",
+    params: {
+      name: method,
+      arguments: params,
+    },
+  };
+
+  let res: Response;
+  try {
+    res = await fetch(MCP_URL, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(30000),
+    });
+  } catch (e: unknown) {
+    console.error(`greptile: request failed — ${(e as Error).message}`);
+    return null;
+  }
+
+  const text = await res.text();
+  try {
+    const data = JSON.parse(text);
+    if (data.error) {
+      console.error(`greptile: ${data.error.message || JSON.stringify(data.error)}`);
+      return null;
+    }
+    if (data.result?.content) {
+      const textPart = data.result.content.find((c: any) => c.type === "text");
+      if (textPart) {
+        try { return JSON.parse(textPart.text); } catch { return textPart.text; }
+      }
+    }
+    return data.result;
+  } catch {
+    console.error("greptile: bad response:", text.slice(0, 300));
+    return null;
+  }
+}
+
+export async function triggerReview(repo: string, prNumber: number, defaultBranch?: string): Promise<any> {
+  return mcp("trigger_code_review", {
+    name: repo,
+    remote: "github",
+    defaultBranch: defaultBranch || "main",
+    prNumber,
+  });
+}
+
+export async function listReviews(repo: string, prNumber: number): Promise<any> {
+  return mcp("list_code_reviews", {
+    name: repo,
+    remote: "github",
+    defaultBranch: "main",
+    prNumber,
+    limit: 5,
+  });
+}
+
+export async function getReview(reviewId: string): Promise<any> {
+  return mcp("get_code_review", { codeReviewId: reviewId });
+}
+
+export async function getPR(repo: string, prNumber: number, defaultBranch?: string): Promise<any> {
+  return mcp("get_merge_request", {
+    name: repo,
+    remote: "github",
+    defaultBranch: defaultBranch || "main",
+    prNumber,
+  });
+}
+
+export async function listComments(repo: string, prNumber: number, opts: { defaultBranch?: string; greptileOnly?: boolean; unaddressedOnly?: boolean } = {}): Promise<any> {
+  const params: Record<string, unknown> = {
+    name: repo,
+    remote: "github",
+    defaultBranch: opts.defaultBranch || "main",
+    prNumber,
+  };
+  if (opts.greptileOnly) params.greptileGenerated = true;
+  if (opts.unaddressedOnly) params.addressed = false;
+  return mcp("list_merge_request_comments", params);
+}
+
+export async function waitForReview(reviewId: string, timeoutMs = 120000): Promise<any> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const review = await getReview(reviewId);
+    if (!review) return null;
+    if (review.status === "COMPLETED") return review;
+    if (review.status === "FAILED") return review;
+    await new Promise(r => setTimeout(r, 5000));
+  }
+  return null;
+}
+
+export async function freshReview(repo: string, prNumber: number, defaultBranch?: string): Promise<any> {
+  const trigger = await triggerReview(repo, prNumber, defaultBranch);
+  if (!trigger) return null;
+
+  const reviewId = trigger.codeReviewId || trigger.id;
+  if (!reviewId) return trigger;
+
+  console.error(`greptile: review triggered (${reviewId}), waiting...`);
+  return waitForReview(reviewId);
+}
+
+export async function getUnaddressedIssues(repo: string, prNumber: number, defaultBranch?: string): Promise<UnaddressedIssue[]> {
+  const comments = await listComments(repo, prNumber, {
+    defaultBranch,
+    greptileOnly: true,
+    unaddressedOnly: true,
+  });
+  if (!comments || !Array.isArray(comments)) return [];
+  return comments.map((c: any) => ({
+    body: (c.body || "").slice(0, 200),
+    file: c.path || c.file || "?",
+    line: c.line || c.position || "?",
+    hasSuggestion: !!c.hasSuggestion,
+    suggestedCode: c.suggestedCode || null,
+  }));
+}
+
+export async function needsReReview(repo: string, prNumber: number, defaultBranch?: string): Promise<{ hasNewCommits: boolean; reviewCompleteness: string } | null> {
+  const pr = await getPR(repo, prNumber, defaultBranch);
+  if (!pr) return null;
+  return {
+    hasNewCommits: !!pr.reviewAnalysis?.hasNewCommitsSinceReview,
+    reviewCompleteness: pr.reviewAnalysis?.reviewCompleteness || "unknown",
+  };
+}

package/src/quality.ts

@@ -0,0 +1,131 @@
+import * as github from "./github.js";
+import * as config from "./config.js";
+import * as greptile from "./greptile.js";
+import * as api from "./api.js";
+import type { Task, QualityGate, QualityResult, PRData } from "./types.js";
+
+function getGreptileStatusCheck(pr: PRData | null): string | null {
+  if (!pr?.statusCheckRollup) return null;
+  const c = pr.statusCheckRollup.find(c =>
+    (c.name || c.context || "").toLowerCase().includes("greptile")
+  );
+  if (!c) return null;
+  if (c.conclusion === "SUCCESS" || c.status === "COMPLETED") return "success";
+  if (c.conclusion === "FAILURE" || c.conclusion === "ERROR") return "failure";
+  if (c.status === "IN_PROGRESS" || c.status === "QUEUED" || c.status === "PENDING") return "pending";
+  return null;
+}
+
+export async function check(task: Task): Promise<QualityResult> {
+  const cfg = config.load();
+  const thresholds = cfg.quality;
+  const gates: QualityGate[] = [];
+
+  const reviewProvider = cfg.quality.reviewProvider || "greptile";
+  const hasGreptileKey = !!(cfg.greptileApiKey || process.env.GREPTILE_API_KEY);
+  const useGreptile = (reviewProvider === "greptile" || reviewProvider === "both") && hasGreptileKey;
+  const useCapy = reviewProvider === "capy" || reviewProvider === "both";
+
+  const hasPR = !!(task.pullRequest && task.pullRequest.number);
+  gates.push({ name: "pr_exists", pass: hasPR, detail: hasPR ? `PR#${task.pullRequest!.number}` : "No PR created" });
+
+  if (!hasPR) {
+    return {
+      pass: false, passed: 0, total: 1, gates,
+      summary: "No PR. Create one first: capy pr " + (task.identifier || task.id),
+    };
+  }
+
+  const repo = task.pullRequest!.repoFullName || (cfg.repos[0] && cfg.repos[0].repoFullName);
+  if (!repo) {
+    return { pass: false, passed: 0, total: 1, gates, summary: "No repo configured. Run: capy init" };
+  }
+  const prNum = task.pullRequest!.number!;
+  const defaultBranch = cfg.repos.find(r => r.repoFullName === repo)?.branch || "main";
+
+  const pr = github.getPR(repo, prNum);
+  if (pr) {
+    const merged = pr.state === "MERGED";
+    const open = pr.state === "OPEN";
+    gates.push({
+      name: "pr_open",
+      pass: merged || open,
+      detail: `${pr.state}${pr.reviewDecision ? ` (${pr.reviewDecision})` : ""}`,
+    });
+  }
+
+  const ci = github.getCIStatus(repo, prNum, pr);
+  if (ci) {
+    const nonGreptile = (f: { name: string }) => !(f.name || "").toLowerCase().includes("greptile");
+    const failures = ci.failing.filter(nonGreptile);
+    const pending = ci.pending.filter(nonGreptile);
+    const ciGreen = failures.length === 0 && pending.length === 0;
+    const greptileCheck = !ci.failing.every(nonGreptile) || !ci.pending.every(nonGreptile);
+
+    gates.push({
+      name: "ci",
+      pass: ciGreen || ci.noChecks,
+      detail: ci.noChecks ? "No CI configured" :
+        ciGreen ? `${ci.total - (greptileCheck ? 1 : 0)} passing` :
+        `${failures.length} failing: ${failures.map(f => f.name).join(", ")}`,
+      failing: failures,
+      pending,
+    });
+  }
+
+  if (useGreptile) {
+    const status = getGreptileStatusCheck(pr);
+
+    if (status === "pending") {
+      gates.push({ name: "greptile", pass: false, detail: "Review still processing" });
+    } else {
+      const unaddressed = await greptile.getUnaddressedIssues(repo, prNum, defaultBranch);
+      gates.push({
+        name: "greptile",
+        pass: unaddressed.length === 0,
+        detail: unaddressed.length === 0
+          ? "All issues addressed"
+          : `${unaddressed.length} unaddressed: ${unaddressed.slice(0, 3).map(u => `${u.file}:${u.line}`).join(", ")}`,
+        issues: unaddressed,
+      });
+
+      if (status === "failure") {
+        gates.push({ name: "greptile_check", pass: false, detail: "Status check failing" });
+      } else if (status === "success") {
+        gates.push({ name: "greptile_check", pass: true, detail: "Status check passing" });
+      }
+    }
+  }
+
+  if (useCapy) {
+    const unresolved = github.getUnresolvedThreads(repo, prNum);
+    gates.push({
+      name: "threads",
+      pass: unresolved.length === 0,
+      detail: unresolved.length === 0 ? "No unresolved threads" : `${unresolved.length} unresolved`,
+      threads: unresolved,
+    });
+  }
+
+  if (thresholds.requireTests) {
+    let diffFiles = null;
+    try { diffFiles = (await api.getDiff(task.identifier || task.id)).files || null; } catch {}
+    const hasTests = diffFiles ? github.diffHasTests(diffFiles) : false;
+    gates.push({ name: "tests", pass: hasTests, detail: hasTests ? "Tests in diff" : "No test files in diff" });
+  }
+
+  const passed = gates.filter(g => g.pass).length;
+  const total = gates.length;
+  const allPass = gates.every(g => g.pass);
+  const failing = gates.filter(g => !g.pass);
+
+  let summary: string;
+  if (allPass) {
+    summary = `${passed}/${total} gates passing. Ready to merge.`;
+  } else {
+    summary = `${passed}/${total} gates passing:\n` +
+      failing.map(g => `  - ${g.name}: ${g.detail}`).join("\n");
+  }
+
+  return { pass: allPass, passed, total, gates, summary };
+}