@arvorco/relentless 0.1.0

package/src/agents/claude.ts

@@ -0,0 +1,185 @@
+/**
+ * Claude Code Agent Adapter
+ *
+ * Adapter for Anthropic's Claude Code CLI
+ * https://docs.anthropic.com/claude-code
+ */
+
+import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./types.js";
+
+export const claudeAdapter: AgentAdapter = {
+  name: "claude",
+  displayName: "Claude Code",
+  hasSkillSupport: true,
+  skillInstallCommand: "/plugin install github:ArvorCo/Relentless",
+
+  async isInstalled(): Promise<boolean> {
+    try {
+      const path = await this.getExecutablePath();
+      return path !== null;
+    } catch {
+      return false;
+    }
+  },
+
+  async getExecutablePath(): Promise<string | null> {
+    try {
+      const proc = Bun.spawn(["which", "claude"], { stdout: "pipe" });
+      const output = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      if (exitCode === 0 && output.trim()) {
+        return output.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+
+  async invoke(prompt: string, options?: InvokeOptions): Promise<AgentResult> {
+    const startTime = Date.now();
+    const args = ["-p"];
+
+    if (options?.dangerouslyAllowAll) {
+      args.push("--dangerously-skip-permissions");
+    }
+
+    if (options?.model) {
+      args.push("--model", options.model);
+    }
+
+    const proc = Bun.spawn(["claude", ...args], {
+      cwd: options?.workingDirectory,
+      stdin: new Blob([prompt]),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Collect output
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    const output = stdout + (stderr ? `\n${stderr}` : "");
+    const duration = Date.now() - startTime;
+
+    return {
+      output,
+      exitCode,
+      isComplete: this.detectCompletion(output),
+      duration,
+    };
+  },
+
+  async *invokeStream(
+    prompt: string,
+    options?: InvokeOptions
+  ): AsyncGenerator<string, AgentResult, unknown> {
+    const startTime = Date.now();
+    const args = ["-p"];
+
+    if (options?.dangerouslyAllowAll) {
+      args.push("--dangerously-skip-permissions");
+    }
+
+    if (options?.model) {
+      args.push("--model", options.model);
+    }
+
+    const proc = Bun.spawn(["claude", ...args], {
+      cwd: options?.workingDirectory,
+      stdin: new Blob([prompt]),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const decoder = new TextDecoder();
+    let fullOutput = "";
+
+    // Stream stdout
+    const reader = proc.stdout.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        fullOutput += chunk;
+        yield chunk;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+
+    // Collect any stderr
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    const output = fullOutput + (stderr ? `\n${stderr}` : "");
+    const duration = Date.now() - startTime;
+
+    return {
+      output,
+      exitCode,
+      isComplete: this.detectCompletion(output),
+      duration,
+    };
+  },
+
+  detectCompletion(output: string): boolean {
+    return output.includes("<promise>COMPLETE</promise>");
+  },
+
+  detectRateLimit(output: string): RateLimitInfo {
+    // Pattern: "You've hit your limit · resets 12am (America/Sao_Paulo)"
+    if (output.includes("You've hit your limit") || output.includes("you've hit your limit")) {
+      const resetMatch = output.match(/resets\s+(\d{1,2})(am|pm)/i);
+      let resetTime: Date | undefined;
+
+      if (resetMatch) {
+        const hour = parseInt(resetMatch[1], 10);
+        const isPM = resetMatch[2].toLowerCase() === "pm";
+        const now = new Date();
+
+        resetTime = new Date(now);
+        resetTime.setHours(isPM && hour !== 12 ? hour + 12 : hour === 12 && !isPM ? 0 : hour);
+        resetTime.setMinutes(0);
+        resetTime.setSeconds(0);
+        resetTime.setMilliseconds(0);
+
+        // If reset time is in the past, move to tomorrow
+        if (resetTime <= now) {
+          resetTime.setDate(resetTime.getDate() + 1);
+        }
+      }
+
+      return {
+        limited: true,
+        resetTime,
+        message: "Claude Code rate limit exceeded",
+      };
+    }
+
+    return { limited: false };
+  },
+
+  async installSkills(projectPath: string): Promise<void> {
+    // Claude Code reads skills from .claude/skills/ in the project
+    const skillsDir = `${projectPath}/.claude/skills`;
+    await Bun.spawn(["mkdir", "-p", skillsDir]).exited;
+
+    // Copy our skills to the project
+    const relentlessRoot = import.meta.dir.replace("/src/agents", "");
+    await Bun.spawn([
+      "cp",
+      "-r",
+      `${relentlessRoot}/skills/prd`,
+      `${skillsDir}/`,
+    ]).exited;
+    await Bun.spawn([
+      "cp",
+      "-r",
+      `${relentlessRoot}/skills/relentless`,
+      `${skillsDir}/`,
+    ]).exited;
+  },
+};

package/src/agents/codex.ts

@@ -0,0 +1,89 @@
+/**
+ * Codex Agent Adapter
+ *
+ * Adapter for OpenAI's Codex CLI
+ * https://developers.openai.com/codex/cli/
+ */
+
+import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./types";
+
+export const codexAdapter: AgentAdapter = {
+  name: "codex",
+  displayName: "OpenAI Codex",
+  hasSkillSupport: false, // Uses SKILL.md but requires manual setup
+
+  async isInstalled(): Promise<boolean> {
+    try {
+      const path = await this.getExecutablePath();
+      return path !== null;
+    } catch {
+      return false;
+    }
+  },
+
+  async getExecutablePath(): Promise<string | null> {
+    try {
+      const proc = Bun.spawn(["which", "codex"], { stdout: "pipe" });
+      const output = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      if (exitCode === 0 && output.trim()) {
+        return output.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+
+  async invoke(prompt: string, options?: InvokeOptions): Promise<AgentResult> {
+    const startTime = Date.now();
+
+    // Codex uses `codex exec -` to read from stdin
+    const proc = Bun.spawn(["codex", "exec", "-"], {
+      cwd: options?.workingDirectory,
+      stdin: new Blob([prompt]),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Collect output
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    const output = stdout + (stderr ? `\n${stderr}` : "");
+    const duration = Date.now() - startTime;
+
+    return {
+      output,
+      exitCode,
+      isComplete: this.detectCompletion(output),
+      duration,
+    };
+  },
+
+  detectCompletion(output: string): boolean {
+    return output.includes("<promise>COMPLETE</promise>");
+  },
+
+  detectRateLimit(output: string): RateLimitInfo {
+    // Codex/OpenAI rate limit patterns
+    const patterns = [
+      /rate limit exceeded/i,
+      /\b429\b/,
+      /too many requests/i,
+      /quota exceeded/i,
+    ];
+
+    for (const pattern of patterns) {
+      if (pattern.test(output)) {
+        return {
+          limited: true,
+          message: "OpenAI Codex rate limit exceeded",
+        };
+      }
+    }
+
+    return { limited: false };
+  },
+};

package/src/agents/droid.ts

@@ -0,0 +1,90 @@
+/**
+ * Droid Agent Adapter
+ *
+ * Adapter for Factory's Droid CLI
+ * https://factory.ai
+ */
+
+import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./types";
+
+export const droidAdapter: AgentAdapter = {
+  name: "droid",
+  displayName: "Factory Droid",
+  hasSkillSupport: false, // No skill system, uses prompting
+
+  async isInstalled(): Promise<boolean> {
+    try {
+      const path = await this.getExecutablePath();
+      return path !== null;
+    } catch {
+      return false;
+    }
+  },
+
+  async getExecutablePath(): Promise<string | null> {
+    try {
+      const proc = Bun.spawn(["which", "droid"], { stdout: "pipe" });
+      const output = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      if (exitCode === 0 && output.trim()) {
+        return output.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+
+  async invoke(prompt: string, options?: InvokeOptions): Promise<AgentResult> {
+    const startTime = Date.now();
+
+    // Droid reads from stdin when piped or redirected.
+    // Use --auto high for high risk tolerance by default
+    const proc = Bun.spawn(["droid", "exec", "--auto", "high"], {
+      cwd: options?.workingDirectory,
+      stdin: new Blob([prompt]),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Collect output
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    const output = stdout + (stderr ? `\n${stderr}` : "");
+    const duration = Date.now() - startTime;
+
+    return {
+      output,
+      exitCode,
+      isComplete: this.detectCompletion(output),
+      duration,
+    };
+  },
+
+  detectCompletion(output: string): boolean {
+    return output.includes("<promise>COMPLETE</promise>");
+  },
+
+  detectRateLimit(output: string): RateLimitInfo {
+    // Droid rate limit patterns
+    const patterns = [
+      /rate limit/i,
+      /\b429\b/,
+      /too many requests/i,
+      /quota exceeded/i,
+    ];
+
+    for (const pattern of patterns) {
+      if (pattern.test(output)) {
+        return {
+          limited: true,
+          message: "Factory Droid rate limit exceeded",
+        };
+      }
+    }
+
+    return { limited: false };
+  },
+};

package/src/agents/gemini.ts

@@ -0,0 +1,109 @@
+/**
+ * Gemini Agent Adapter
+ *
+ * Adapter for Google's Gemini CLI
+ * https://github.com/google-gemini/gemini-cli
+ */
+
+import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./types";
+
+export const geminiAdapter: AgentAdapter = {
+  name: "gemini",
+  displayName: "Gemini CLI",
+  hasSkillSupport: true, // Uses extension system
+  skillInstallCommand: "gemini extensions install https://github.com/ArvorCo/Relentless",
+
+  async isInstalled(): Promise<boolean> {
+    try {
+      const path = await this.getExecutablePath();
+      return path !== null;
+    } catch {
+      return false;
+    }
+  },
+
+  async getExecutablePath(): Promise<string | null> {
+    try {
+      const proc = Bun.spawn(["which", "gemini"], { stdout: "pipe" });
+      const output = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      if (exitCode === 0 && output.trim()) {
+        return output.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+
+  async invoke(prompt: string, options?: InvokeOptions): Promise<AgentResult> {
+    const startTime = Date.now();
+    const args: string[] = [];
+
+    if (options?.dangerouslyAllowAll) {
+      args.push("--yolo");
+    }
+
+    if (options?.model) {
+      args.push("--model", options.model);
+    }
+
+    // Gemini CLI accepts prompt as positional argument
+    args.push(prompt);
+
+    const proc = Bun.spawn(["gemini", ...args], {
+      cwd: options?.workingDirectory,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Collect output
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    const output = stdout + (stderr ? `\n${stderr}` : "");
+    const duration = Date.now() - startTime;
+
+    return {
+      output,
+      exitCode,
+      isComplete: this.detectCompletion(output),
+      duration,
+    };
+  },
+
+  detectCompletion(output: string): boolean {
+    return output.includes("<promise>COMPLETE</promise>");
+  },
+
+  detectRateLimit(output: string): RateLimitInfo {
+    // Gemini rate limit patterns
+    const patterns = [
+      /quota exceeded/i,
+      /resource exhausted/i,
+      /rate limit/i,
+      /\b429\b/,
+      /too many requests/i,
+    ];
+
+    for (const pattern of patterns) {
+      if (pattern.test(output)) {
+        return {
+          limited: true,
+          message: "Gemini rate limit exceeded",
+        };
+      }
+    }
+
+    return { limited: false };
+  },
+
+  async installSkills(_projectPath: string): Promise<void> {
+    // Gemini uses extensions, we can't install project-local
+    // Users need to run: gemini extensions install <url>
+    console.log(
+      `To install Relentless skills for Gemini, run:\n  ${this.skillInstallCommand}`
+    );
+  },
+};

package/src/agents/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Agent Adapters Module
+ *
+ * Re-exports all agent-related types and functions
+ */
+
+export * from "./types";
+export * from "./registry";
+
+// Individual adapters (for direct access if needed)
+export { claudeAdapter } from "./claude";
+export { ampAdapter } from "./amp";
+export { opencodeAdapter } from "./opencode";
+export { codexAdapter } from "./codex";
+export { droidAdapter } from "./droid";
+export { geminiAdapter } from "./gemini";

package/src/agents/opencode.ts

@@ -0,0 +1,88 @@
+/**
+ * OpenCode Agent Adapter
+ *
+ * Adapter for the OpenCode CLI
+ * https://opencode.ai
+ */
+
+import type { AgentAdapter, AgentResult, InvokeOptions, RateLimitInfo } from "./types";
+
+export const opencodeAdapter: AgentAdapter = {
+  name: "opencode",
+  displayName: "OpenCode",
+  hasSkillSupport: false, // Uses agent system, different from skills
+
+  async isInstalled(): Promise<boolean> {
+    try {
+      const path = await this.getExecutablePath();
+      return path !== null;
+    } catch {
+      return false;
+    }
+  },
+
+  async getExecutablePath(): Promise<string | null> {
+    try {
+      const proc = Bun.spawn(["which", "opencode"], { stdout: "pipe" });
+      const output = await new Response(proc.stdout).text();
+      const exitCode = await proc.exited;
+      if (exitCode === 0 && output.trim()) {
+        return output.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  },
+
+  async invoke(prompt: string, options?: InvokeOptions): Promise<AgentResult> {
+    const startTime = Date.now();
+
+    // OpenCode uses `opencode run "message"` for non-interactive mode
+    const proc = Bun.spawn(["opencode", "run", prompt], {
+      cwd: options?.workingDirectory,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Collect output
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+
+    const output = stdout + (stderr ? `\n${stderr}` : "");
+    const duration = Date.now() - startTime;
+
+    return {
+      output,
+      exitCode,
+      isComplete: this.detectCompletion(output),
+      duration,
+    };
+  },
+
+  detectCompletion(output: string): boolean {
+    return output.includes("<promise>COMPLETE</promise>");
+  },
+
+  detectRateLimit(output: string): RateLimitInfo {
+    // OpenCode rate limit patterns
+    const patterns = [
+      /rate limited/i,
+      /try again later/i,
+      /quota exceeded/i,
+      /\b429\b/,
+    ];
+
+    for (const pattern of patterns) {
+      if (pattern.test(output)) {
+        return {
+          limited: true,
+          message: "OpenCode rate limit exceeded",
+        };
+      }
+    }
+
+    return { limited: false };
+  },
+};

package/src/agents/registry.ts

@@ -0,0 +1,95 @@
+/**
+ * Agent Registry
+ *
+ * Central registry for all supported AI coding agents.
+ * Provides agent discovery, selection, and health checks.
+ */
+
+import type { AgentAdapter, AgentName } from "./types";
+import { claudeAdapter } from "./claude";
+import { ampAdapter } from "./amp";
+import { opencodeAdapter } from "./opencode";
+import { codexAdapter } from "./codex";
+import { droidAdapter } from "./droid";
+import { geminiAdapter } from "./gemini";
+
+/**
+ * Map of all registered agent adapters
+ */
+export const AGENTS: Record<AgentName, AgentAdapter> = {
+  claude: claudeAdapter,
+  amp: ampAdapter,
+  opencode: opencodeAdapter,
+  codex: codexAdapter,
+  droid: droidAdapter,
+  gemini: geminiAdapter,
+};
+
+/**
+ * Get an agent adapter by name
+ */
+export function getAgent(name: AgentName): AgentAdapter {
+  const agent = AGENTS[name];
+  if (!agent) {
+    throw new Error(`Unknown agent: ${name}`);
+  }
+  return agent;
+}
+
+/**
+ * Get all agent names
+ */
+export function getAllAgentNames(): AgentName[] {
+  return Object.keys(AGENTS) as AgentName[];
+}
+
+/**
+ * Check which agents are installed on the system
+ */
+export async function getInstalledAgents(): Promise<AgentAdapter[]> {
+  const results = await Promise.all(
+    Object.values(AGENTS).map(async (agent) => ({
+      agent,
+      installed: await agent.isInstalled(),
+    }))
+  );
+
+  return results.filter((r) => r.installed).map((r) => r.agent);
+}
+
+/**
+ * Agent health check result
+ */
+export interface AgentHealthResult {
+  name: AgentName;
+  displayName: string;
+  installed: boolean;
+  executablePath: string | null;
+  hasSkillSupport: boolean;
+  skillInstallCommand?: string;
+}
+
+/**
+ * Run health checks on all agents
+ */
+export async function checkAgentHealth(): Promise<AgentHealthResult[]> {
+  const results = await Promise.all(
+    Object.values(AGENTS).map(async (agent) => ({
+      name: agent.name,
+      displayName: agent.displayName,
+      installed: await agent.isInstalled(),
+      executablePath: await agent.getExecutablePath(),
+      hasSkillSupport: agent.hasSkillSupport,
+      skillInstallCommand: agent.skillInstallCommand,
+    }))
+  );
+
+  return results;
+}
+
+/**
+ * Validate that an agent name is valid
+ */
+export function isValidAgentName(name: string): name is AgentName {
+  return name in AGENTS;
+}