wraptc 1.0.2 → 1.0.4

package/src/core/providers/opencode.ts

@@ -0,0 +1,168 @@
+import { createErrorClassifier } from "../error-patterns";
+/**
+ * OpenCodeProvider - Provider for OpenCode agent delegation
+ *
+ * Uses 'opencode agent run' command with JSON output.
+ * Provider ID: 'opencode' (also aliased as 'delegate' for compatibility)
+ *
+ * Key features:
+ * - Runs via `opencode agent run <prompt> -f json -q`
+ * - Supports file context via prompt injection
+ * - JSON output parsing with summary extraction
+ * - Files changed detection from output
+ */
+import type {
+  CodingRequest,
+  ProviderConfig,
+  ProviderErrorContext,
+  ProviderErrorKind,
+  ProviderInvokeOptions,
+  TokenUsage,
+} from "../types";
+import { ProcessProvider } from "./index";
+
+// OpenCode-specific error patterns (extend defaults)
+const OPENCODE_SPECIFIC_PATTERNS: Partial<Record<ProviderErrorKind, string[]>> = {
+  RATE_LIMIT: ["api limit exceeded"],
+};
+
+// Create classifier with OpenCode-specific patterns merged with defaults
+const classifyOpenCodeError = createErrorClassifier(OPENCODE_SPECIFIC_PATTERNS);
+
+export class OpenCodeProvider extends ProcessProvider {
+  constructor(config: ProviderConfig) {
+    super("opencode", "OpenCode Agent", {
+      ...config,
+      binary: config.binary || "opencode",
+      // OpenCode uses -f json for JSON output
+      jsonMode: "flag",
+      jsonFlag: "-f",
+      streamingMode: "none", // OpenCode doesn't support streaming
+      capabilities: config.capabilities || ["generate", "edit", "explain", "test", "refactor"],
+    });
+  }
+
+  /**
+   * OpenCode uses positional prompt with args, not stdin
+   */
+  protected getStdinInput(): string | undefined {
+    return undefined;
+  }
+
+  /**
+   * Build args: opencode agent run <prompt> -f json -q
+   */
+  protected buildArgs(req: CodingRequest, _opts: ProviderInvokeOptions): string[] {
+    const args: string[] = ["agent", "run"];
+
+    // Build prompt with file context if provided
+    let prompt = req.prompt;
+    if (req.files && req.files.length > 0) {
+      const fileList = req.files.map((f) => (typeof f === "string" ? f : f.path)).join("\n");
+      prompt = `${prompt}\n\nFiles to consider:\n${fileList}`;
+    }
+
+    args.push(prompt);
+
+    // Add JSON output flag and quiet mode
+    args.push("-f", "json", "-q");
+
+    // Add any additional args from config
+    args.push(...this.config.args);
+
+    return args;
+  }
+
+  /**
+   * Parse OpenCode JSON output to extract text and usage
+   */
+  protected parseOutput(stdout: string): { text: string; usage?: TokenUsage } {
+    try {
+      const output = JSON.parse(stdout);
+
+      // Extract text from various possible fields
+      const text =
+        output.summary ||
+        output.response ||
+        output.message ||
+        output.output ||
+        output.text ||
+        this.extractSummaryFromText(stdout);
+
+      return {
+        text,
+        usage: output.usage,
+      };
+    } catch {
+      // Not JSON, extract summary from plain text
+      return {
+        text: this.extractSummaryFromText(stdout),
+      };
+    }
+  }
+
+  /**
+   * Extract a summary from plain text output
+   */
+  private extractSummaryFromText(stdout: string): string {
+    const lines = stdout.split("\n").filter((l) => l.trim());
+
+    // Look for summary-like patterns
+    for (const line of lines) {
+      if (line.match(/completed|fixed|added|updated|created|implemented/i)) {
+        return line.substring(0, 500);
+      }
+    }
+
+    // Fallback: first non-empty line or truncated output
+    return lines[0]?.substring(0, 500) || stdout.substring(0, 500);
+  }
+
+  /**
+   * Classify errors with OpenCode-specific patterns merged with defaults
+   */
+  classifyError(error: ProviderErrorContext): ProviderErrorKind {
+    return classifyOpenCodeError(error.stderr, error.stdout, error.exitCode);
+  }
+
+  /**
+   * Extract files changed from OpenCode output (for result enrichment)
+   */
+  extractFilesChanged(stdout: string): string[] {
+    const files: string[] = [];
+
+    const filePatterns = [
+      /(?:modified|changed|updated|created|edited):\s*([^\s]+)/gi,
+      /File:\s*([^\s]+)/gi,
+      /→\s*([^\s]+\.[a-z]{2,4})/gi,
+      /```[\w]*\s*([^\s]+)/gi,
+      /\[.*?\]\(([^)]+\.[a-z]{2,4})\)/gi,
+    ];
+
+    for (const pattern of filePatterns) {
+      const matches = stdout.matchAll(pattern);
+      for (const match of matches) {
+        if (match[1]) {
+          files.push(match[1]);
+        }
+      }
+    }
+
+    return [...new Set(files)];
+  }
+}
+
+/**
+ * Create an OpenCode provider with default or custom config
+ */
+export function createOpenCodeProvider(config?: Partial<ProviderConfig>): OpenCodeProvider {
+  return new OpenCodeProvider({
+    binary: "opencode",
+    args: [],
+    jsonMode: "flag",
+    jsonFlag: "-f",
+    streamingMode: "none",
+    capabilities: ["generate", "edit", "explain", "test", "refactor"],
+    ...config,
+  });
+}

package/src/core/providers/qwen-code.ts

@@ -0,0 +1,41 @@
+/**
+ * QwenCodeProvider - Simplified provider using ProcessProvider defaults
+ *
+ * Qwen Code CLI uses:
+ * - Positional prompt: qwen [options] <prompt>
+ * - JSON output flag: -o json
+ */
+import type { CodingRequest, ProviderConfig, ProviderInvokeOptions } from "../types";
+import { ProcessProvider } from "./index";
+
+export class QwenCodeProvider extends ProcessProvider {
+  constructor(config: ProviderConfig) {
+    super("qwen-code", "Qwen Code CLI", {
+      ...config,
+      binary: config.binary || "qwen",
+    });
+  }
+
+  /**
+   * Qwen uses positional prompt (not stdin), so override getStdinInput
+   */
+  protected getStdinInput(): string | undefined {
+    return undefined; // Qwen uses positional prompt
+  }
+
+  /**
+   * Build args: qwen -o json [...args] <prompt>
+   */
+  protected buildArgs(req: CodingRequest, _opts: ProviderInvokeOptions): string[] {
+    const args: string[] = [];
+
+    if (this.config.jsonMode === "flag") {
+      args.push("-o", "json");
+    }
+
+    args.push(...this.config.args);
+    args.push(req.prompt);
+
+    return args;
+  }
+}

package/src/core/router.ts

@@ -0,0 +1,370 @@
+import type { Provider } from "./providers/index";
+import type { StateManager } from "./state";
+import type {
+  CodingRequest,
+  CodingResponse,
+  ProviderErrorContext,
+  ProviderErrorKind,
+} from "./types";
+import type { Config } from "./types";
+
+export interface RouterOptions {
+  config: Config;
+  stateManager: StateManager;
+}
+
+/**
+ * Extended Map interface that supports async provider loading
+ */
+interface AsyncProviderMap extends Map<string, Provider> {
+  getAsync?(key: string): Promise<Provider | null>;
+}
+
+export class Router {
+  private providers: AsyncProviderMap;
+  private config: Config;
+  private stateManager: StateManager;
+
+  constructor(providers: AsyncProviderMap, options: RouterOptions) {
+    this.providers = providers;
+    this.config = options.config;
+    this.stateManager = options.stateManager;
+  }
+
+  /**
+   * Get a provider, supporting both sync and async loading
+   */
+  private async getProvider(id: string): Promise<Provider | null> {
+    // Try async loading first (for lazy-loaded providers)
+    if (this.providers.getAsync) {
+      return this.providers.getAsync(id);
+    }
+    // Fall back to sync get
+    return this.providers.get(id) || null;
+  }
+
+  async route(
+    req: CodingRequest,
+    opts: { signal?: AbortSignal; cwd?: string } = {},
+  ): Promise<CodingResponse> {
+    const startTime = Date.now();
+
+    // Build candidate list
+    const candidates = this.getCandidateProviders(req);
+    if (candidates.length === 0) {
+      throw new Error(
+        "No providers configured. Add providers to your config or check your routing.defaultOrder setting.",
+      );
+    }
+
+    // Try each provider in order
+    const errors: Array<{ provider: string; error: Error; kind: ProviderErrorKind }> = [];
+
+    for (const providerId of candidates) {
+      const provider = await this.getProvider(providerId);
+      if (!provider) {
+        errors.push({
+          provider: providerId,
+          error: new Error(`Provider ${providerId} not found or unavailable`),
+          kind: "NOT_FOUND",
+        });
+        continue;
+      }
+
+      // Check if provider is marked as out of credits
+      const state = await this.stateManager.getProviderState(providerId);
+      if (state.outOfCreditsUntil && new Date(state.outOfCreditsUntil) > new Date()) {
+        errors.push({
+          provider: providerId,
+          error: new Error(
+            `Provider ${providerId} is out of credits until ${state.outOfCreditsUntil}`,
+          ),
+          kind: "OUT_OF_CREDITS",
+        });
+        continue;
+      }
+
+      // Check daily limit
+      const creditConfig = this.config.credits.providers[providerId];
+      if (
+        creditConfig &&
+        "dailyRequestLimit" in creditConfig &&
+        state.requestsToday >= creditConfig.dailyRequestLimit
+      ) {
+        // Mark as out of credits for rest of day
+        const tomorrow = new Date();
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        tomorrow.setHours(0, 0, 0, 0);
+        await this.stateManager.markOutOfCredits(providerId, tomorrow);
+
+        errors.push({
+          provider: providerId,
+          error: new Error(`Daily request limit exceeded for ${providerId}`),
+          kind: "OUT_OF_CREDITS",
+        });
+        continue;
+      }
+
+      try {
+        // Execute request
+        const result = await provider.runOnce(req, opts);
+
+        // Update state on success, including token usage
+        const tokensSaved = result.usage?.totalTokens ?? result.usage?.outputTokens ?? 0;
+        await this.stateManager.recordSuccess(providerId, tokensSaved);
+
+        return {
+          provider: providerId,
+          text: result.text,
+          usage: result.usage,
+          meta: {
+            elapsedMs: Date.now() - startTime,
+          },
+        };
+      } catch (error) {
+        const err = error as Error;
+        const context: ProviderErrorContext = {
+          exitCode: "exitCode" in err ? (err as any).exitCode : undefined,
+          stderr: err.message,
+          stdout: "stdout" in err ? (err as any).stdout : undefined,
+        };
+
+        const errorKind = provider.classifyError(context);
+
+        // Update state based on error
+        await this.stateManager.recordError(providerId, errorKind, err.message);
+
+        // For OUT_OF_CREDITS or RATE_LIMIT, mark provider as unavailable for cooldown
+        if (errorKind === "OUT_OF_CREDITS" || errorKind === "RATE_LIMIT") {
+          const cooldownTime = new Date(Date.now() + 60 * 60 * 1000); // 1 hour
+          await this.stateManager.markOutOfCredits(providerId, cooldownTime);
+        }
+
+        // Errors that should fail immediately (user needs to fix request/config)
+        if (errorKind === "BAD_REQUEST") {
+          throw new Error(
+            `Bad request to ${providerId}: ${err.message}. Check your prompt and options.`,
+          );
+        }
+        if (errorKind === "UNAUTHORIZED") {
+          throw new Error(
+            `Unauthorized for ${providerId}: ${err.message}. Check your API key or authentication.`,
+          );
+        }
+        if (errorKind === "FORBIDDEN") {
+          throw new Error(
+            `Access denied for ${providerId}: ${err.message}. Check your permissions or subscription.`,
+          );
+        }
+        if (errorKind === "CONTEXT_LENGTH") {
+          throw new Error(
+            `Context too long for ${providerId}: ${err.message}. Try a shorter prompt or fewer files.`,
+          );
+        }
+        if (errorKind === "CONTENT_FILTER") {
+          throw new Error(
+            `Content filtered by ${providerId}: ${err.message}. Rephrase your prompt to avoid policy violations.`,
+          );
+        }
+
+        // For other errors, log and continue to next provider
+        errors.push({ provider: providerId, error: err, kind: errorKind });
+      }
+    }
+
+    // All providers failed
+    const errorSummary = errors
+      .map((e) => `${e.provider} (${e.kind}): ${e.error.message}`)
+      .join("; ");
+    throw new Error(
+      `All ${errors.length} providers failed. Tried: ${candidates.join(", ")}. Details: ${errorSummary}`,
+    );
+  }
+
+  async *routeStream(
+    req: CodingRequest,
+    opts: { signal?: AbortSignal; cwd?: string } = {},
+  ): AsyncGenerator<CodingResponse> {
+    const startTime = Date.now();
+
+    // Build candidate list
+    const candidates = this.getCandidateProviders(req);
+    if (candidates.length === 0) {
+      throw new Error(
+        "No providers configured. Add providers to your config or check your routing.defaultOrder setting.",
+      );
+    }
+
+    // Try each provider in order
+    const errors: Array<{ provider: string; error: Error; kind: ProviderErrorKind }> = [];
+
+    for (const providerId of candidates) {
+      const provider = await this.getProvider(providerId);
+      if (!provider) {
+        errors.push({
+          provider: providerId,
+          error: new Error(`Provider ${providerId} not found or unavailable`),
+          kind: "NOT_FOUND",
+        });
+        continue;
+      }
+
+      // Check if provider is marked as out of credits
+      const state = await this.stateManager.getProviderState(providerId);
+      if (state.outOfCreditsUntil && new Date(state.outOfCreditsUntil) > new Date()) {
+        errors.push({
+          provider: providerId,
+          error: new Error(
+            `Provider ${providerId} is out of credits until ${state.outOfCreditsUntil}`,
+          ),
+          kind: "OUT_OF_CREDITS",
+        });
+        continue;
+      }
+
+      // Check daily limit
+      const creditConfig = this.config.credits.providers[providerId];
+      if (
+        creditConfig &&
+        "dailyRequestLimit" in creditConfig &&
+        state.requestsToday >= creditConfig.dailyRequestLimit
+      ) {
+        const tomorrow = new Date();
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        tomorrow.setHours(0, 0, 0, 0);
+        await this.stateManager.markOutOfCredits(providerId, tomorrow);
+
+        errors.push({
+          provider: providerId,
+          error: new Error(`Daily request limit exceeded for ${providerId}`),
+          kind: "OUT_OF_CREDITS",
+        });
+        continue;
+      }
+
+      try {
+        const fullText = "";
+
+        // Execute streaming request
+        for await (const event of provider.runStream(req, opts)) {
+          if (event.type === "complete") {
+            // Record success with token usage
+            const tokensSaved = event.usage?.totalTokens ?? event.usage?.outputTokens ?? 0;
+            await this.stateManager.recordSuccess(providerId, tokensSaved);
+            yield {
+              provider: providerId,
+              text: event.text,
+              usage: event.usage,
+              meta: {
+                elapsedMs: Date.now() - startTime,
+              },
+            };
+            return; // Success, exit generator
+          }
+          // Pass through events (could be extended to yield events too)
+        }
+      } catch (error) {
+        const err = error as Error;
+        const context: ProviderErrorContext = {
+          exitCode: "exitCode" in err ? (err as any).exitCode : undefined,
+          stderr: err.message,
+          stdout: "stdout" in err ? (err as any).stdout : undefined,
+        };
+
+        const errorKind = provider.classifyError(context);
+        await this.stateManager.recordError(providerId, errorKind, err.message);
+
+        if (errorKind === "OUT_OF_CREDITS" || errorKind === "RATE_LIMIT") {
+          const cooldownTime = new Date(Date.now() + 60 * 60 * 1000);
+          await this.stateManager.markOutOfCredits(providerId, cooldownTime);
+        }
+
+        // Errors that should fail immediately (user needs to fix request/config)
+        if (errorKind === "BAD_REQUEST") {
+          throw new Error(
+            `Bad request to ${providerId}: ${err.message}. Check your prompt and options.`,
+          );
+        }
+        if (errorKind === "UNAUTHORIZED") {
+          throw new Error(
+            `Unauthorized for ${providerId}: ${err.message}. Check your API key or authentication.`,
+          );
+        }
+        if (errorKind === "FORBIDDEN") {
+          throw new Error(
+            `Access denied for ${providerId}: ${err.message}. Check your permissions or subscription.`,
+          );
+        }
+        if (errorKind === "CONTEXT_LENGTH") {
+          throw new Error(
+            `Context too long for ${providerId}: ${err.message}. Try a shorter prompt or fewer files.`,
+          );
+        }
+        if (errorKind === "CONTENT_FILTER") {
+          throw new Error(
+            `Content filtered by ${providerId}: ${err.message}. Rephrase your prompt to avoid policy violations.`,
+          );
+        }
+
+        errors.push({ provider: providerId, error: err, kind: errorKind });
+      }
+    }
+
+    // All providers failed
+    const errorSummary = errors
+      .map((e) => `${e.provider} (${e.kind}): ${e.error.message}`)
+      .join("; ");
+    throw new Error(
+      `All ${errors.length} providers failed. Tried: ${candidates.join(", ")}. Details: ${errorSummary}`,
+    );
+  }
+
+  private getCandidateProviders(req: CodingRequest): string[] {
+    // If provider is explicitly specified, use only that provider
+    if (req.provider) {
+      return [req.provider];
+    }
+
+    // Check for per-mode override
+    const mode = req.mode || "generate";
+    if (this.config.routing.perModeOverride?.[mode]) {
+      return this.config.routing.perModeOverride[mode];
+    }
+
+    // Use default order
+    return this.config.routing.defaultOrder;
+  }
+
+  async getProviderInfo(): Promise<
+    Array<{
+      id: string;
+      displayName: string;
+      outOfCreditsUntil?: Date;
+      requestsToday: number;
+      available: boolean;
+    }>
+  > {
+    const info: Array<{
+      id: string;
+      displayName: string;
+      outOfCreditsUntil?: Date;
+      requestsToday: number;
+      available: boolean;
+    }> = [];
+
+    for (const providerId of this.providers.keys()) {
+      const provider = await this.getProvider(providerId);
+      const state = await this.stateManager.getProviderState(providerId);
+
+      info.push({
+        id: providerId,
+        displayName: provider?.displayName || providerId,
+        outOfCreditsUntil: state.outOfCreditsUntil ? new Date(state.outOfCreditsUntil) : undefined,
+        requestsToday: state.requestsToday,
+        available: !!provider,
+      });
+    }
+
+    return info;
+  }
+}