wraptc 1.0.3 → 1.0.4

package/bin/wraptc

@@ -4,9 +4,9 @@ const args = process.argv.slice(2);
 
 // Check if --mcp flag is present or first command is 'mcp'
 if (args.includes('--mcp') || args[0] === 'mcp') {
-  // Run MCP server
-  await import('../dist/mcp/server.js');
+  // Run MCP server from source
+  import('../src/mcp/server.ts');
 } else {
-  // Run CLI
-  await import('../dist/cli/index.js');
+  // Run CLI from source
+  import('../src/cli/index.ts');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wraptc",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "Unified CLI wrapper for multiple coding AI agents with intelligent routing",
   "type": "module",
   "main": "./dist/core/index.js",
@@ -63,7 +63,7 @@
     "typescript": "^5.0.0"
   },
   "files": [
-    "dist",
+    "src",
     "bin",
     "README.md",
     "LICENSE",

package/src/cli/__tests__/cli.test.ts

@@ -0,0 +1,337 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { WrapTerminalCoder } from "../../core/index.js";
+import { ConfigLoader } from "../../core/index.js";
+import { StateManager } from "../../core/index.js";
+import { Router } from "../../core/index.js";
+
+// Mock the core modules
+mock.module("../../core/index.js", () => {
+  return {
+    WrapTerminalCoder: {
+      create: mock(async () => ({
+        providers: new Map(),
+        config: {},
+        stateManager: new StateManager(),
+        router: new Router(new Map(), { config: {}, stateManager: new StateManager() }),
+        route: mock(async (req: any) => ({
+          provider: "gemini",
+          text: "Mock response",
+          usage: { inputTokens: 10, outputTokens: 20 },
+          meta: { elapsedMs: 100 },
+        })),
+        routeStream: async function* (req: any) {
+          yield {
+            provider: "gemini",
+            text: "Mock stream response",
+            usage: { inputTokens: 10, outputTokens: 20 },
+            meta: { elapsedMs: 100 },
+          };
+        },
+        getProviderInfo: mock(async () => [
+          {
+            id: "gemini",
+            displayName: "Gemini CLI",
+            requestsToday: 5,
+            outOfCreditsUntil: undefined,
+          },
+        ]),
+      })),
+    },
+    ConfigLoader: mock(() => ({
+      loadConfig: mock(async () => ({
+        routing: { defaultOrder: ["gemini", "qwen-code", "codex"] },
+        providers: {},
+        credits: { providers: {} },
+      })),
+    })),
+    StateManager: mock(() => ({
+      initialize: mock(async () => {}),
+      getProviderState: mock(async () => ({
+        requestsToday: 0,
+        outOfCreditsUntil: undefined,
+        lastErrors: [],
+      })),
+      recordSuccess: mock(async () => {}),
+      recordError: mock(async () => {}),
+    })),
+    Router: mock(() => ({
+      route: mock(async (req: any) => ({
+        provider: "gemini",
+        text: "Mock response",
+      })),
+    })),
+  };
+});
+
+describe("CLI Integration", () => {
+  describe("Providers Command", () => {
+    test("should list providers", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const providers = await wtc.getProviderInfo();
+
+      expect(providers).toBeInstanceOf(Array);
+      expect(providers.length).toBeGreaterThan(0);
+      expect(providers[0]).toHaveProperty("id");
+      expect(providers[0]).toHaveProperty("displayName");
+    });
+  });
+
+  describe("Ask Command", () => {
+    test("should process basic request", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Hello world",
+        mode: "generate",
+        stream: false,
+      };
+
+      const response = await wtc.route(req);
+
+      expect(response).toHaveProperty("provider");
+      expect(response).toHaveProperty("text");
+      expect(response.text).toBeDefined();
+    });
+
+    test("should handle explicit provider", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Test",
+        mode: "generate",
+        stream: false,
+        provider: "gemini",
+      };
+
+      const response = await wtc.route(req);
+
+      expect(response.provider).toBe("gemini");
+    });
+
+    test("should handle different modes", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const modes = ["generate", "edit", "explain", "test"];
+
+      for (const mode of modes) {
+        const req = {
+          prompt: "Test",
+          mode,
+          stream: false,
+        };
+
+        const response = await wtc.route(req);
+        expect(response).toBeDefined();
+      }
+    });
+
+    test("should handle file context", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Explain this code",
+        mode: "explain",
+        fileContext: ["src/file1.ts", "src/file2.ts"],
+        stream: false,
+      };
+
+      const response = await wtc.route(req);
+      expect(response).toBeDefined();
+    });
+  });
+
+  describe("Configuration", () => {
+    test("should load configuration", async () => {
+      const configLoader = new ConfigLoader();
+      const config = await configLoader.loadConfig();
+
+      expect(config).toHaveProperty("routing");
+      expect(config).toHaveProperty("providers");
+      expect(config).toHaveProperty("credits");
+    });
+
+    test("should handle config file path", async () => {
+      const configLoader = new ConfigLoader({
+        projectConfigPath: "/test/path/config.json",
+      });
+      const config = await configLoader.loadConfig();
+
+      expect(config).toBeDefined();
+    });
+  });
+
+  describe("State Management", () => {
+    test("should track provider state", async () => {
+      const stateManager = new StateManager();
+      await stateManager.initialize();
+
+      const state = await stateManager.getProviderState("gemini");
+      expect(state).toHaveProperty("requestsToday");
+      expect(state).toHaveProperty("outOfCreditsUntil");
+    });
+
+    test("should record successful requests", async () => {
+      // Override mock for this test to track state changes
+      const mockGetState = mock(async () => ({
+        requestsToday: 1,
+        outOfCreditsUntil: undefined,
+        lastErrors: [],
+      }));
+      const stateManager = new StateManager();
+      stateManager.getProviderState = mockGetState;
+
+      await stateManager.recordSuccess("gemini");
+
+      const state = await stateManager.getProviderState("gemini");
+      expect(state.requestsToday).toBeGreaterThan(0);
+    });
+  });
+});
+
+describe("CLI Commands", () => {
+  describe("Providers Command", () => {
+    test("should return JSON array of providers", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const providers = await wtc.getProviderInfo();
+
+      expect(Array.isArray(providers)).toBe(true);
+      providers.forEach((provider: any) => {
+        expect(provider).toHaveProperty("id");
+        expect(provider).toHaveProperty("displayName");
+      });
+    });
+
+    test("should show correct provider status", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const providers = await wtc.getProviderInfo();
+
+      providers.forEach((provider: any) => {
+        expect(typeof provider.requestsToday).toBe("number");
+        expect(provider.requestsToday).toBeGreaterThanOrEqual(0);
+      });
+    });
+  });
+
+  describe("Ask Command", () => {
+    test("should handle basic ask command", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Write hello world",
+        mode: "generate",
+        stream: false,
+      };
+
+      const response = await wtc.route(req);
+
+      expect(response).toHaveProperty("text");
+      expect(response.text).toBeDefined();
+      expect(response.text.length).toBeGreaterThan(0);
+    });
+
+    test("should handle ask with provider flag", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Test",
+        mode: "generate",
+        stream: false,
+        provider: "gemini",
+      };
+
+      const response = await wtc.route(req);
+
+      expect(response.provider).toBe("gemini");
+    });
+
+    test("should handle ask with file context", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Refactor this",
+        mode: "edit",
+        fileContext: ["src/utils.ts"],
+        stream: false,
+      };
+
+      const response = await wtc.route(req);
+      expect(response).toBeDefined();
+    });
+
+    test("should handle streaming mode", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Write a long document",
+        mode: "generate",
+        stream: true,
+      };
+
+      const responses = [];
+      for await (const response of wtc.routeStream(req)) {
+        responses.push(response);
+      }
+
+      expect(responses.length).toBeGreaterThan(0);
+      expect(responses[responses.length - 1]).toHaveProperty("meta");
+    });
+  });
+
+  describe("Output Formats", () => {
+    test("should support JSON output format", async () => {
+      const wtc = await WrapTerminalCoder.create();
+      const req = {
+        prompt: "Test",
+        mode: "generate",
+        stream: false,
+      };
+
+      const response = await wtc.route(req);
+
+      expect(response).toHaveProperty("provider");
+      expect(response).toHaveProperty("text");
+      expect(response).toHaveProperty("usage");
+      expect(response).toHaveProperty("meta");
+    });
+  });
+
+  describe("Error Handling", () => {
+    test("should handle provider not found", async () => {
+      const wtc = await WrapTerminalCoder.create();
+
+      // Override route to throw error for this test
+      wtc.route = mock(async (req: any) => {
+        if (req.provider === "nonexistent") {
+          throw new Error("Provider not found: nonexistent");
+        }
+        return {
+          provider: "gemini",
+          text: "Mock response",
+          usage: { inputTokens: 10, outputTokens: 20 },
+          meta: { elapsedMs: 100 },
+        };
+      });
+
+      const req = {
+        prompt: "Test",
+        provider: "nonexistent",
+        mode: "generate",
+        stream: false,
+      };
+
+      await expect(wtc.route(req)).rejects.toThrow("Provider not found");
+    });
+  });
+});
+
+describe("Configuration Validation", () => {
+  test("should validate configuration with Zod", async () => {
+    const configLoader = new ConfigLoader();
+    const config = await configLoader.loadConfig();
+
+    expect(config).toBeDefined();
+    expect(config).toHaveProperty("routing");
+    expect(config).toHaveProperty("providers");
+    expect(config).toHaveProperty("credits");
+  });
+
+  test("should handle invalid configuration", async () => {
+    const configLoader = new ConfigLoader({
+      projectConfigPath: "/invalid/path/config.json",
+    });
+
+    await expect(configLoader.loadConfig()).resolves.toBeDefined();
+  });
+});

package/src/cli/index.ts

@@ -0,0 +1,149 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import { WrapTerminalCoder } from "../core/index.js";
+import { CodingRequestSchema } from "../core/index.js";
+import type { CodingRequest } from "../core/index.js";
+import { runMCPServer } from "../mcp/server.js";
+
+const program = new Command();
+
+program
+  .name("wraptc")
+  .description("wraptc - unified CLI for multiple coding agents")
+  .version("0.1.0")
+  .option("--mcp", "Start MCP server mode");
+
+// Handle MCP mode flag
+program.hook("preAction", async (thisCommand) => {
+  const options = thisCommand.opts();
+  if (options.mcp) {
+    await runMCPServer();
+    process.exit(0);
+  }
+});
+
+program
+  .command("ask")
+  .alias("a")
+  .description("Send a coding request to the best available provider")
+  .argument("[prompt]", "The coding prompt (can also use -p or pipe from stdin)")
+  .option("-p, --prompt <prompt>", "The prompt to send to the coding agent")
+  .option("--use <provider>", "Specific provider to use (qwen, gemini, codex)")
+  .option("--mode <mode>", "Task type: generate, edit, explain, test", "generate")
+  .option("--lang <language>", "Language hint (js, ts, py, etc.)")
+  .option("-f, --file <files...>", "Include file(s) for context")
+  .option("-t, --temperature <temp>", "Creativity level (0-2)", Number.parseFloat)
+  .option("-s, --stream", "Stream responses in real-time")
+  .option("-o, --output <format>", "Output format: text, json", "text")
+  .option("-d, --dry-run", "Show which provider will be used")
+  .option("-c, --config <path>", "Custom config file path")
+  .option("--timeout <seconds>", "Request timeout in seconds", Number.parseInt)
+  .option("--retry <count>", "Retry failed requests", Number.parseInt)
+  .action(async (promptArg, options) => {
+    try {
+      // Handle positional argument or option
+      let prompt = promptArg || options.prompt;
+
+      // Validate prompt
+      if (!prompt && process.stdin.isTTY) {
+        console.error("Error: Prompt is required (use positional arg, -p, or pipe from stdin)");
+        console.error("Examples:");
+        console.error("  wraptc 'Write a function'");
+        console.error("  wraptc -p 'Write a function'");
+        console.error("  echo 'Write a function' | wraptc");
+        process.exit(1);
+      }
+
+      // Read from stdin if prompt not provided
+      if (!prompt && !process.stdin.isTTY) {
+        prompt = await Bun.stdin.text();
+      }
+
+      // Build request
+      const request: CodingRequest = {
+        prompt: prompt.trim(),
+        mode: options.mode,
+        language: options.lang,
+        fileContext: options.file,
+        temperature: options.temperature,
+        stream: options.stream,
+        provider: options.use, // Changed from options.provider
+      };
+
+      // Validate request
+      const parsed = CodingRequestSchema.safeParse(request);
+      if (!parsed.success) {
+        console.error("Error: Invalid request:", parsed.error.errors);
+        process.exit(1);
+      }
+
+      // Create WrapTerminalCoder instance
+      const wtc = await WrapTerminalCoder.create({
+        configPath: options.config,
+      });
+
+      // Dry run mode
+      if (options.dryRun) {
+        console.log("Would use provider:", request.provider || "auto-selected");
+        process.exit(0);
+      }
+
+      // Execute request
+      if (request.stream) {
+        for await (const event of wtc.routeStream(request)) {
+          if (options.output === "json") {
+            console.log(JSON.stringify(event));
+          } else {
+            console.log(event.text);
+          }
+        }
+      } else {
+        const response = await wtc.route(request);
+
+        if (options.output === "json") {
+          console.log(JSON.stringify(response));
+        } else {
+          console.log(response.text);
+        }
+      }
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("providers")
+  .description("List available providers and their status")
+  .option("-c, --config <path>", "Custom config file path")
+  .action(async (options) => {
+    try {
+      const wtc = await WrapTerminalCoder.create({
+        configPath: options.config,
+      });
+
+      const providers = await wtc.getProviderInfo();
+
+      console.log("Available Providers:");
+      for (const provider of providers) {
+        const status = provider.outOfCreditsUntil
+          ? `⚠️  Out of credits until ${new Date(provider.outOfCreditsUntil).toLocaleString()}`
+          : `✅ ${provider.requestsToday} requests today`;
+
+        console.log(`  ${provider.displayName} (${provider.id}): ${status}`);
+      }
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+program
+  .command("mcp")
+  .description("Start MCP server")
+  .action(async () => {
+    await runMCPServer();
+  });
+
+program.parse();

package/src/core/__tests__/fixtures/configs/project-config.json

@@ -0,0 +1,14 @@
+{
+  "routing": {
+    "defaultOrder": ["project-provider", "user-provider", "system-provider"]
+  },
+  "providers": {
+    "project-provider": {
+      "binary": "./project-provider",
+      "args": ["--project-flag"],
+      "jsonMode": "none",
+      "streamingMode": "line",
+      "capabilities": ["generate", "edit", "test"]
+    }
+  }
+}

package/src/core/__tests__/fixtures/configs/system-config.json

@@ -0,0 +1,14 @@
+{
+  "routing": {
+    "defaultOrder": ["system-provider"]
+  },
+  "providers": {
+    "system-provider": {
+      "binary": "/usr/bin/system-provider",
+      "args": [],
+      "jsonMode": "none",
+      "streamingMode": "line",
+      "capabilities": ["generate"]
+    }
+  }
+}

package/src/core/__tests__/fixtures/configs/user-config.json

@@ -0,0 +1,15 @@
+{
+  "routing": {
+    "defaultOrder": ["user-provider", "system-provider"]
+  },
+  "providers": {
+    "user-provider": {
+      "binary": "/usr/local/bin/user-provider",
+      "args": ["--user-flag"],
+      "jsonMode": "flag",
+      "jsonFlag": "--json",
+      "streamingMode": "jsonl",
+      "capabilities": ["generate", "edit"]
+    }
+  }
+}