wraptc 1.0.2 → 1.0.4

package/src/core/adapters/loader.ts

@@ -0,0 +1,143 @@
+/**
+ * AdapterLoader - Load adapter definitions from files
+ *
+ * Supports loading .ts adapter files from:
+ * - ~/.config/wraptc/adapters/
+ * - ./.wtc/adapters/
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { builtInAdapters } from "./builtin";
+import type { AdapterDefinition } from "./types";
+
+/**
+ * Directories to scan for user adapters (in priority order)
+ */
+const ADAPTER_DIRS = [
+  // User adapters (highest priority)
+  join(process.env.HOME ?? "~", ".config", "wrap-terminalcoder", "adapters"),
+  // Project-local adapters
+  "./.wtc/adapters",
+];
+
+/**
+ * Load a single adapter from a file
+ */
+async function loadAdapterFile(filePath: string): Promise<AdapterDefinition | null> {
+  try {
+    // Only support .ts files (TypeScript only approach)
+    if (!filePath.endsWith(".ts") && !filePath.endsWith(".js")) {
+      return null;
+    }
+
+    // Skip test files and declaration files
+    if (filePath.includes(".test.") || filePath.endsWith(".d.ts")) {
+      return null;
+    }
+
+    // Dynamic import the adapter
+    const module = await import(filePath);
+    const adapter = module.default as AdapterDefinition;
+
+    // Validate minimal requirements
+    if (!adapter || !adapter.id || !adapter.binary) {
+      console.warn(`Invalid adapter at ${filePath}: missing id or binary`);
+      return null;
+    }
+
+    return adapter;
+  } catch (err) {
+    console.warn(`Failed to load adapter from ${filePath}:`, err);
+    return null;
+  }
+}
+
+/**
+ * Load all adapters from a directory
+ */
+async function loadAdaptersFromDir(dir: string): Promise<Map<string, AdapterDefinition>> {
+  const adapters = new Map<string, AdapterDefinition>();
+
+  const resolvedDir = dir.startsWith(".") ? join(process.cwd(), dir) : dir;
+
+  if (!existsSync(resolvedDir)) {
+    return adapters;
+  }
+
+  try {
+    const glob = new Bun.Glob("*.ts");
+
+    for await (const file of glob.scan(resolvedDir)) {
+      const filePath = join(resolvedDir, file);
+      const adapter = await loadAdapterFile(filePath);
+
+      if (adapter) {
+        adapters.set(adapter.id, adapter);
+      }
+    }
+  } catch (err) {
+    console.warn(`Failed to scan adapter directory ${resolvedDir}:`, err);
+  }
+
+  return adapters;
+}
+
+/**
+ * Load all user adapters from configured directories
+ */
+export async function loadUserAdapters(): Promise<Map<string, AdapterDefinition>> {
+  const adapters = new Map<string, AdapterDefinition>();
+
+  // Load from each directory (later directories override earlier ones)
+  for (const dir of ADAPTER_DIRS) {
+    const dirAdapters = await loadAdaptersFromDir(dir);
+    for (const [id, adapter] of dirAdapters) {
+      adapters.set(id, adapter);
+    }
+  }
+
+  return adapters;
+}
+
+/**
+ * Load all adapters (built-in + user)
+ *
+ * User adapters override built-in adapters with the same ID
+ */
+export async function loadAllAdapters(): Promise<Map<string, AdapterDefinition>> {
+  const adapters = new Map<string, AdapterDefinition>();
+
+  // Add built-in adapters first
+  for (const adapter of builtInAdapters) {
+    adapters.set(adapter.id, adapter);
+  }
+
+  // Load user adapters (override built-in)
+  const userAdapters = await loadUserAdapters();
+  for (const [id, adapter] of userAdapters) {
+    adapters.set(id, adapter);
+  }
+
+  return adapters;
+}
+
+/**
+ * Get adapter directories being scanned
+ */
+export function getAdapterDirectories(): string[] {
+  return ADAPTER_DIRS.map((dir) => (dir.startsWith(".") ? join(process.cwd(), dir) : dir));
+}
+
+/**
+ * Ensure user adapter directory exists
+ */
+export async function ensureUserAdapterDir(): Promise<string> {
+  const userDir = join(process.env.HOME ?? "~", ".config", "wrap-terminalcoder", "adapters");
+
+  if (!existsSync(userDir)) {
+    await Bun.$`mkdir -p ${userDir}`.quiet();
+  }
+
+  return userDir;
+}

package/src/core/adapters/provider-bridge.ts

@@ -0,0 +1,190 @@
+/**
+ * AdapterProviderBridge - Wrap adapters as Provider interface
+ *
+ * Enables adapters to work with the existing Router and ProviderFactory
+ * for backward compatibility.
+ */
+
+import type { Provider, ProviderInvokeOptions } from "../providers/index";
+import type {
+  CodingEvent,
+  CodingRequest,
+  ProviderErrorContext,
+  ProviderErrorKind,
+  ProviderInfo,
+} from "../types";
+import { AdapterError, AdapterRunner } from "./runner";
+import type { AdapterDefinition } from "./types";
+
+/**
+ * Bridge that wraps an AdapterDefinition as a Provider
+ */
+export class AdapterProviderBridge implements Provider {
+  readonly id: string;
+  readonly displayName: string;
+  readonly supportsStreaming: boolean;
+  readonly prefersJson: boolean;
+  readonly capabilities?: string[];
+
+  private runner: AdapterRunner;
+  private def: AdapterDefinition;
+
+  constructor(definition: AdapterDefinition) {
+    this.def = definition;
+    this.runner = new AdapterRunner(definition);
+
+    this.id = definition.id;
+    this.displayName = definition.displayName ?? definition.id;
+    this.supportsStreaming = (definition.streaming ?? "none") !== "none";
+    this.prefersJson = definition.output === "json";
+    this.capabilities = definition.capabilities;
+  }
+
+  /**
+   * Run the adapter once (non-streaming)
+   */
+  async runOnce(
+    req: CodingRequest,
+    opts: ProviderInvokeOptions,
+  ): Promise<{
+    text: string;
+    usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number };
+  }> {
+    try {
+      const result = await this.runner.run(req.prompt, {
+        signal: opts.signal,
+        cwd: opts.cwd,
+        env: opts.env,
+        timeoutMs: opts.timeoutMs,
+      });
+
+      return {
+        text: result.text,
+        usage: result.usage,
+      };
+    } catch (err) {
+      // Re-throw adapter errors with proper context
+      if (err instanceof AdapterError) {
+        throw err;
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * Run the adapter with streaming
+   */
+  async *runStream(req: CodingRequest, opts: ProviderInvokeOptions): AsyncGenerator<CodingEvent> {
+    const requestId = crypto.randomUUID();
+
+    yield {
+      type: "start",
+      provider: this.id,
+      requestId,
+    };
+
+    try {
+      for await (const chunk of this.runner.runStream(req.prompt, {
+        signal: opts.signal,
+        cwd: opts.cwd,
+        env: opts.env,
+        timeoutMs: opts.timeoutMs,
+      })) {
+        switch (chunk.type) {
+          case "start":
+            // Already emitted start, skip
+            break;
+
+          case "text":
+            yield { type: "text_delta", text: chunk.content };
+            break;
+
+          case "json":
+            yield { type: "chunk", data: chunk.data };
+            break;
+
+          case "complete":
+            yield {
+              type: "complete",
+              provider: this.id,
+              text: chunk.text,
+              usage: chunk.usage,
+            };
+            break;
+
+          case "error":
+            yield {
+              type: "error",
+              provider: this.id,
+              code: chunk.kind,
+              message: chunk.message,
+            };
+            break;
+        }
+      }
+    } catch (err) {
+      const error = err as Error;
+      const kind =
+        err instanceof AdapterError ? err.kind : this.classifyError({ stderr: error.message });
+
+      yield {
+        type: "error",
+        provider: this.id,
+        code: kind,
+        message: error.message,
+      };
+    }
+  }
+
+  /**
+   * Classify an error
+   */
+  classifyError(error: ProviderErrorContext): ProviderErrorKind {
+    const combined = ((error.stderr ?? "") + (error.stdout ?? "")).toLowerCase();
+
+    // Check adapter-specific patterns first
+    if (this.def.errorPatterns) {
+      for (const [kind, patterns] of Object.entries(this.def.errorPatterns)) {
+        if (patterns?.some((p) => combined.includes(p.toLowerCase()))) {
+          return kind as ProviderErrorKind;
+        }
+      }
+    }
+
+    // Fall back to generic classification
+    if (combined.includes("rate limit") || combined.includes("429")) {
+      return "RATE_LIMIT";
+    }
+    if (combined.includes("unauthorized") || combined.includes("401")) {
+      return "UNAUTHORIZED";
+    }
+    if (combined.includes("quota") || combined.includes("credits")) {
+      return "OUT_OF_CREDITS";
+    }
+    if (combined.includes("timeout")) {
+      return "TIMEOUT";
+    }
+
+    return "TRANSIENT";
+  }
+
+  /**
+   * Get provider info
+   */
+  getInfo(): ProviderInfo {
+    return {
+      id: this.id,
+      displayName: this.displayName,
+      supportsStreaming: this.supportsStreaming,
+      prefersJson: this.prefersJson,
+      capabilities: this.capabilities,
+    };
+  }
+}
+
+/**
+ * Create a Provider from an AdapterDefinition
+ */
+export function createProviderFromAdapter(definition: AdapterDefinition): Provider {
+  return new AdapterProviderBridge(definition);
+}