wraptc 1.0.2 → 1.0.4

package/src/core/providers/custom.ts

@@ -0,0 +1,261 @@
+import { classifyErrorDefault } from "../error-patterns";
+import type {
+  CodingEvent,
+  CodingRequest,
+  ProviderConfig,
+  ProviderErrorContext,
+  ProviderErrorKind,
+} from "../types";
+import { BaseProvider, type ProviderInvokeOptions } from "./index";
+
+export class CustomProvider extends BaseProvider {
+  // Configurable output size limit (default 100MB)
+  private readonly maxOutputSize: number = 100 * 1024 * 1024;
+
+  constructor(id: string, config: ProviderConfig) {
+    super(id, id, config);
+  }
+
+  async runOnce(
+    req: CodingRequest,
+    opts: ProviderInvokeOptions,
+  ): Promise<{
+    text: string;
+    usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+  }> {
+    const args = this.buildArgs(req, opts);
+    const needsStdin = !this.config.argsTemplate || !args.some((arg) => arg.includes(req.prompt));
+
+    // Use Bun.spawn() for better performance
+    const proc = Bun.spawn([this.config.binary, ...args], {
+      cwd: opts?.cwd,
+      stdin: needsStdin && req.prompt ? "pipe" : "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send prompt to stdin if not using template
+    if (needsStdin && req.prompt && proc.stdin) {
+      proc.stdin.write(req.prompt);
+      proc.stdin.end();
+    }
+
+    // Set up abort handler
+    if (opts?.signal) {
+      opts.signal.addEventListener("abort", () => {
+        proc.kill();
+      });
+    }
+
+    // Use array buffering instead of string concatenation
+    const stdoutChunks: string[] = [];
+    const stderrChunks: string[] = [];
+    let totalSize = 0;
+
+    // Read stdout with size limit
+    if (proc.stdout) {
+      const reader = proc.stdout.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const text = decoder.decode(value, { stream: true });
+          stdoutChunks.push(text);
+          totalSize += text.length;
+          if (totalSize > this.maxOutputSize) {
+            proc.kill();
+            throw new Error(`Output exceeded maximum size limit of ${this.maxOutputSize} bytes`);
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    // Read stderr
+    if (proc.stderr) {
+      const reader = proc.stderr.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          stderrChunks.push(decoder.decode(value, { stream: true }));
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    // Wait for process to exit
+    const exitCode = await proc.exited;
+
+    // Check if aborted
+    if (opts?.signal?.aborted) {
+      throw new Error("Aborted");
+    }
+
+    const stdout = stdoutChunks.join("");
+    const stderr = stderrChunks.join("");
+
+    if (exitCode === 0) {
+      if (this.config.jsonMode !== "none") {
+        return this.parseJsonOutput(stdout);
+      }
+      return { text: stdout };
+    }
+
+    throw new Error(`${this.displayName} CLI failed with code ${exitCode}: ${stderr}`);
+  }
+
+  async *runStream(req: CodingRequest, opts: ProviderInvokeOptions): AsyncGenerator<CodingEvent> {
+    const requestId = crypto.randomUUID();
+    yield { type: "start", provider: this.id, requestId };
+
+    const args = this.buildArgs(req, opts);
+    const needsStdin =
+      !this.config.argsTemplate ||
+      !this.config.argsTemplate.some((arg) => arg.includes("{{prompt}}"));
+
+    // Use Bun.spawn() for streaming
+    const proc = Bun.spawn([this.config.binary, ...args], {
+      cwd: opts?.cwd,
+      stdin: needsStdin && req.prompt ? "pipe" : "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Send prompt to stdin if not using template
+    if (needsStdin && req.prompt && proc.stdin) {
+      proc.stdin.write(req.prompt);
+      proc.stdin.end();
+    }
+
+    // Use array buffering for fullText instead of string concatenation
+    const fullTextChunks: string[] = [];
+    // Line buffer for handling partial lines in JSONL mode
+    let lineBuffer = "";
+
+    // Stream stdout directly without accumulating
+    if (proc.stdout) {
+      const reader = proc.stdout.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const text = decoder.decode(value, { stream: true });
+          fullTextChunks.push(text);
+
+          if (this.config.streamingMode === "jsonl") {
+            // Buffer partial lines and emit complete lines
+            lineBuffer += text;
+            const lines = lineBuffer.split("\n");
+            // Keep the last (potentially incomplete) line in the buffer
+            lineBuffer = lines.pop() ?? "";
+
+            for (const line of lines.filter(Boolean)) {
+              try {
+                const parsed = JSON.parse(line);
+                yield { type: "chunk", data: parsed };
+              } catch {
+                yield { type: "text_delta", text: line };
+              }
+            }
+          } else if (this.config.streamingMode === "line") {
+            // Emit each line as a text_delta
+            const lines = text.split("\n");
+            for (const line of lines) {
+              if (line.trim()) {
+                yield { type: "text_delta", text: `${line}\n` };
+              }
+            }
+          } else {
+            yield { type: "text_delta", text };
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    // Emit any remaining buffered line
+    if (lineBuffer.trim()) {
+      try {
+        const parsed = JSON.parse(lineBuffer);
+        yield { type: "chunk", data: parsed };
+      } catch {
+        yield { type: "text_delta", text: lineBuffer };
+      }
+    }
+
+    // Collect stderr with array buffering (with 1MB limit)
+    const stderrChunks: string[] = [];
+    let stderrSize = 0;
+    const maxStderrSize = 1024 * 1024; // 1MB limit
+
+    if (proc.stderr) {
+      const reader = proc.stderr.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const text = decoder.decode(value, { stream: true });
+          if (stderrSize + text.length <= maxStderrSize) {
+            stderrChunks.push(text);
+            stderrSize += text.length;
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    // Wait for process to exit
+    const exitCode = await proc.exited;
+    const fullText = fullTextChunks.join("");
+    const stderr = stderrChunks.join("");
+
+    if (exitCode === 0) {
+      const result =
+        this.config.jsonMode !== "none" ? this.parseJsonOutput(fullText) : { text: fullText };
+      yield { type: "complete", provider: this.id, text: result.text, usage: result.usage };
+    } else {
+      yield {
+        type: "error",
+        provider: this.id,
+        code: this.classifyError({ stderr, exitCode: exitCode || undefined }),
+        message: stderr || `Process exited with code ${exitCode}`,
+      };
+    }
+  }
+
+  classifyError(error: ProviderErrorContext): ProviderErrorKind {
+    // Use the shared error classifier from error-patterns.ts
+    return classifyErrorDefault(error.stderr, error.stdout, error.exitCode, error.httpStatus);
+  }
+
+  protected buildArgs(req: CodingRequest, opts: ProviderInvokeOptions): string[] {
+    // If argsTemplate is provided, use it with variable substitution
+    if (this.config.argsTemplate && this.config.argsTemplate.length > 0) {
+      return this.config.argsTemplate.map((arg) => {
+        return arg
+          .replace("{{prompt}}", req.prompt)
+          .replace("{{mode}}", req.mode || "generate")
+          .replace("{{language}}", req.language || "")
+          .replace("{{temperature}}", req.temperature?.toString() || "0.7");
+      });
+    }
+
+    // Otherwise use standard args with optional JSON flag
+    const args = [...this.config.args];
+
+    if (this.config.jsonMode === "flag" && this.config.jsonFlag) {
+      args.push(this.config.jsonFlag);
+    }
+
+    return args;
+  }
+}

package/src/core/providers/gemini.ts

@@ -0,0 +1,41 @@
+/**
+ * GeminiProvider - Simplified provider using ProcessProvider defaults
+ *
+ * Gemini CLI uses:
+ * - Positional prompt: gemini [options] <prompt>
+ * - JSON output flag: -o json
+ */
+import type { CodingRequest, ProviderConfig, ProviderInvokeOptions } from "../types";
+import { ProcessProvider } from "./index";
+
+export class GeminiProvider extends ProcessProvider {
+  constructor(config: ProviderConfig) {
+    super("gemini", "Gemini CLI", {
+      ...config,
+      binary: config.binary || "gemini",
+    });
+  }
+
+  /**
+   * Gemini uses positional prompt (not stdin), so override getStdinInput
+   */
+  protected getStdinInput(): string | undefined {
+    return undefined; // Gemini uses positional prompt
+  }
+
+  /**
+   * Build args: gemini -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/providers/index.ts

@@ -0,0 +1,383 @@
+import { join } from "node:path";
+import { DEFAULT_ERROR_PATTERNS, classifyErrorDefault } from "../error-patterns";
+import type {
+  CodingEvent,
+  CodingRequest,
+  CodingResponse,
+  ProviderConfig,
+  ProviderErrorContext,
+  ProviderErrorKind,
+  ProviderInfo,
+  ProviderInvokeOptions,
+  TokenUsage,
+} from "../types";
+
+// Re-export ProviderInvokeOptions for convenience
+export type { ProviderInvokeOptions };
+
+export interface Provider {
+  readonly id: string;
+  readonly displayName: string;
+  readonly supportsStreaming: boolean;
+  readonly prefersJson: boolean;
+  readonly capabilities?: string[];
+
+  runOnce(
+    req: CodingRequest,
+    opts: ProviderInvokeOptions,
+  ): Promise<{
+    text: string;
+    usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+  }>;
+
+  runStream(req: CodingRequest, opts: ProviderInvokeOptions): AsyncGenerator<CodingEvent>;
+
+  classifyError(error: ProviderErrorContext): ProviderErrorKind;
+
+  getInfo(): ProviderInfo;
+}
+
+export abstract class BaseProvider implements Provider {
+  public readonly id: string;
+  public readonly displayName: string;
+  public readonly supportsStreaming: boolean;
+  public readonly prefersJson: boolean;
+  public readonly capabilities?: string[];
+  protected config: ProviderConfig;
+
+  constructor(id: string, displayName: string, config: ProviderConfig) {
+    this.id = id;
+    this.displayName = displayName;
+    this.config = config;
+    this.supportsStreaming = config.streamingMode !== "none";
+    this.prefersJson = config.jsonMode !== "none";
+    this.capabilities = config.capabilities;
+  }
+
+  // These are implemented in ProcessProvider with defaults
+  // Subclasses can override for custom behavior
+  abstract runOnce(
+    req: CodingRequest,
+    opts: ProviderInvokeOptions,
+  ): Promise<{ text: string; usage?: TokenUsage }>;
+
+  abstract runStream(req: CodingRequest, opts: ProviderInvokeOptions): AsyncGenerator<CodingEvent>;
+
+  abstract classifyError(error: ProviderErrorContext): ProviderErrorKind;
+
+  getInfo(): ProviderInfo {
+    return {
+      id: this.id,
+      displayName: this.displayName,
+      supportsStreaming: this.supportsStreaming,
+      prefersJson: this.prefersJson,
+      capabilities: this.capabilities,
+    };
+  }
+
+  protected async ensureConfigDir(): Promise<string> {
+    const configDir = join(process.env.HOME || "~", ".config", "wrap-terminalcoder");
+    // Use Bun's built-in mkdir via shell
+    await Bun.$`mkdir -p ${configDir}`.quiet();
+    return configDir;
+  }
+
+  protected buildArgs(req: CodingRequest, opts: ProviderInvokeOptions): string[] {
+    const args = [...this.config.args];
+
+    if (this.config.argsTemplate) {
+      return this.config.argsTemplate.map((arg) => {
+        return arg.replace("{{prompt}}", req.prompt);
+      });
+    }
+
+    if (this.config.jsonMode === "flag" && this.config.jsonFlag) {
+      args.push(this.config.jsonFlag);
+    }
+
+    return args;
+  }
+
+  protected parseJsonOutput(stdout: string): {
+    text: string;
+    usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+  } {
+    try {
+      const parsed = JSON.parse(stdout);
+      return {
+        text: parsed.text || parsed.response || parsed.output || stdout,
+        usage: parsed.usage,
+      };
+    } catch {
+      return { text: stdout };
+    }
+  }
+}
+
+export abstract class ProcessProvider extends BaseProvider {
+  protected readonly binaryPath: string;
+  // Configurable output size limit (default 100MB)
+  protected readonly maxOutputSize: number = 100 * 1024 * 1024;
+
+  constructor(id: string, displayName: string, config: ProviderConfig) {
+    super(id, displayName, config);
+    this.binaryPath = config.binary;
+  }
+
+  /**
+   * Check if the binary exists before attempting to spawn a process.
+   * This prevents hanging when the binary is not found.
+   */
+  protected async checkBinaryExists(): Promise<void> {
+    try {
+      await Bun.$`which ${this.binaryPath}`.quiet();
+    } catch {
+      throw new Error(`Binary not found: ${this.binaryPath}`);
+    }
+  }
+
+  protected async executeProcess(
+    args: string[],
+    input?: string,
+    opts?: ProviderInvokeOptions,
+  ): Promise<{ stdout: string; stderr: string; exitCode: number | null }> {
+    // Check if binary exists first to avoid hanging on non-existent binaries
+    await this.checkBinaryExists();
+
+    // Use Bun.spawn() for better performance
+    const proc = Bun.spawn([this.binaryPath, ...args], {
+      cwd: opts?.cwd,
+      stdin: input ? "pipe" : "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Write input to stdin if provided
+    if (input && proc.stdin) {
+      proc.stdin.write(input);
+      proc.stdin.end();
+    }
+
+    // Set up abort handler
+    if (opts?.signal) {
+      opts.signal.addEventListener("abort", () => {
+        proc.kill();
+      });
+    }
+
+    // Read stdout and stderr using Bun's streaming APIs
+    const stdoutChunks: string[] = [];
+    const stderrChunks: string[] = [];
+    let totalSize = 0;
+
+    // Read stdout
+    if (proc.stdout) {
+      const reader = proc.stdout.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const text = decoder.decode(value, { stream: true });
+          stdoutChunks.push(text);
+          totalSize += text.length;
+          if (totalSize > this.maxOutputSize) {
+            proc.kill();
+            throw new Error(`Output exceeded maximum size limit of ${this.maxOutputSize} bytes`);
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    // Read stderr
+    if (proc.stderr) {
+      const reader = proc.stderr.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          stderrChunks.push(decoder.decode(value, { stream: true }));
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    // Wait for process to exit
+    const exitCode = await proc.exited;
+
+    // Check if aborted
+    if (opts?.signal?.aborted) {
+      throw new Error("Aborted");
+    }
+
+    return {
+      stdout: stdoutChunks.join(""),
+      stderr: stderrChunks.join(""),
+      exitCode,
+    };
+  }
+
+  protected async *streamProcess(
+    args: string[],
+    input?: string,
+    opts?: ProviderInvokeOptions,
+  ): AsyncGenerator<{ type: "stdout" | "stderr"; data: string }> {
+    // Check if binary exists first to avoid hanging on non-existent binaries
+    await this.checkBinaryExists();
+
+    // Use Bun.spawn() for streaming
+    const proc = Bun.spawn([this.binaryPath, ...args], {
+      cwd: opts?.cwd,
+      stdin: input ? "pipe" : "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Write input to stdin if provided
+    if (input && proc.stdin) {
+      proc.stdin.write(input);
+      proc.stdin.end();
+    }
+
+    // Stream stdout chunks directly without accumulation
+    if (proc.stdout) {
+      const reader = proc.stdout.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          yield { type: "stdout", data: decoder.decode(value, { stream: true }) };
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    // Collect stderr for error reporting (with 1MB limit)
+    const stderrChunks: string[] = [];
+    let stderrSize = 0;
+    const maxStderrSize = 1024 * 1024; // 1MB limit
+
+    if (proc.stderr) {
+      const reader = proc.stderr.getReader();
+      const decoder = new TextDecoder();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          const text = decoder.decode(value, { stream: true });
+          if (stderrSize + text.length <= maxStderrSize) {
+            stderrChunks.push(text);
+            stderrSize += text.length;
+          }
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+
+    if (stderrChunks.length > 0) {
+      yield { type: "stderr", data: stderrChunks.join("") };
+    }
+
+    // Wait for process to complete
+    await proc.exited;
+  }
+
+  /**
+   * Default runOnce implementation.
+   * Subclasses can override for custom behavior.
+   */
+  async runOnce(
+    req: CodingRequest,
+    opts: ProviderInvokeOptions,
+  ): Promise<{ text: string; usage?: TokenUsage }> {
+    const args = this.buildArgs(req, opts);
+    const input = this.getStdinInput(req);
+    const result = await this.executeProcess(args, input, opts);
+
+    if (result.exitCode !== 0) {
+      throw new Error(`${this.displayName} failed with code ${result.exitCode}: ${result.stderr}`);
+    }
+
+    return this.parseOutput(result.stdout);
+  }
+
+  /**
+   * Default runStream implementation.
+   * Subclasses can override for custom behavior.
+   */
+  async *runStream(req: CodingRequest, opts: ProviderInvokeOptions): AsyncGenerator<CodingEvent> {
+    const requestId = crypto.randomUUID();
+    yield { type: "start", provider: this.id, requestId };
+
+    const args = this.buildArgs(req, opts);
+    const input = this.getStdinInput(req);
+    const fullTextChunks: string[] = [];
+
+    for await (const chunk of this.streamProcess(args, input, opts)) {
+      if (chunk.type === "stdout") {
+        const text = chunk.data;
+        fullTextChunks.push(text);
+
+        if (this.config.streamingMode === "jsonl") {
+          // Try to parse as JSONL
+          for (const line of text.split("\n").filter(Boolean)) {
+            try {
+              const parsed = JSON.parse(line);
+              yield { type: "chunk", data: parsed };
+            } catch {
+              yield { type: "text_delta", text: line };
+            }
+          }
+        } else {
+          yield { type: "text_delta", text };
+        }
+      } else if (chunk.type === "stderr") {
+        yield {
+          type: "error",
+          provider: this.id,
+          code: this.classifyError({ stderr: chunk.data }),
+          message: chunk.data,
+        };
+      }
+    }
+
+    const fullText = fullTextChunks.join("");
+    const result = this.parseOutput(fullText);
+    yield { type: "complete", provider: this.id, text: result.text, usage: result.usage };
+  }
+
+  /**
+   * Default error classification using shared classifyErrorDefault.
+   * Subclasses can override for provider-specific patterns.
+   */
+  classifyError(error: ProviderErrorContext): ProviderErrorKind {
+    return classifyErrorDefault(error.stderr, error.stdout, error.exitCode, error.httpStatus);
+  }
+
+  /**
+   * Get stdin input for the process.
+   * Override in subclass if needed.
+   */
+  protected getStdinInput(req: CodingRequest): string | undefined {
+    // Default: pipe prompt to stdin
+    return req.prompt;
+  }
+
+  /**
+   * Parse output from the process.
+   * Override in subclass if needed.
+   */
+  protected parseOutput(stdout: string): { text: string; usage?: TokenUsage } {
+    if (this.config.jsonMode !== "none") {
+      return this.parseJsonOutput(stdout);
+    }
+    return { text: stdout.trim() };
+  }
+}