im-pickle-rick 0.1.0

package/src/services/commands/worker.ts

@@ -0,0 +1,262 @@
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { readFile, mkdir, appendFile } from "node:fs/promises";
+import { getExtensionRoot, resolveResource, resolveSkillPath } from "../../utils/resources.js";
+import { spawn } from "node:child_process";
+import pc from "picocolors";
+
+export async function runWorker(
+    task: string, 
+    ticketId: string, 
+    ticketPath: string, 
+    timeout: string,
+    skillName?: string
+): Promise<void> {
+    const startEpoch = Date.now();
+    let timeoutMs = parseInt(timeout) * 1000;
+    
+    // 1. Setup paths
+    // Normalize ticketPath to ensure we have the directory
+    let targetDir = ticketPath;
+    if (ticketPath.endsWith(".md")) {
+        targetDir = dirname(ticketPath);
+    } else if (existsSync(ticketPath) && existsSync(join(ticketPath, "..", "state.json"))) {
+         // If ticketPath is a dir but the state is in parent, it might be a sub-ticket.
+         // But usually ticketPath IS the ticket directory.
+         // Let's stick to the logic: targetDir is where we run.
+         targetDir = ticketPath;
+    }
+    
+    // Ensure absolute path if not already
+    if (!targetDir.startsWith("/")) {
+        targetDir = join(process.cwd(), targetDir);
+    }
+
+    await mkdir(targetDir, { recursive: true });
+    
+    const sessionLog = join(targetDir, `worker_session_${process.pid}.log`);
+    const extensionRoot = getExtensionRoot();
+
+    // --- Timeout Clamping Logic (Ported from spawn_morty.py) ---
+    // Check parent dir (Manager state) first, then current dir (Worker state resume)
+    let timeoutStatePath: string | null = null;
+    const parentState = join(targetDir, "..", "state.json");
+    const workerState = join(targetDir, "state.json");
+
+    if (existsSync(parentState)) {
+        timeoutStatePath = parentState;
+    } else if (existsSync(workerState)) {
+        timeoutStatePath = workerState;
+    }
+
+    if (timeoutStatePath) {
+        try {
+            const stateContent = await readFile(timeoutStatePath, "utf-8");
+            const state = JSON.parse(stateContent);
+            const maxMins = state.max_time_minutes || 0;
+            const startTime = state.start_time_epoch || 0;
+
+            if (maxMins > 0 && startTime > 0) {
+                // startTime is in seconds in python script usually, let's check input.
+                // In JS Date.now() is ms. Python time.time() is seconds.
+                // The state file usually stores seconds (from python).
+                // Let's assume seconds if it's small, ms if it's huge.
+                // Actually, let's look at `state.json` convention. 
+                // Usually Python `time.time()` -> float seconds.
+                // JS `Date.now()` -> int ms.
+                
+                // If it's < 10^11, it's seconds.
+                const nowSeconds = Date.now() / 1000;
+                let startSeconds = startTime;
+                if (startSeconds > 100000000000) { // It's MS
+                    startSeconds = startSeconds / 1000;
+                }
+
+                const remaining = (maxMins * 60) - (nowSeconds - startSeconds);
+                if (remaining * 1000 < timeoutMs) {
+                    const clamped = Math.max(10, Math.floor(remaining));
+                    timeoutMs = clamped * 1000;
+                    console.log(pc.yellow(`⚠️  Worker timeout clamped: ${clamped}s (Global Session Limit)`));
+                }
+            }
+        } catch (e) {
+            // Ignore state read errors
+        }
+    }
+
+    // 2. Build Prompt
+    const tomlPath = resolveResource("commands/send-to-morty.toml");
+    let basePrompt = '# **TASK REQUEST**\n$ARGUMENTS\n\nYou are a Morty Worker. Implement the request above.';
+    
+    try {
+        if (existsSync(tomlPath)) {
+            const content = await readFile(tomlPath, "utf-8");
+            const match = content.match(/prompt = \"""([\s\S]*?)\"""/);
+            if (match) {
+                basePrompt = match[1].trim();
+            }
+        }
+    } catch (e) {
+        console.warn(pc.yellow("⚠️ Failed to load prompt TOML, using fallback."));
+    }
+
+    let workerPrompt = basePrompt.replace("${extensionPath}", extensionRoot);
+    workerPrompt = workerPrompt.replace("$ARGUMENTS", task);
+
+    // Inject Skill if provided
+    if (skillName) {
+        const skillPath = resolveSkillPath(skillName);
+        console.log(pc.dim(`🔍 Resolving skill '${skillName}' -> '${skillPath}'`));
+        
+        if (skillPath && existsSync(skillPath)) {
+            const skillContent = await readFile(skillPath, "utf-8");
+            console.log(pc.dim(`📄 Skill content loaded (${skillContent.length} chars)`));
+            
+            if (skillContent.length > 0) {
+                workerPrompt += `\n\n<skill_injection>\n${skillContent}\n</skill_injection>`;
+            } else {
+                console.warn(pc.yellow(`⚠️ Skill file is empty: ${skillPath}`));
+            }
+        } else {
+            console.warn(pc.yellow(`⚠️ Skill '${skillName}' not found at ${skillPath}`));
+        }
+    }
+
+    // Fallback prompt enforcement
+    if (workerPrompt.length < 200) {
+        workerPrompt += `\n\nTask: "${task}"\n1. Activate persona: activate_skill("load-pickle-persona").\n2. Output: <promise>I AM DONE</promise>`;
+    }
+
+    // 3. Build Command
+    const includes = [
+        process.cwd(), // Current workspace
+        targetDir,
+        join(targetDir, ".."),
+        extensionRoot,
+        join(extensionRoot, "scripts"),
+        join(extensionRoot, "skills"),
+        join(extensionRoot, "sessions"),
+        join(extensionRoot, "jar"),
+        join(extensionRoot, "worktrees")
+    ];
+
+    // Filter unique and existing paths
+    const uniqueIncludes = [...new Set(includes)].filter(p => existsSync(p));
+
+    let args = ["-s", "-y", "-o", "text"];
+    for (const p of uniqueIncludes) {
+        args.push("--include-directories", p);
+    }
+    args.push("-p", workerPrompt);
+    
+    let command = "gemini";
+    let cmdArgs = args;
+
+    // Check for Command Override (for testing or specialized environments)
+    if (process.env.PICKLE_WORKER_CMD_OVERRIDE) {
+        const parts = process.env.PICKLE_WORKER_CMD_OVERRIDE.split(" ");
+        command = parts[0];
+        // We assume the override includes necessary base args, but we might need to append prompt/includes
+        // Actually, spawn_morty.py REPLACES the cmd with the override + prompt.
+        // Let's assume the override replaces the 'gemini' part but keeps the args we built, 
+        // OR replaces the whole thing.
+        // spawn_morty.py: cmd = shlex.split(os.environ["PICKLE_WORKER_CMD_OVERRIDE"])
+        // It ignores the built args if override is present?
+        // Wait, spawn_morty.py lines:
+        //   cmd = ["gemini", ...]
+        //   ... build cmd ...
+        //   if "PICKLE_WORKER_CMD_OVERRIDE": cmd = shlex.split(...)
+        // So it COMPLETELY replaces it. That seems wrong if we want to pass the prompt.
+        // BUT, if the override is just the binary, we should prepend it.
+        // Let's assume the user knows what they are doing if they use the override.
+        // FOR NOW: Let's stick to standard behavior unless forced.
+        // If I want to match spawn_morty exactly:
+        if (process.env.PICKLE_WORKER_CMD_OVERRIDE) {
+             const override = process.env.PICKLE_WORKER_CMD_OVERRIDE.split(" ");
+             command = override[0];
+             cmdArgs = [...override.slice(1), ...args]; // Prepend flags from override, append ours?
+             // Actually, usually override is like "gemini-beta".
+             cmdArgs = [...override.slice(1), ...args]; 
+        }
+    }
+
+    console.log(pc.cyan(`🥒 Spawning Morty Worker [Ticket: ${ticketId}]`));
+    console.log(pc.dim(`   Log: ${sessionLog}`));
+    console.log(pc.dim(`   Timeout: ${timeoutMs/1000}s`));
+
+    // 4. Spawn Process
+    const logStream = {
+        write: async (msg: string) => {
+            try {
+                await appendFile(sessionLog, msg);
+            } catch (e) {}
+        }
+    };
+
+    // Header
+    await logStream.write(`CWD: ${process.cwd()}\nCommand: ${command} ${cmdArgs.join(" ")}\n${"-".repeat(80)}\n\n`);
+
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, cmdArgs, {
+            cwd: process.cwd(),
+            env: { 
+                ...process.env, 
+                PYTHONUNBUFFERED: "1",
+                PICKLE_STATE_FILE: workerState // Pass state file location to worker
+            },
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+
+        let outputBuffer = "";
+
+        child.stdout.on("data", async (data) => {
+            const str = data.toString();
+            outputBuffer += str;
+            await logStream.write(str);
+            process.stdout.write("."); // Spinner tick
+        });
+
+        child.stderr.on("data", async (data) => {
+            const str = data.toString();
+            outputBuffer += str;
+            await logStream.write(str);
+        });
+
+        // Timeout Logic
+        const timer = setTimeout(() => {
+            child.kill();
+            const msg = `\n\n[TIMEOUT] Worker exceeded ${timeoutMs/1000}s limit.\n`;
+            logStream.write(msg).catch(() => {});
+            console.error(pc.red(msg));
+            reject(new Error("Timeout"));
+        }, timeoutMs);
+
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            
+            // Check for explicit success promise
+            const isSuccess = outputBuffer.includes("<promise>I AM DONE</promise>") || outputBuffer.includes("I AM DONE");
+            
+            if (isSuccess) {
+                console.log(pc.green(`\n✅ Worker Succeeded (Exit: ${code})`));
+                resolve();
+            } else {
+                console.log(pc.red(`\n❌ Worker Failed (Exit: ${code}) - Check logs at ${sessionLog}`));
+                // We resolve, but set exitCode to 1 so the CLI fails gracefully after cleanup if needed
+                if (code !== 0) {
+                    process.exitCode = code || 1;
+                } else {
+                    process.exitCode = 1;
+                }
+                resolve(); 
+            }
+        });
+
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            logStream.write(`\n\n[ERROR] Spawn failed: ${err.message}\n`).catch(() => {});
+            reject(err);
+        });
+    });
+}

package/src/services/config/index.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./state.js";

package/src/services/config/settings.test.ts

@@ -0,0 +1,42 @@
+import { expect, test, describe, mock } from "bun:test";
+import { loadSettings, saveSettings, getConfiguredProvider, getConfiguredModel, updateModelSettings } from "./settings.js";
+import { mkdir, writeFile, readFile } from "node:fs/promises";
+
+// Mock fs/promises
+mock.module("node:fs/promises", () => ({
+  readFile: async (path: string) => {
+    if (path.includes("/.pickle/settings.json")) {
+      return JSON.stringify({
+        model: {
+          provider: "gemini",
+          model: "gemini-3-flash"
+        }
+      });
+    }
+    throw new Error("File not found");
+  },
+  writeFile: async () => {},
+  mkdir: async () => {}
+}));
+
+mock.module("node:os", () => ({
+  homedir: () => "/home/testuser"
+}));
+
+describe("Settings", () => {
+  test("loadSettings should parse settings.json", async () => {
+    const settings = await loadSettings();
+    expect(settings.model?.provider).toBe("gemini");
+    expect(settings.model?.model).toBe("gemini-3-flash");
+  });
+
+  test("getConfiguredProvider should return provider from settings", async () => {
+    const provider = await getConfiguredProvider();
+    expect(provider).toBe("gemini");
+  });
+
+  test("getConfiguredModel should return model from settings", async () => {
+    const model = await getConfiguredModel();
+    expect(model).toBe("gemini-3-flash");
+  });
+});

package/src/services/config/settings.ts

@@ -0,0 +1,220 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { PickleSettings, PickleSettingsSchema } from "./types.js";
+import type { AIProviderName } from "../providers/types.js";
+
+const SETTINGS_DIR = join(homedir(), ".pickle");
+const SETTINGS_PATH = join(SETTINGS_DIR, "settings.json");
+
+// Valid provider names
+const VALID_PROVIDERS = [
+  "gemini", "opencode", "claude", "cursor", "codex", 
+  "qwen", "droid", "copilot"
+] as const;
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+  fixed?: string; // Fixed JSON string if applicable
+}
+
+/**
+ * Attempt to fix common JSON syntax errors
+ */
+function fixJsonSyntax(jsonString: string): string | null {
+  // Remove trailing commas before } or ]
+  let fixed = jsonString.replace(/,(\s*[}\]])/g, '$1');
+  
+  // Try to parse the fixed JSON
+  try {
+    JSON.parse(fixed);
+    return fixed;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate settings file content
+ */
+export function validateSettings(content: string): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  
+  // Check if content is empty
+  if (!content || content.trim() === "") {
+    return { valid: false, errors: ["Settings file is empty"], warnings };
+  }
+  
+  // Try to parse JSON
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(content);
+  } catch (parseError) {
+    // Try to fix common syntax errors
+    const fixed = fixJsonSyntax(content);
+    if (fixed) {
+      try {
+        parsed = JSON.parse(fixed);
+        warnings.push("Fixed trailing comma in JSON");
+      } catch {
+        errors.push(`Invalid JSON syntax: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+        return { valid: false, errors, warnings, fixed: undefined };
+      }
+    } else {
+      errors.push(`Invalid JSON syntax: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+      return { valid: false, errors, warnings, fixed: undefined };
+    }
+  }
+  
+  // Keep track if we fixed the JSON
+  const wasFixed = parsed !== undefined && content !== JSON.stringify(parsed);
+  
+  // Validate against schema
+  const schemaResult = PickleSettingsSchema.safeParse(parsed);
+  if (!schemaResult.success) {
+    schemaResult.error.errors.forEach((err) => {
+      errors.push(`Schema error at ${err.path.join('.')}: ${err.message}`);
+    });
+    return { valid: false, errors, warnings, fixed: wasFixed ? JSON.stringify(parsed) : undefined };
+  }
+  
+  const settings = schemaResult.data;
+  
+  // Validate provider if specified
+  if (settings.model?.provider) {
+    if (!VALID_PROVIDERS.includes(settings.model.provider as typeof VALID_PROVIDERS[number])) {
+      errors.push(
+        `Invalid provider "${settings.model.provider}". ` +
+        `Must be one of: ${VALID_PROVIDERS.join(", ")}`
+      );
+    }
+  }
+  
+  // Validate model string if specified
+  if (settings.model?.model !== undefined) {
+    if (typeof settings.model.model !== "string") {
+      errors.push("Model must be a string");
+    } else if (settings.model.model.trim() === "") {
+      warnings.push("Model name is empty - provider default will be used");
+    }
+  }
+  
+  // Warn if no provider configured
+  if (!settings.model?.provider) {
+    warnings.push("No provider configured - will use default (Gemini)");
+  }
+  
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    fixed: wasFixed ? JSON.stringify(parsed, null, 2) : undefined
+  };
+}
+
+/**
+ * Validate and load settings with detailed error reporting
+ */
+export async function loadSettingsWithValidation(): Promise<{ settings: PickleSettings; validation: ValidationResult }> {
+  try {
+    const content = await readFile(SETTINGS_PATH, "utf-8");
+    const validation = validateSettings(content);
+    
+    // If we have a fixed version, use it
+    const parsed = validation.fixed 
+      ? JSON.parse(validation.fixed)
+      : JSON.parse(content);
+    
+    const settings = PickleSettingsSchema.parse(parsed);
+    return { settings, validation };
+  } catch (e) {
+    // File doesn't exist or is completely unreadable
+    if ((e as NodeJS.ErrnoException).code === "ENOENT") {
+      return {
+        settings: {},
+        validation: {
+          valid: true,
+          errors: [],
+          warnings: ["Settings file does not exist - using defaults"]
+        }
+      };
+    }
+    
+    return {
+      settings: {},
+      validation: {
+        valid: false,
+        errors: [`Failed to load settings: ${e instanceof Error ? e.message : String(e)}`],
+        warnings: []
+      }
+    };
+  }
+}
+
+/**
+ * Load settings from ~/.pickle/settings.json
+ * Returns default settings if file doesn't exist or is invalid
+ */
+export async function loadSettings(): Promise<PickleSettings> {
+  try {
+    const content = await readFile(SETTINGS_PATH, "utf-8");
+    const json = JSON.parse(content);
+    return PickleSettingsSchema.parse(json);
+  } catch (e) {
+    // Return empty/default settings if file doesn't exist or is invalid
+    return {};
+  }
+}
+
+/**
+ * Save settings to ~/.pickle/settings.json
+ * Creates the directory if it doesn't exist
+ */
+export async function saveSettings(settings: PickleSettings): Promise<void> {
+  try {
+    await mkdir(SETTINGS_DIR, { recursive: true });
+    const validated = PickleSettingsSchema.parse(settings);
+    await writeFile(SETTINGS_PATH, JSON.stringify(validated, null, 2), "utf-8");
+  } catch (e) {
+    throw new Error(`Failed to save settings: ${e}`);
+  }
+}
+
+/**
+ * Get the configured provider name from settings
+ * Returns undefined if not configured
+ */
+export async function getConfiguredProvider(): Promise<string | undefined> {
+  const settings = await loadSettings();
+  return settings.model?.provider;
+}
+
+/**
+ * Get the configured model name from settings
+ * Returns undefined if not configured
+ */
+export async function getConfiguredModel(): Promise<string | undefined> {
+  const settings = await loadSettings();
+  return settings.model?.model;
+}
+
+/**
+ * Update specific model settings
+ */
+export async function updateModelSettings(
+  provider?: AIProviderName,
+  model?: string
+): Promise<void> {
+  const settings = await loadSettings();
+  const newSettings: PickleSettings = {
+    ...settings,
+    model: {
+      provider,
+      model,
+    },
+  };
+  await saveSettings(newSettings);
+}

package/src/services/config/state.test.ts

@@ -0,0 +1,88 @@
+import { mock, expect, test, describe, beforeEach } from "bun:test";
+import { join } from "node:path";
+
+const mockFiles = new Map<string, string>();
+
+mock.module("node:fs", () => ({
+  existsSync: (path: string) => {
+    return mockFiles.has(path) || (path.includes(".pickle/sessions") && !path.includes("definitely-not-there"));
+  }
+}));
+
+mock.module("node:fs/promises", () => ({
+  readFile: async (path: string) => {
+    if (mockFiles.has(path)) return mockFiles.get(path);
+    throw new Error(`File not found: ${path}`);
+  },
+  writeFile: async (path: string, content: string) => {
+    mockFiles.set(path, content);
+  },
+  mkdir: async () => {},
+  readdir: async (path: string) => {
+    if (path.includes("sessions")) {
+      return [{ name: "session-1", isDirectory: () => true }];
+    }
+    return [];
+  }
+}));
+
+mock.module("node:os", () => ({
+  homedir: () => "/home/testuser"
+}));
+
+mock.module("./settings.js", () => ({
+  loadSettings: async () => ({ max_iterations: 15 })
+}));
+
+mock.module("../../utils/project-root.js", () => ({
+  findProjectRoot: () => "/project"
+}));
+
+// Import AFTER mocks
+const { getSessionPath, loadState, saveState, createSession } = await import("./state.js");
+
+describe("Config State", () => {
+  beforeEach(() => {
+    mockFiles.clear();
+  });
+
+  test("getSessionPath should return correct path", () => {
+    expect(getSessionPath("/app", "sid")).toBe(join("/app", ".pickle", "sessions", "sid"));
+  });
+
+  test("saveState and loadState should work together", async () => {
+    const sessionDir = "/project/.pickle/sessions/test-session";
+    const state: any = {
+      active: true,
+      working_dir: "/project",
+      step: "prd",
+      iteration: 1,
+      max_iterations: 10,
+      max_time_minutes: 60,
+      worker_timeout_seconds: 1200,
+      start_time_epoch: Date.now(),
+      completion_promise: "DONE",
+      original_prompt: "test prompt",
+      current_ticket: "t1",
+      history: [],
+      started_at: new Date().toISOString(),
+      session_dir: sessionDir
+    };
+
+    await saveState(sessionDir, state);
+    const loaded = await loadState(sessionDir);
+    expect(loaded).not.toBeNull();
+    expect(loaded?.original_prompt).toBe("test prompt");
+  });
+
+  test("loadState should return null if file does not exist", async () => {
+    const loaded = await loadState("/definitely-not-there");
+    expect(loaded).toBeNull();
+  });
+
+  test("createSession should initialize a valid session", async () => {
+    const state = await createSession("/project", "new session prompt");
+    expect(state.original_prompt).toBe("new session prompt");
+    expect(state.working_dir).toBe("/project");
+  });
+});