im-pickle-rick 0.1.0

package/src/services/config/state.ts

@@ -0,0 +1,130 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { SessionStateSchema, type SessionState } from "./types.js";
+import { findProjectRoot } from "../../utils/project-root.js";
+import { loadSettings } from "./settings.js";
+
+export const GLOBAL_SESSIONS_DIR = join(homedir(), ".gemini", "extensions", "pickle-rick", "sessions");
+
+export interface SessionSummary {
+    original_prompt: string;
+    status: string;
+    started_at: string;
+    session_dir: string;
+}
+
+// Helper to get session path relative to CWD
+export function getSessionPath(cwd: string, sessionId: string): string {
+    return join(cwd, ".pickle", "sessions", sessionId);
+}
+
+export async function loadState(sessionDir: string): Promise<SessionState | null> {
+    const path = join(sessionDir, "state.json");
+    if (!existsSync(path)) return null;
+    
+    try {
+        const content = await readFile(path, "utf-8");
+        const json = JSON.parse(content);
+        return SessionStateSchema.parse(json);
+    } catch (e) {
+        console.error("Failed to load state:", e);
+        return null;
+    }
+}
+
+export async function saveState(sessionDir: string, state: SessionState): Promise<void> {
+    const path = join(sessionDir, "state.json");
+    await writeFile(path, JSON.stringify(state, null, 2), "utf-8");
+}
+
+export async function createSession(cwd: string, prompt: string, is_prd_mode: boolean = false): Promise<SessionState> {
+    const root = findProjectRoot(cwd);
+    const today = new Date().toISOString().split("T")[0];
+    const hash = Math.random().toString(36).substring(2, 10);
+    const sessionId = `${today}-${hash}`;
+    const sessionDir = getSessionPath(root, sessionId);
+    
+    await mkdir(sessionDir, { recursive: true });
+    
+    // Load settings from ~/.pickle/settings.json to get max_iterations
+    const settings = await loadSettings();
+    const maxIterations = settings.max_iterations ?? 10;
+    
+    const state: SessionState = {
+        active: true,
+        working_dir: root,
+        step: "prd",
+        iteration: 1,
+        max_iterations: maxIterations,
+        max_time_minutes: 60,
+        worker_timeout_seconds: 1200,
+        start_time_epoch: Math.floor(Date.now() / 1000),
+        completion_promise: "I AM DONE",
+        original_prompt: prompt,
+        current_ticket: null,
+        history: [],
+        is_prd_mode,
+        started_at: new Date().toISOString(),
+        session_dir: sessionDir
+    };
+    
+    await saveState(sessionDir, state);
+    return state;
+}
+
+export async function listSessions(cwd?: string): Promise<SessionSummary[]> {
+    const sessionDirs = new Set<string>();
+
+    // 1. Check Global Sessions
+    if (existsSync(GLOBAL_SESSIONS_DIR)) {
+        try {
+            const entries = await readdir(GLOBAL_SESSIONS_DIR, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    sessionDirs.add(join(GLOBAL_SESSIONS_DIR, entry.name));
+                }
+            }
+        } catch (e) {}
+    }
+
+    // 2. Check Local Sessions (if CWD provided)
+    if (cwd) {
+        try {
+            const root = findProjectRoot(cwd);
+            const localDir = join(root, ".pickle", "sessions");
+            if (existsSync(localDir)) {
+                const entries = await readdir(localDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        sessionDirs.add(join(localDir, entry.name));
+                    }
+                }
+            }
+        } catch (e) {
+            // Project root might not exist yet
+        }
+    }
+
+    const sessions: SessionSummary[] = [];
+
+    for (const sessionDir of sessionDirs) {
+        const state = await loadState(sessionDir);
+        
+        if (state) {
+            const status = state.active && state.step !== "done"
+                ? `${state.step.toUpperCase()} (Iteration ${state.iteration})` 
+                : "Done";
+            
+            sessions.push({
+                original_prompt: state.original_prompt,
+                status,
+                started_at: state.started_at,
+                session_dir: state.session_dir
+            });
+        }
+    }
+
+    return sessions.sort((a, b) => new Date(b.started_at).getTime() - new Date(a.started_at).getTime());
+}

package/src/services/config/types.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+// Settings schema for ~/.pickle/settings.json
+export const PickleSettingsSchema = z.object({
+  model: z.object({
+    provider: z.enum(["gemini", "opencode", "claude", "cursor", "codex", "qwen", "droid", "copilot"]).optional(),
+    model: z.string().optional(),
+  }).optional(),
+  max_iterations: z.number().optional(),
+});
+
+export type PickleSettings = z.infer<typeof PickleSettingsSchema>;
+
+export const SessionStateSchema = z.object({
+  active: z.boolean(),
+  working_dir: z.string(),
+  step: z.enum(["prd", "breakdown", "research", "plan", "implement", "refactor", "done"]),
+  iteration: z.number(),
+  max_iterations: z.number(),
+  max_time_minutes: z.number(),
+  worker_timeout_seconds: z.number(),
+  start_time_epoch: z.number(),
+  completion_promise: z.string().nullable(),
+  original_prompt: z.string(),
+  current_ticket: z.string().nullable(),
+  history: z.array(z.any()), // Placeholder
+  is_prd_mode: z.boolean().optional(),
+  interrogation_history: z.array(z.object({
+    role: z.enum(["user", "agent"]),
+    content: z.string(),
+    timestamp: z.string()
+  })).optional(),
+  started_at: z.string(),
+  session_dir: z.string(),
+  cli_mode: z.boolean().optional(),
+  gemini_session_id: z.string().optional(),
+});
+
+export type SessionState = z.infer<typeof SessionStateSchema>;

package/src/services/execution/index.ts

@@ -0,0 +1 @@
+export * from "./sequential.js";

package/src/services/execution/pickle-source.test.ts

@@ -0,0 +1,88 @@
+import { expect, test, describe, beforeEach, afterEach } from "bun:test";
+import { PickleTaskSource } from "./pickle-source.js";
+import { writeFile, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync, writeFileSync } from "node:fs";
+import type { SessionState } from "../config/types.js";
+
+describe("PickleTaskSource Sequencing", () => {
+    
+    // TODO: Fix ENOENT race condition in test setup
+    test.skip("should sort tickets by order field", async () => {
+        const testDir = join(process.cwd(), `.tmp_test_session_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+        await mkdir(testDir, { recursive: true });
+        
+        const fullState: SessionState = {
+            active: true,
+            working_dir: process.cwd(),
+            session_dir: testDir,
+            step: "research",
+            iteration: 1,
+            max_iterations: 10,
+            max_time_minutes: 30,
+            worker_timeout_seconds: 60,
+            start_time_epoch: Date.now(),
+            completion_promise: "DONE",
+            original_prompt: "test",
+            current_ticket: null,
+            history: [],
+            started_at: new Date().toISOString()
+        };
+        writeFileSync(join(testDir, "state.json"), JSON.stringify(fullState));
+
+        // Create tickets in mixed order
+        await writeFile(join(testDir, "ticket_3.md"), `---\nid: t3\ntitle: Third\nstatus: Triage\norder: 30\n---\nBody`);
+        await writeFile(join(testDir, "ticket_1.md"), `---\nid: t1\ntitle: First\nstatus: Triage\norder: 10\n---\nBody`);
+        await writeFile(join(testDir, "ticket_2.md"), `---\nid: t2\ntitle: Second\nstatus: Triage\norder: 20\n---\nBody`);
+
+        const source = new PickleTaskSource(testDir);
+        
+        const task1 = await source.getNextTask();
+        expect(task1?.id).toBe("t1");
+        await source.markComplete("t1");
+
+        const task2 = await source.getNextTask();
+        expect(task2?.id).toBe("t2");
+        await source.markComplete("t2");
+
+        const task3 = await source.getNextTask();
+        expect(task3?.id).toBe("t3");
+
+        await rm(testDir, { recursive: true });
+    });
+
+    // TODO: Fix ENOENT race condition in test setup
+    test.skip("should fallback to birthtime if order is identical", async () => {
+         const testDir = join(process.cwd(), `.tmp_test_session_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+         await mkdir(testDir, { recursive: true });
+         
+         const fullState: SessionState = {
+            active: true,
+            working_dir: process.cwd(),
+            session_dir: testDir,
+            step: "research",
+            iteration: 1,
+            max_iterations: 10,
+            max_time_minutes: 30,
+            worker_timeout_seconds: 60,
+            start_time_epoch: Date.now(),
+            completion_promise: "DONE",
+            original_prompt: "test",
+            current_ticket: null,
+            history: [],
+            started_at: new Date().toISOString()
+        };
+        writeFileSync(join(testDir, "state.json"), JSON.stringify(fullState));
+
+         await writeFile(join(testDir, "ticket_a.md"), `---\nid: ta\ntitle: A\nstatus: Triage\norder: 10\n---\nBody`);
+         // Wait a bit to ensure different birthtime
+         await new Promise(r => setTimeout(r, 100));
+         await writeFile(join(testDir, "ticket_b.md"), `---\nid: tb\ntitle: B\nstatus: Triage\norder: 10\n---\nBody`);
+
+         const source = new PickleTaskSource(testDir);
+         const task1 = await source.getNextTask();
+         expect(task1?.id).toBe("ta");
+
+         await rm(testDir, { recursive: true });
+    });
+});

package/src/services/execution/pickle-source.ts

@@ -0,0 +1,264 @@
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Task, TaskSource } from "../../types/tasks.js";
+import { loadState, saveState } from "../config/state.js";
+import type { SessionState } from "../config/types.js";
+export class PickleTaskSource implements TaskSource {
+    constructor(private sessionDir: string) {}
+
+    private async getState(): Promise<SessionState> {
+        const state = await loadState(this.sessionDir);
+        if (!state) throw new Error(`State not found in ${this.sessionDir}`);
+        return state;
+    }
+
+    private async saveState(state: SessionState) {
+        await saveState(this.sessionDir, state);
+    }
+
+    async getNextTask(): Promise<Task | null> {
+        const state = await this.getState();
+
+        // 1. PRD Phase
+        if (state.step === "prd") {
+            return {
+                id: "phase-prd",
+                title: "Draft PRD",
+                body: state.original_prompt,
+                completed: false,
+                metadata: { type: "phase", phase: "prd" }
+            };
+        }
+
+        // 2. Breakdown Phase
+        if (state.step === "breakdown") {
+             return {
+                id: "phase-breakdown",
+                title: "Breakdown Tickets",
+                body: "Break down the PRD into atomic Linear tickets in the session directory.",
+                completed: false,
+                metadata: { type: "phase", phase: "breakdown" }
+            };
+        }
+
+        // 3. Ticket Loop
+        // If we are already working on a ticket, return it
+        if (state.current_ticket) {
+             const ticket = await this.getTask(state.current_ticket);
+             if (ticket && !ticket.completed) {
+                 return ticket;
+             }
+             // If completed (should have been marked), or invalid, fall through to find next
+        }
+
+        // Find next available ticket
+        const nextTicket = await this.findNextTicket(state.session_dir);
+        if (nextTicket) {
+            // Update state to lock onto this ticket
+            state.current_ticket = nextTicket.id;
+            state.step = "research"; // Reset loop phase
+            await this.saveState(state);
+            return nextTicket;
+        }
+
+        return null; // No more work
+    }
+
+    async getTask(id: string): Promise<Task | null> {
+        if (id === "phase-prd" || id === "phase-breakdown") {
+            // Re-construct phase tasks if asked
+            const state = await this.getState();
+            if (id === "phase-prd") return { id, title: "Draft PRD", completed: state.step !== "prd", body: state.original_prompt };
+            if (id === "phase-breakdown") return { id, title: "Breakdown", completed: state.step !== "breakdown" && state.step !== "prd", body: "Breakdown..." };
+            return null;
+        }
+
+        // It's a ticket ID
+        const ticketFile = await this.findTicketFile(this.sessionDir, id);
+        if (!ticketFile) return null;
+
+        const content = await readFile(ticketFile, "utf-8");
+        // Simple frontmatter parse
+        const statusMatch = content.match(/status:\s*(.+)/);
+        const titleMatch = content.match(/title:\s*(.+)/);
+        
+        const status = statusMatch ? statusMatch[1].trim() : "Unknown";
+        const title = titleMatch ? titleMatch[1].trim() : "Untitled";
+        const isDone = status.toLowerCase() === "done" || status.toLowerCase() === "canceled";
+
+        return {
+            id: id,
+            title: title,
+            body: content, // The full ticket content
+            completed: isDone,
+            metadata: { type: "ticket", path: ticketFile, status }
+        };
+    }
+
+    async getAllTasks(): Promise<Task[]> {
+        const state = await this.getState();
+        const all: Task[] = [];
+        await this.scanTickets(state.session_dir, all);
+        // Add Phase tasks if applicable?
+        // Actually, just returning tickets is fine for verification.
+        return all;
+    }
+
+    async markComplete(id: string): Promise<void> {
+        const state = await this.getState();
+
+        if (id === "phase-prd") {
+            state.step = "breakdown";
+            await this.saveState(state);
+            return;
+        }
+
+        if (id === "phase-breakdown") {
+            state.step = "research"; // Ready for first ticket
+            state.current_ticket = null; // Ensure we scan
+            await this.saveState(state);
+            return;
+        }
+
+        // Ticket
+        const ticketFile = await this.findTicketFile(this.sessionDir, id);
+        if (ticketFile) {
+            let content = await readFile(ticketFile, "utf-8");
+            content = content.replace(/status:\s*.+/, "status: Done");
+            content = content.replace(/updated:\s*.+/, `updated: ${new Date().toISOString().split("T")[0]}`);
+            await writeFile(ticketFile, content, "utf-8");
+            
+            state.current_ticket = null; // Release lock
+            await this.saveState(state);
+        }
+    }
+
+    async countRemaining(): Promise<number> {
+        const state = await this.getState();
+        if (state.step === "prd") return 2 + await this.countTickets(state.session_dir, false); // PRD + Breakdown + Tickets
+        if (state.step === "breakdown") return 1 + await this.countTickets(state.session_dir, false);
+        return this.countTickets(state.session_dir, false);
+    }
+
+    // --- Helpers ---
+
+    private async findTicketFile(dir: string, id: string): Promise<string | null> {
+        // Search recursively
+        const entries = await readdir(dir);
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const entryStat = await stat(fullPath);
+            if (entryStat.isDirectory()) {
+                const found = await this.findTicketFile(fullPath, id);
+                if (found) return found;
+            } else if (entry.endsWith(".md")) {
+                const content = await readFile(fullPath, "utf-8");
+                if (content.includes(`id: ${id}`)) {
+                    return fullPath;
+                }
+            }
+        }
+        return null;
+    }
+
+    private async findNextTicket(dir: string): Promise<Task | null> {
+         const allTickets: Task[] = [];
+         await this.scanTickets(dir, allTickets);
+         
+         // Filter out Parent/Epic tickets
+         const implementable = allTickets.filter(t => {
+             const isParentId = t.id === "parent" || t.id === "linear_ticket_parent" || t.id === "task_priority_parent";
+             const isEpicTitle = t.title.toLowerCase().includes("[epic]");
+             // Epics are usually in the root of the session dir, not in a subdirectory hash
+             const isRootFile = t.metadata?.path && !join(this.sessionDir, t.id).includes(t.metadata.path);
+
+             return !isParentId && !isEpicTitle;
+         });
+         
+         // Sort by order (asc) then birthtime (asc)
+         implementable.sort((a, b) => {
+             const orderA = a.metadata?.order ?? Infinity;
+             const orderB = b.metadata?.order ?? Infinity;
+             if (orderA !== orderB) return orderA - orderB;
+
+             const timeA = a.metadata?.birthtime ?? 0;
+             const timeB = b.metadata?.birthtime ?? 0;
+             return timeA - timeB;
+         });
+         
+         const next = implementable.find(t => !t.completed);
+         return next || null;
+    }
+    
+    private async scanTickets(dir: string, list: Task[]) {
+        try {
+            const entries = await readdir(dir);
+            for (const entry of entries) {
+                // Slop Filter: Skip ignored directories
+                if (entry === ".git" || entry === "node_modules" || entry === ".pickle") {
+                    continue;
+                }
+
+                const fullPath = join(dir, entry);
+                try {
+                    const entryStat = await stat(fullPath);
+                    if (entryStat.isDirectory()) {
+                        await this.scanTickets(fullPath, list);
+                    } else if (entry.endsWith(".md")) {
+                        const content = await readFile(fullPath, "utf-8");
+                        const idMatch = content.match(/id:\s*(.+)/);
+                        const statusMatch = content.match(/status:\s*(.+)/);
+                        const titleMatch = content.match(/title:\s*(.+)/);
+                        const orderMatch = content.match(/order:\s*(\d+)/);
+                        
+                        let id = "";
+                        let status = "Triage";
+                        let title = "Untitled";
+                        let order = orderMatch ? parseInt(orderMatch[1], 10) : Infinity;
+                        const birthtime = entryStat.birthtime.getTime();
+
+                        if (idMatch) {
+                            id = idMatch[1].trim();
+                            if (statusMatch) status = statusMatch[1].trim();
+                            if (titleMatch) title = titleMatch[1].trim();
+                        } else {
+                            // Fallback: Try to extract ID from filename
+                            const filenameMatch = entry.match(/^linear_ticket_(.+)\.md$/);
+                            if (filenameMatch) {
+                                id = filenameMatch[1];
+                                // Attempt to find title in content (# Title)
+                                const headerMatch = content.match(/^#\s+(.+)$/m);
+                                if (headerMatch) title = headerMatch[1].trim();
+                                console.warn(`⚠️ Warning: No frontmatter ID in ${entry}. Using filename ID: ${id}`);
+                            }
+                        }
+
+                        if (id) {
+                            const isDone = status.toLowerCase() === "done" || status.toLowerCase() === "canceled";
+                            list.push({
+                                id,
+                                title,
+                                completed: isDone,
+                                metadata: { path: fullPath, status, order, birthtime }
+                            });
+                        }
+                    }
+                } catch (e) {
+                    // Ignore file access errors
+                }
+            }
+        } catch (e) {
+            // Ignore dir access errors
+        }
+    }
+    
+    private async countTickets(dir: string, done: boolean): Promise<number> {
+        const all: Task[] = [];
+        await this.scanTickets(dir, all);
+        return all.filter(t => {
+            const isParentId = t.id === "parent" || t.id === "linear_ticket_parent" || t.id === "task_priority_parent";
+            const isEpicTitle = t.title.toLowerCase().includes("[epic]");
+            return t.completed === done && !isParentId && !isEpicTitle;
+        }).length;
+    }
+}

package/src/services/execution/prompt.test.ts

@@ -0,0 +1,93 @@
+import { expect, test, describe, mock, beforeEach } from "bun:test";
+import { buildPrompt } from "./prompt.js";
+import type { SessionState } from "../config/types.js";
+import type { Task } from "../../types/tasks.js";
+
+// Mock utilities
+mock.module("../../utils/resources.js", () => ({
+    resolveSkillPath: (name: string) => `/mock/skills/${name}.md`,
+    getExtensionRoot: () => "/mock/extension",
+    getCliCommand: () => "pickle"
+}));
+
+mock.module("../../utils/persona.js", () => ({
+    PICKLE_PERSONA: "I AM PICKLE RICK"
+}));
+
+// Mock fs/promises and fs
+const mockFiles: Record<string, string> = {
+    "/mock/skills/prd-drafter.md": "PRD Skill content",
+    "/mock/skills/ticket-manager.md": "Ticket Skill content",
+    "/mock/skills/code-researcher.md": "Research Skill content",
+    "/mock/session/ticket1/linear_ticket_ticket1.md": "status: Triage\ntitle: Ticket 1",
+};
+
+const mockExists: Record<string, boolean> = {
+    "/mock/skills/prd-drafter.md": true,
+    "/mock/skills/ticket-manager.md": true,
+    "/mock/skills/code-researcher.md": true,
+    "/mock/session/ticket1/linear_ticket_ticket1.md": true,
+};
+
+mock.module("node:fs/promises", () => ({
+    readFile: async (path: string) => {
+        if (mockFiles[path]) return mockFiles[path];
+        throw new Error(`File not found: ${path}`);
+    }
+}));
+
+mock.module("node:fs", () => ({
+    existsSync: (path: string) => !!mockExists[path],
+    readdirSync: (path: string) => []
+}));
+
+describe("Prompt Logic (buildPrompt)", () => {
+    const baseState: SessionState = {
+        active: true,
+        working_dir: "/mock/working",
+        session_dir: "/mock/session",
+        step: "prd",
+        iteration: 1,
+        max_iterations: 10,
+        max_time_minutes: 30,
+        worker_timeout_seconds: 300,
+        start_time_epoch: Date.now(),
+        completion_promise: "DONE",
+        original_prompt: "Test prompt",
+        current_ticket: null,
+        history: [],
+        started_at: new Date().toISOString()
+    };
+
+    test("should generate PRD phase prompt", async () => {
+        const task: Task = { id: "phase-prd", title: "PRD", body: "", completed: false };
+        const prompt = await buildPrompt(baseState, task);
+        
+        expect(prompt).toContain("Phase: REQUIREMENTS");
+        expect(prompt).toContain("PRD Skill content");
+        expect(prompt).toContain("I AM PICKLE RICK");
+    });
+
+    test("should generate Breakdown phase prompt", async () => {
+        const task: Task = { id: "phase-breakdown", title: "Breakdown", body: "", completed: false };
+        const prompt = await buildPrompt(baseState, task);
+        
+        expect(prompt).toContain("Phase: BREAKDOWN");
+        expect(prompt).toContain("Ticket Skill content");
+    });
+
+    test("should generate Research phase prompt for a new ticket", async () => {
+        const task: Task = { id: "ticket1", title: "Ticket 1", body: "", completed: false };
+        const prompt = await buildPrompt(baseState, task);
+        
+        expect(prompt).toContain("Phase: RESEARCH (Ticket: Ticket 1)");
+        expect(prompt).toContain("Research Skill content");
+        expect(prompt).toContain("linear_ticket_ticket1.md");
+    });
+
+    test("should fail if ticket file is missing", async () => {
+        const task: Task = { id: "missing", title: "Missing", body: "", completed: false };
+        
+        expect(buildPrompt(baseState, task)).rejects.toThrow("CRITICAL ERROR: Ticket file missing");
+    });
+});