im-pickle-rick 0.1.0

package/src/services/providers/gemini.test.ts

@@ -0,0 +1,40 @@
+import { expect, test, describe, mock } from "bun:test";
+import { GeminiProvider } from "./gemini.js";
+
+// Global mock for fs/promises
+mock.module("node:fs/promises", () => ({
+  readFile: async (path: string) => {
+    if (path.includes("/existent/.gemini/settings.json")) {
+      return JSON.stringify({
+        model: {
+          name: "gemini-3-flash-preview"
+        }
+      });
+    }
+    throw new Error("File not found");
+  },
+  writeFile: async () => {},
+  unlink: async () => {}
+}));
+
+// Mocking os
+let mockHome = "/existent";
+mock.module("node:os", () => ({
+  homedir: () => mockHome
+}));
+
+describe("GeminiProvider", () => {
+  test("getModelName should return model name from settings", async () => {
+    mockHome = "/existent";
+    const provider = new GeminiProvider();
+    const modelName = await provider.getModelName();
+    expect(modelName).toBe("gemini-3-flash-preview");
+  });
+
+  test("getModelName should return undefined if file reading fails", async () => {
+    mockHome = "/non-existent";
+    const provider = new GeminiProvider();
+    const modelName = await provider.getModelName();
+    expect(modelName).toBeUndefined();
+  });
+});

package/src/services/providers/gemini.ts

@@ -0,0 +1,169 @@
+import {
+  BaseProvider,
+  checkForErrors,
+  execCommand,
+  execCommandStreaming,
+  parseStreamJsonResult,
+  detectStepFromOutput,
+} from "./base.js";
+import type { AIResult, ProviderOptions } from "./types.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { writeFile, unlink, readFile } from "node:fs/promises";
+
+export class GeminiProvider extends BaseProvider {
+  name = "Gemini CLI";
+  cliCommand = "gemini";
+
+  async getModelName(): Promise<string | undefined> {
+    try {
+      const settingsPath = join(homedir(), ".gemini/settings.json");
+      const content = await readFile(settingsPath, "utf-8");
+      const settings = JSON.parse(content);
+      return settings.model?.name;
+    } catch (e) {
+      return undefined;
+    }
+  }
+
+  async execute(
+    prompt: string,
+    workDir: string,
+    options?: ProviderOptions,
+  ): Promise<AIResult> {
+    return this.executeStreaming(prompt, workDir, () => {}, options);
+  }
+
+  async executeStreaming(
+    prompt: string,
+    workDir: string,
+    onProgress: (step: string, content?: string) => void,
+    options?: ProviderOptions,
+  ): Promise<AIResult> {
+    // Disable the pickle-rick extension to prevent recursion or interference
+    try {
+      await execCommand(this.cliCommand, ["extensions", "disable", "pickle-rick"], workDir);
+    } catch (e) {
+      // Silently ignore if it fails (might not be installed)
+    }
+
+    const extensionPath = join(homedir(), ".gemini/extensions/pickle-rick");
+    const promptFile = join(workDir, ".gemini-prompt.txt");
+    await writeFile(promptFile, prompt, "utf-8");
+
+    const geminiArgs = [
+      "-s",
+      "-y",
+      "-o",
+      "stream-json",
+      "--include-directories",
+      extensionPath,
+      "--include-directories",
+      join(extensionPath, "sessions"),
+      "--include-directories",
+      join(extensionPath, "jar"),
+      "--include-directories",
+      join(extensionPath, "worktrees"),
+    ];
+
+    if (options?.resumeSessionId) {
+      geminiArgs.push("-r", options.resumeSessionId);
+    }
+
+    if (options?.providerArgs) {
+      geminiArgs.push(...options.providerArgs);
+    }
+
+    if (options?.extraIncludes) {
+      for (const include of options.extraIncludes) {
+        geminiArgs.push("--include-directories", include);
+      }
+    }
+
+    const command = "sh";
+    const shellArgs = [
+      "-c",
+      `cat "${promptFile}" | ${this.cliCommand} ${geminiArgs.join(" ")}`,
+    ];
+
+    const outputLines: string[] = [];
+    let sessionId: string | undefined;
+
+    try {
+      const { exitCode } = await execCommandStreaming(
+        command,
+        shellArgs,
+        workDir,
+        (line) => {
+          outputLines.push(line);
+          try {
+            const parsed = JSON.parse(line);
+
+            if (parsed.type === "init" && parsed.session_id) {
+              sessionId = parsed.session_id;
+            }
+
+            if (
+              parsed.type === "message" &&
+              parsed.role === "assistant" &&
+              parsed.content
+            ) {
+              onProgress("thinking", parsed.content);
+            }
+
+            const step = detectStepFromOutput(line);
+            if (step) {
+              onProgress(step);
+            }
+          } catch {} // Ignore JSON parsing errors
+        },
+      );
+
+      const fullOutput = outputLines.join("\n");
+
+      let error = checkForErrors(fullOutput);
+
+      // If exit code is bad but no JSON error found, use the raw output (likely stderr)
+      if (exitCode !== 0 && !error) {
+        // Filter out likely non-error lines (json) to find the error message
+        const rawLines = outputLines.filter((l) => !l.trim().startsWith("{"));
+        error =
+          rawLines.join("\n") ||
+          "Unknown execution error (exit code " + exitCode + ")";
+      }
+
+      if (error) {
+        return {
+          success: false,
+          response: "",
+          inputTokens: 0,
+          outputTokens: 0,
+          error,
+        };
+      }
+
+      const { response, inputTokens, outputTokens } =
+        parseStreamJsonResult(fullOutput);
+
+      return {
+        success: exitCode === 0 && !error,
+        response,
+        inputTokens,
+        outputTokens,
+        error:
+          error ||
+          (exitCode !== 0 ? "Process exited with code " + exitCode : undefined),
+        sessionId,
+      };
+    } finally {
+      try {
+        await unlink(promptFile);
+      } catch (e) {} // Ignore errors during cleanup
+
+      // Re-enable the extension
+      try {
+        await execCommand(this.cliCommand, ["extensions", "enable", "pickle-rick"], workDir);
+      } catch (e) {} // Ignore errors during cleanup
+    }
+  }
+}

package/src/services/providers/index.test.ts

@@ -0,0 +1,28 @@
+import { expect, test, describe, mock } from "bun:test";
+import { createProvider, getConfiguredModel } from "./index.js";
+import { GeminiProvider } from "./gemini.js";
+import { CodexProvider } from "./codex.js";
+import { OpencodeProvider } from "./opencode.js";
+
+mock.module("../config/settings.js", () => ({
+  getConfiguredProvider: async () => "gemini",
+  loadSettings: async () => ({
+    model: {
+      provider: "gemini",
+      model: "gemini-3-flash"
+    }
+  })
+}));
+
+describe("Providers Index", () => {
+  test("createProvider should return GeminiProvider for 'gemini' setting", async () => {
+    const provider = await createProvider();
+    expect(provider).toBeInstanceOf(GeminiProvider);
+    expect(provider.name).toBe("Gemini CLI");
+  });
+
+  test("getConfiguredModel should return model from settings", async () => {
+    const model = await getConfiguredModel();
+    expect(model).toBe("gemini-3-flash");
+  });
+});

package/src/services/providers/index.ts

@@ -0,0 +1,41 @@
+export * from "./types.js";
+export * from "./base.js";
+export * from "./codex.js";
+export * from "./gemini.js";
+export * from "./opencode.js";
+
+import { CodexProvider } from "./codex.js";
+import { GeminiProvider } from "./gemini.js";
+import { OpencodeProvider } from "./opencode.js";
+import type { AIProvider, AIProviderName } from "./types.js";
+import { loadSettings, getConfiguredProvider } from "../config/settings.js";
+
+/**
+ * Create a provider instance based on settings or default to Gemini
+ */
+export async function createProvider(): Promise<AIProvider> {
+  const configuredProvider = await getConfiguredProvider();
+  
+  switch (configuredProvider) {
+    case "codex":
+      return new CodexProvider();
+    case "opencode":
+      return new OpencodeProvider();
+    case "gemini":
+    default:
+      return new GeminiProvider();
+  }
+}
+
+/**
+ * Get the currently configured provider name
+ */
+export { getConfiguredProvider };
+
+/**
+ * Get the currently configured model name from settings
+ */
+export async function getConfiguredModel(): Promise<string | undefined> {
+  const settings = await loadSettings();
+  return settings.model?.model;
+}

package/src/services/providers/opencode.test.ts

@@ -0,0 +1,64 @@
+import { expect, test, describe, mock } from "bun:test";
+import { OpencodeProvider } from "./opencode.js";
+
+// Track which paths should succeed
+let shouldJsonSucceed = true;
+let shouldYamlSucceed = false;
+
+// Global mock for fs/promises
+mock.module("node:fs/promises", () => ({
+  readFile: async (path: string) => {
+    if (path.includes("/.config/opencode/config.json") && shouldJsonSucceed) {
+      return JSON.stringify({
+        model: "anthropic/claude-sonnet-4-5"
+      });
+    }
+    if (path.includes("/.opencode/config.yaml") && shouldYamlSucceed) {
+      return `model: openai/gpt-4\nother: value`;
+    }
+    throw new Error("File not found");
+  },
+  writeFile: async () => {},
+  unlink: async () => {}
+}));
+
+mock.module("node:os", () => ({
+  homedir: () => "/home/testuser"
+}));
+
+describe("OpencodeProvider", () => {
+  test("should have correct name and cliCommand", () => {
+    const provider = new OpencodeProvider();
+    expect(provider.name).toBe("OpenCode");
+    expect(provider.cliCommand).toBe("opencode");
+  });
+
+  test("getModelName should return model from JSON config", async () => {
+    shouldJsonSucceed = true;
+    shouldYamlSucceed = false;
+    const provider = new OpencodeProvider();
+    const modelName = await provider.getModelName();
+    expect(modelName).toBe("anthropic/claude-sonnet-4-5");
+  });
+
+  test("getModelName should return model from YAML config if JSON not found", async () => {
+    shouldJsonSucceed = false;
+    shouldYamlSucceed = true;
+    const provider = new OpencodeProvider();
+    const modelName = await provider.getModelName();
+    expect(modelName).toBe("openai/gpt-4");
+  });
+
+  test("getModelName should return undefined if no config found", async () => {
+    shouldJsonSucceed = false;
+    shouldYamlSucceed = false;
+    const provider = new OpencodeProvider();
+    const modelName = await provider.getModelName();
+    expect(modelName).toBeUndefined();
+  });
+
+  test("isAvailable should check if opencode command exists", async () => {
+    const provider = new OpencodeProvider();
+    expect(typeof provider.isAvailable).toBe("function");
+  });
+});

package/src/services/providers/opencode.ts

@@ -0,0 +1,228 @@
+import {
+  BaseProvider,
+  checkForErrors,
+  detectStepFromOutput,
+  execCommand,
+  execCommandStreaming,
+} from "./base.js";
+import type { AIResult, ProviderOptions } from "./types.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { writeFile, unlink, readFile } from "node:fs/promises";
+
+interface OpencodeEvent {
+  type: string;
+  timestamp: number;
+  sessionID?: string;
+  part?: {
+    id?: string;
+    sessionID?: string;
+    messageID?: string;
+    type?: string;
+    text?: string;
+    tool?: string;
+    callID?: string;
+    state?: {
+      status?: string;
+      input?: Record<string, unknown>;
+      output?: string;
+      title?: string;
+      metadata?: Record<string, unknown>;
+      time?: {
+        start?: number;
+        end?: number;
+      };
+    };
+    reason?: string;
+    snapshot?: string;
+    cost?: number;
+    tokens?: {
+      input?: number;
+      output?: number;
+      reasoning?: number;
+      cache?: {
+        read?: number;
+        write?: number;
+      };
+    };
+  };
+  error?: {
+    name?: string;
+    data?: {
+      message?: string;
+      statusCode?: number;
+      isRetryable?: boolean;
+    };
+  };
+}
+
+
+
+export class OpencodeProvider extends BaseProvider {
+  name = "OpenCode";
+  cliCommand = "opencode";
+
+  async getModelName(): Promise<string | undefined> {
+    // Try JSON config first
+    try {
+      const configPath = join(homedir(), ".config/opencode/config.json");
+      const content = await readFile(configPath, "utf-8");
+      const config = JSON.parse(content);
+      if (config.model) {
+        return config.model;
+      }
+    } catch {
+      // Fall through to try YAML config
+    }
+
+    // Try YAML config
+    try {
+      const yamlConfigPath = join(homedir(), ".opencode/config.yaml");
+      const content = await readFile(yamlConfigPath, "utf-8");
+      // Simple YAML parsing - look for model: line
+      const match = content.match(/^model:\s*(.+)$/m);
+      if (match) {
+        return match[1].trim();
+      }
+    } catch {
+      // Config not found or unreadable
+    }
+
+    return undefined;
+  }
+
+  async execute(
+    prompt: string,
+    workDir: string,
+    options?: ProviderOptions,
+  ): Promise<AIResult> {
+    return this.executeStreaming(prompt, workDir, () => {}, options);
+  }
+
+  async executeStreaming(
+    prompt: string,
+    workDir: string,
+    onProgress: (step: string, content?: string) => void,
+    options?: ProviderOptions,
+  ): Promise<AIResult> {
+    const promptFile = join(workDir, ".opencode-prompt.txt");
+    await writeFile(promptFile, prompt, "utf-8");
+
+    const opencodeArgs = ["run", "--format", "json"];
+
+    if (options?.resumeSessionId) {
+      opencodeArgs.push("-s", options.resumeSessionId);
+    }
+
+    if (options?.providerArgs) {
+      opencodeArgs.push(...options.providerArgs);
+    }
+
+    // Read prompt from stdin
+    const command = "sh";
+    const shellArgs = [
+      "-c",
+      `cat "${promptFile}" | ${this.cliCommand} ${opencodeArgs.join(" ")}`,
+    ];
+
+    const outputLines: string[] = [];
+    let sessionId: string | undefined;
+    let accumulatedResponse = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let error: string | undefined;
+
+    try {
+      const { exitCode } = await execCommandStreaming(
+        command,
+        shellArgs,
+        workDir,
+        (line) => {
+          outputLines.push(line);
+          try {
+            const event: OpencodeEvent = JSON.parse(line);
+
+            // Extract session ID from step_start
+            if (event.type === "step_start" && event.sessionID) {
+              sessionId = event.sessionID;
+            }
+
+            // Accumulate text response
+            if (event.type === "text" && event.part?.text) {
+              accumulatedResponse += event.part.text;
+              onProgress("thinking", event.part.text);
+            }
+
+            // Detect step from tool_use
+            const step = detectStepFromOutput(line);
+            if (step) {
+              onProgress(step);
+            }
+
+            // Extract tokens and cost from step_finish
+            if (event.type === "step_finish" && event.part) {
+              if (event.part.tokens?.input) {
+                inputTokens = event.part.tokens.input;
+              }
+              if (event.part.tokens?.output) {
+                outputTokens = event.part.tokens.output;
+              }
+              // Check for final completion
+              if (event.part.reason === "stop") {
+                // Final step
+              }
+            }
+
+            // Check for errors
+            if (event.type === "error" && event.error?.data?.message) {
+              error = event.error.data.message;
+            }
+          } catch {
+            // Ignore JSON parsing errors
+          }
+        },
+      );
+
+      // Check for errors in raw output
+      const fullOutput = outputLines.join("\n");
+      const parsedError = checkForErrors(fullOutput);
+      if (parsedError) {
+        error = parsedError;
+      }
+
+      // If exit code is bad but no error found, use raw output
+      if (exitCode !== 0 && !error) {
+        const rawLines = outputLines.filter((l) => !l.trim().startsWith("{"));
+        error =
+          rawLines.join("\n") ||
+          `Unknown execution error (exit code ${exitCode})`;
+      }
+
+      if (error) {
+        return {
+          success: false,
+          response: accumulatedResponse,
+          inputTokens,
+          outputTokens,
+          error,
+        };
+      }
+
+      return {
+        success: exitCode === 0 && !error,
+        response: accumulatedResponse || "Task completed",
+        inputTokens,
+        outputTokens,
+        error: exitCode !== 0 ? `Process exited with code ${exitCode}` : undefined,
+        sessionId,
+      };
+    } finally {
+      // Cleanup
+      try {
+        await unlink(promptFile);
+      } catch {
+        // Ignore cleanup errors
+      }
+    }
+  }
+}

package/src/services/providers/types.ts

@@ -0,0 +1,44 @@
+// ... existing imports
+export interface AIResult {
+	success: boolean;
+	response: string;
+	inputTokens: number;
+	outputTokens: number;
+	sessionId?: string; // Added field
+	cost?: string;
+	error?: string;
+}
+
+export interface ProviderOptions {
+	modelOverride?: string;
+	resumeSessionId?: string; // Added field
+	providerArgs?: string[];
+    extraIncludes?: string[]; // Added: Force include directories (e.g. for Worktrees)
+}
+
+// ... rest of file
+export type ProgressCallback = (step: string, content?: string) => void;
+
+export interface AIProvider {
+	name: string;
+	cliCommand: string;
+	isAvailable(): Promise<boolean>;
+	getModelName?(): Promise<string | undefined>;
+	execute(prompt: string, workDir: string, options?: ProviderOptions): Promise<AIResult>;
+	executeStreaming?(
+		prompt: string,
+		workDir: string,
+		onProgress: ProgressCallback,
+		options?: ProviderOptions,
+	): Promise<AIResult>;
+}
+
+export type AIProviderName =
+	| "claude"
+	| "opencode"
+	| "cursor"
+	| "codex"
+	| "qwen"
+	| "droid"
+	| "copilot"
+    | "gemini";