wraptc 1.0.2 → 1.0.4

package/src/core/index.ts

@@ -0,0 +1,130 @@
+// Main entry point for wrap-terminalcoder core
+export * from "./wrap-terminalcoder";
+export * from "./router";
+export * from "./config";
+export * from "./state";
+export * from "./types";
+export * from "./memory-monitor";
+export * from "./provider-factory";
+
+// Provider exports
+export * from "./providers/index";
+export { CustomProvider } from "./providers/custom";
+export { ConfigurableProvider, createConfigurableProvider } from "./providers/configurable";
+export { GeminiProvider } from "./providers/gemini";
+export { QwenCodeProvider } from "./providers/qwen-code";
+export { CodexProvider } from "./providers/codex";
+
+// Provider definition helper - for creating custom providers via .ts config files
+export {
+  defineProvider,
+  type ProviderDefinition,
+  type ProviderDefinitionInput,
+  ProviderDefinitionSchema,
+  InputConfigSchema,
+  OutputConfigSchema,
+  StreamingConfigSchema,
+  ArgsConfigSchema,
+  RetryConfigSchema,
+  ErrorPatternsSchema,
+  DEFAULT_ERROR_PATTERNS,
+} from "./define-provider";
+
+// Provider loader - for loading .ts config files
+export {
+  loadProviderConfigs,
+  getProviderDirectories,
+  ensureUserProviderDir,
+} from "./provider-loader";
+
+// ============================================================================
+// NEW: Adapter System - Lightweight terminal coder wrappers
+// ============================================================================
+export {
+  // Types
+  type AdapterConfig,
+  type AdapterDefinition,
+  type AdapterHooks,
+  type AdapterInvokeOptions,
+  type AdapterResult,
+  type AdapterInfo,
+  type InputMethod,
+  type OutputFormat,
+  type StreamingMode,
+  type StreamChunk,
+  type ErrorPatterns,
+  // Core functionality
+  defineAdapter,
+  AdapterRunner,
+  AdapterError,
+  // Loading
+  loadUserAdapters,
+  loadAllAdapters,
+  getAdapterDirectories,
+  ensureUserAdapterDir,
+  // Provider bridge
+  AdapterProviderBridge,
+  createProviderFromAdapter,
+  // Built-in adapters
+  geminiAdapter,
+  qwenAdapter,
+  codexAdapter,
+  builtInAdapters,
+  getBuiltInAdapter,
+  getBuiltInAdapterIds,
+} from "./adapters";
+
+// ============================================================================
+// NEW: Plugin System - Formal plugin registry with lifecycle hooks
+// ============================================================================
+export {
+  // Types
+  type PluginDefinition,
+  type PluginRegistrationOptions,
+  type PluginRegistrationResult,
+  type PluginInfo,
+  type CreateProviderOptions,
+  type ManagedProvider,
+  type PluginContext,
+  type IPluginRegistry,
+  type IPluginLifecycle,
+  type ProviderFactory,
+  type PluginConfigType,
+  isLifecycleProvider,
+  // Registry
+  PluginRegistry,
+  getPluginRegistry,
+  // Built-in plugins
+  geminiPlugin,
+  qwenCodePlugin,
+  codexPlugin,
+  builtInPlugins,
+  registerBuiltInPlugins,
+  areBuiltInPluginsRegistered,
+  getBuiltInPluginTypes,
+} from "./plugin";
+
+// ============================================================================
+// NEW: Unified Interface - Consistent types across all providers
+// ============================================================================
+export {
+  // Capabilities
+  Capability,
+  type CapabilityType,
+  type ICapabilities,
+  ProviderCapabilities,
+  // Output
+  type IOutput,
+  type IOutputMeta,
+  type UnifiedStreamChunk,
+  type NormalizerConfig,
+  DEFAULT_NORMALIZER_CONFIG,
+  OutputNormalizer,
+  // Errors
+  type IProviderError,
+  ProviderError,
+  classifyErrorMessage,
+} from "./unified";
+
+// Re-export integration tests for convenience
+export { describe, test, expect } from "bun:test";

package/src/core/memory-monitor.ts

@@ -0,0 +1,171 @@
+// Memory monitoring utilities for wrap-terminalcoder
+// Helps prevent memory leaks and monitor memory usage
+
+export interface MemoryStats {
+  heapUsed: number;
+  heapTotal: number;
+  external: number;
+  rss: number;
+  arrayBuffers: number;
+}
+
+export interface MemoryThresholds {
+  warning: number; // e.g., 0.8 for 80%
+  critical: number; // e.g., 0.9 for 90%
+}
+
+export class MemoryMonitor {
+  private static instance: MemoryMonitor;
+  private isMonitoring = false;
+  private intervalId: NodeJS.Timeout | null = null;
+  private thresholds: MemoryThresholds = { warning: 0.8, critical: 0.9 };
+
+  private constructor() {}
+
+  static getInstance(): MemoryMonitor {
+    if (!MemoryMonitor.instance) {
+      MemoryMonitor.instance = new MemoryMonitor();
+    }
+    return MemoryMonitor.instance;
+  }
+
+  /**
+   * Get current memory usage statistics
+   */
+  getMemoryStats(): MemoryStats {
+    const usage = process.memoryUsage();
+    return {
+      heapUsed: Math.round(usage.heapUsed / 1024 / 1024), // MB
+      heapTotal: Math.round(usage.heapTotal / 1024 / 1024), // MB
+      external: Math.round(usage.external / 1024 / 1024), // MB
+      rss: Math.round(usage.rss / 1024 / 1024), // MB
+      arrayBuffers: Math.round((usage as any).arrayBuffers / 1024 / 1024), // MB
+    };
+  }
+
+  /**
+   * Check if memory usage is within acceptable limits
+   */
+  checkMemoryLimit(threshold = 0.85): boolean {
+    const usage = process.memoryUsage();
+    const heapUsedPercent = usage.heapUsed / usage.heapTotal;
+    return heapUsedPercent < threshold;
+  }
+
+  /**
+   * Get memory usage as a percentage
+   */
+  getMemoryUsagePercent(): number {
+    const usage = process.memoryUsage();
+    return Math.round((usage.heapUsed / usage.heapTotal) * 100);
+  }
+
+  /**
+   * Format memory stats for logging
+   */
+  formatMemoryStats(stats?: MemoryStats): string {
+    const s = stats || this.getMemoryStats();
+    return `Heap: ${s.heapUsed}MB/${s.heapTotal}MB (${this.getMemoryUsagePercent()}%) | RSS: ${s.rss}MB | Buffers: ${s.arrayBuffers}MB`;
+  }
+
+  /**
+   * Start periodic memory monitoring
+   */
+  startMonitoring(intervalMs = 30000, logLevel: "info" | "warn" | "error" = "info"): void {
+    if (this.isMonitoring) {
+      console.log("[MemoryMonitor] Already monitoring memory usage");
+      return;
+    }
+
+    this.isMonitoring = true;
+    this.intervalId = setInterval(() => {
+      const stats = this.getMemoryStats();
+      const usagePercent = this.getMemoryUsagePercent();
+
+      if (usagePercent >= this.thresholds.critical * 100) {
+        console.error(`[MemoryMonitor] CRITICAL: ${this.formatMemoryStats(stats)}`);
+        this.triggerMemoryAlert("critical", stats);
+      } else if (usagePercent >= this.thresholds.warning * 100) {
+        console.warn(`[MemoryMonitor] WARNING: ${this.formatMemoryStats(stats)}`);
+        this.triggerMemoryAlert("warning", stats);
+      } else if (logLevel === "info") {
+        console.log(`[MemoryMonitor] ${this.formatMemoryStats(stats)}`);
+      }
+    }, intervalMs);
+
+    console.log(`[MemoryMonitor] Started monitoring memory usage every ${intervalMs}ms`);
+  }
+
+  /**
+   * Stop periodic memory monitoring
+   */
+  stopMonitoring(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.isMonitoring = false;
+    console.log("[MemoryMonitor] Stopped monitoring");
+  }
+
+  /**
+   * Set memory usage thresholds
+   */
+  setThresholds(thresholds: MemoryThresholds): void {
+    this.thresholds = thresholds;
+  }
+
+  /**
+   * Force garbage collection if available (Node.js with --expose-gc)
+   */
+  forceGC(): void {
+    if (global.gc) {
+      global.gc();
+      console.log("[MemoryMonitor] Garbage collection triggered");
+    } else {
+      console.log("[MemoryMonitor] Garbage collection not available (run with --expose-gc flag)");
+    }
+  }
+
+  /**
+   * Log detailed memory report
+   */
+  logMemoryReport(): void {
+    const stats = this.getMemoryStats();
+    console.log("[MemoryMonitor] === MEMORY REPORT ===");
+    console.log(`Heap Used: ${stats.heapUsed}MB`);
+    console.log(`Heap Total: ${stats.heapTotal}MB`);
+    console.log(`RSS: ${stats.rss}MB`);
+    console.log(`External: ${stats.external}MB`);
+    console.log(`Array Buffers: ${stats.arrayBuffers}MB`);
+    console.log(`Usage: ${this.getMemoryUsagePercent()}%`);
+    console.log("[MemoryMonitor] ====================");
+  }
+
+  private triggerMemoryAlert(level: "warning" | "critical", stats: MemoryStats): void {
+    // Emit event or call alerting system
+    if (level === "critical") {
+      console.error(`[MemoryMonitor] Memory usage critical! Consider:
+        1. Restarting the application
+        2. Reducing concurrent requests
+        3. Implementing streaming limits
+        4. Adding more memory monitoring`);
+    }
+  }
+}
+
+// Export singleton instance
+export const memoryMonitor = MemoryMonitor.getInstance();
+
+// Helper function to format bytes
+export function formatBytes(bytes: number, decimals = 2): string {
+  if (bytes === 0) return "0 Bytes";
+
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+}

package/src/core/plugin/builtin.ts

@@ -0,0 +1,87 @@
+/**
+ * Built-in Plugins
+ *
+ * Wraps the built-in adapters as plugins for the registry.
+ */
+
+import { codexAdapter, geminiAdapter, qwenAdapter } from "../adapters/builtin";
+import { createProviderFromAdapter } from "../adapters/provider-bridge";
+import { PluginRegistry } from "./registry";
+import type { PluginDefinition } from "./types";
+
+/**
+ * Gemini CLI plugin
+ */
+export const geminiPlugin: PluginDefinition = {
+  type: "gemini",
+  displayName: "Gemini CLI",
+  description: "Google Gemini CLI for AI-assisted coding",
+  version: "1.0.0",
+  binary: "gemini",
+  capabilities: ["generate", "edit", "explain", "test"],
+  hasLifecycle: false,
+  factory: () => createProviderFromAdapter(geminiAdapter),
+};
+
+/**
+ * Qwen Code CLI plugin
+ */
+export const qwenCodePlugin: PluginDefinition = {
+  type: "qwen-code",
+  displayName: "Qwen Code CLI",
+  description: "Qwen Code CLI for AI-assisted coding",
+  version: "1.0.0",
+  binary: "qwen",
+  capabilities: ["generate", "edit", "explain", "test"],
+  hasLifecycle: false,
+  factory: () => createProviderFromAdapter(qwenAdapter),
+};
+
+/**
+ * Codex CLI plugin
+ */
+export const codexPlugin: PluginDefinition = {
+  type: "codex",
+  displayName: "Codex CLI",
+  description: "OpenAI Codex CLI for code generation",
+  version: "1.0.0",
+  binary: "codex",
+  capabilities: ["generate", "edit", "test"],
+  hasLifecycle: false,
+  factory: () => createProviderFromAdapter(codexAdapter),
+};
+
+/**
+ * All built-in plugins
+ */
+export const builtInPlugins: PluginDefinition[] = [geminiPlugin, qwenCodePlugin, codexPlugin];
+
+/**
+ * Register all built-in plugins
+ */
+export async function registerBuiltInPlugins(
+  registry: PluginRegistry = PluginRegistry.getInstance(),
+): Promise<void> {
+  for (const plugin of builtInPlugins) {
+    const result = registry.registerSync(plugin, { builtIn: true });
+    if (!result.success) {
+      console.warn(`Failed to register built-in plugin ${plugin.type}:`, result.message);
+    }
+  }
+}
+
+/**
+ * Check if built-in plugins are registered
+ */
+export function areBuiltInPluginsRegistered(
+  registry: PluginRegistry = PluginRegistry.getInstance(),
+): boolean {
+  return builtInPlugins.every((plugin) => registry.has(plugin.type));
+}
+
+/**
+ * Get built-in plugin types
+ */
+export function getBuiltInPluginTypes(): string[] {
+  return builtInPlugins.map((p) => p.type);
+}

package/src/core/plugin/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Plugin System Exports
+ */
+
+// Types
+export type {
+  PluginDefinition,
+  PluginRegistrationOptions,
+  PluginRegistrationResult,
+  PluginInfo,
+  CreateProviderOptions,
+  ManagedProvider,
+  PluginContext,
+  IPluginRegistry,
+  IPluginLifecycle,
+  ProviderFactory,
+  PluginConfigType,
+} from "./types";
+
+export { isLifecycleProvider } from "./types";
+
+// Registry
+export { PluginRegistry, getPluginRegistry } from "./registry";
+
+// Built-in plugins
+export {
+  geminiPlugin,
+  qwenCodePlugin,
+  codexPlugin,
+  builtInPlugins,
+  registerBuiltInPlugins,
+  areBuiltInPluginsRegistered,
+  getBuiltInPluginTypes,
+} from "./builtin";