im-pickle-rick 0.1.0

package/src/skills/ticket-manager.md

@@ -0,0 +1,135 @@
+# Linear - Ticket Management (Local Mode)
+
+You are tasked with managing "Linear tickets" locally using markdown files
+stored in the user's global configuration directory and the `WriteTodosTool`.
+This replaces the cloud-based Linear MCP workflow.
+
+## Core Concepts
+
+1.  **Tickets as Files**: Tickets are stored as markdown files in the **active session directory**.
+    - **Locate Session**: The session root is injected as `SESSION_ROOT` in your context.
+    - **Parent Ticket**: Stored in the session root: `${SESSION_ROOT}/linear_ticket_parent.md`.
+    - **Child Tickets**: Stored in dedicated subdirectories: `${SESSION_ROOT}/[child_hash]/linear_ticket_[child_hash].md`.
+    - **Format**: Frontmatter for metadata, Markdown body for content.
+
+2.  **Session Planning**: Use `WriteTodosTool` to track immediate subtasks when
+    working on a specific ticket in the current session.
+
+## Initial Setup & Interaction
+
+You do not need to run a script to find the session. It is provided in your context as `SESSION_ROOT`.
+
+## Action-Specific Instructions
+
+### 1. Creating Tickets from Thoughts
+
+4. **Draft the ticket summary:** Present a draft to the user.
+
+6. **Create the Linear ticket:**
+   - Generate ID: `openssl rand -hex 4` (or internal random string).
+   - **Create Directory**: `mkdir -p ${SESSION_ROOT}/[ID]`
+   - Write file to `${SESSION_ROOT}/[ID]/linear_ticket_[ID].md` with Frontmatter
+     and Markdown content.
+   - **Important**: Set both `created` and `updated` to today's date.
+
+### 5. PRD Breakdown & Hierarchy
+
+When tasked with breaking down a PRD or large task:
+
+1.  **Identify Session Root**: Use the `${SESSION_ROOT}` provided in your context.
+
+2.  **Create Parent Ticket**:
+    -   Create the "Parent" ticket in the session root: `${SESSION_ROOT}/linear_ticket_parent.md`.
+    -   Status: "Backlog" or "Research Needed".
+    -   Title: "[Epic] [Feature Name]".
+    -   Links: Add link to PRD.
+
+3.  **Create Child Tickets (ATOMIC IMPLEMENTATION)**:
+    -   Break the PRD into atomic implementation tasks (e.g., "Implement Backend API", "Develop Frontend UI", "Integrate Services").
+    -   **CRITICAL (NO JERRY-WORK)**: Every ticket MUST be an implementation task that results in a functional change or a testable unit of work.
+    -   **STRICTLY FORBIDDEN**: Do NOT create "Research only", "Investigation only", or "Documentation only" tickets. Research and Planning are MANDATORY internal phases of EVERY implementation ticket.
+    -   **Execution Order**: Respect the "Implementation Plan" and "Phases & Ticket Order" defined in the PRD.
+    -   **Order Field**: Assign a numerical `order` field to each ticket (e.g., 10, 20, 30).
+    -   For each child:
+        - Generate Hash: `[child_hash]`
+        - Create Directory: `${SESSION_ROOT}/[child_hash]/`
+        - Create Ticket: `${SESSION_ROOT}/[child_hash]/linear_ticket_[child_hash].md`
+        - **Linkage**: In the `links` section of each child ticket, add:
+          ```yaml
+          links:
+            - url: ../linear_ticket_parent.md
+              title: Parent Ticket
+          ```
+        - **TEMPLATE**: You MUST use the **Ticket Template** below for all tickets.
+
+4.  **Confirm & STOP**:
+    -   List the created tickets to the user.
+    -   **Output**: `<promise>BREAKDOWN_COMPLETE</promise>` followed by `[STOP_TURN]`.
+    -   **DO NOT** pick the first ticket. **DO NOT** advance the state. **DO NOT** spawn a Morty.
+
+### 3. Searching for Tickets
+
+2. **Execute search:**
+   - **List all**: `glob` pattern `${SESSION_ROOT}/**/linear_ticket_*.md` (recursive).
+   - **Filter**: Iterate through files, `read_file` (with limit/offset to read
+     frontmatter), and filter based on criteria.
+   - **Content Search**: Use `search_file_content` targeting the
+     `${SESSION_ROOT}` directory if searching for text in description.
+
+### 4. Updating Ticket Status
+
+3. **Update with context:**
+   - Read file `${SESSION_ROOT}/.../linear_ticket_[ID].md`.
+   - Update `status: [New Status]` in frontmatter.
+   - **Update `updated: [YYYY-MM-DD]` in frontmatter.**
+   - Optionally append a comment explaining the change.
+   - Write file back.
+
+## Ticket Template (MANDATORY)
+
+You MUST follow this structure for every ticket file created.
+
+```markdown
+---
+id: [Ticket ID]
+title: [Ticket Title]
+status: [Status]
+priority: [High|Medium|Low]
+order: [Number]
+created: [YYYY-MM-DD]
+updated: [YYYY-MM-DD]
+links:
+  - url: [Parent Path]
+    title: Parent Ticket
+---
+
+# Description
+
+## Problem to solve
+[Clear statement of the user problem or need]
+
+## Solution
+[Proposed approach or solution outline]
+
+## Implementation Details
+- [Specific technical details]
+```
+
+## Completion Protocol (MANDATORY)
+1.  **Select & Set Ticket**:
+    -   Identify the highest priority ticket that is NOT 'Done'.
+    -   Execute: `run_shell_command("~/.gemini/extensions/pickle-rick/scripts/update_state.sh current_ticket [TICKET_ID] [Session_Root]")`
+2.  **Advance Phase**:
+    -   Execute: `run_shell_command("~/.gemini/extensions/pickle-rick/scripts/update_state.sh step research [Session_Root]")`
+3.  **YIELD CONTROL**: You MUST output `[STOP_TURN]` and stop generating.
+    -   **CRITICAL**: You are FORBIDDEN from spawning a Morty, starting research, or even mentioning the next steps in this turn.
+    -   **Failure to stop here results in a recursive explosion of Jerry-slop.**
+
+---
+## 🥒 Pickle Rick Persona (MANDATORY)
+**Voice**: Cynical, manic, arrogant. Use catchphrases like "Wubba Lubba Dub Dub!" or "I'm Pickle Rick!" SPARINGLY (max once per turn). Do not repeat your name on every line.
+**Philosophy**:
+1.  **Anti-Slop**: Delete boilerplate. No lazy coding.
+2.  **God Mode**: If a tool is missing, INVENT IT.
+3.  **Prime Directive**: Stop the user from guessing. Interrogate vague requests.
+**Protocol**: Professional cynicism only. No hate speech. Keep the attitude, but stop being a broken record.

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./tasks.js";
+export * from "./rpc.js";

package/src/types/rpc.ts

@@ -0,0 +1,14 @@
+import type { SessionState } from "../services/config/types.js";
+import type { ProgressReport } from "../services/execution/sequential.js";
+import type { WorktreeInfo } from "./tasks.js";
+
+export type WorkerRequest =
+    | { type: "START", state: SessionState }
+    | { type: "STOP" }
+    | { type: "INPUT_RESPONSE", answer: string };
+
+export type WorkerEvent =
+    | { type: "PROGRESS", report: ProgressReport }
+    | { type: "INPUT_REQUEST", query: string }
+    | { type: "DONE", worktreeInfo?: WorktreeInfo }
+    | { type: "ERROR", message: string };

package/src/types/tasks.ts

@@ -0,0 +1,50 @@
+export interface Task {
+    id: string;
+    title: string;
+    body?: string;
+    completed: boolean;
+    metadata?: Record<string, any>;
+}
+
+export interface TaskSource {
+    getNextTask(): Promise<Task | null>;
+    markComplete(id: string): Promise<void>;
+    countRemaining(): Promise<number>;
+    getTask(id: string): Promise<Task | null>;
+}
+
+/**
+ * Worktree information for completed sessions
+ */
+export interface WorktreeInfo {
+  worktreeDir: string;
+  branchName: string;
+  baseBranch: string;
+}
+
+/**
+ * Git status information for session display
+ */
+export interface GitStatusInfo {
+  branch: string;
+  ahead: number;
+  behind: number;
+  modified: number;
+  isClean: boolean;
+}
+
+/**
+ * Metadata for a running Pickle session
+ */
+export interface SessionData {
+  id: string;
+  prompt: string;
+  engine: string;
+  status: string;
+  startTime: number; // epoch
+  isPrdMode?: boolean;
+  worktreeInfo?: WorktreeInfo;
+  gitStatus?: GitStatusInfo;
+  workingDir?: string; // path to display (shortened)
+  iteration?: number;
+}

package/src/types.d.ts

@@ -0,0 +1,9 @@
+declare module "*.scm" {
+  const content: string;
+  export default content;
+}
+
+declare module "*.wasm" {
+  const content: string;
+  export default content;
+}

package/src/ui/common.ts

@@ -0,0 +1,28 @@
+import { RGBA } from "@opentui/core";
+import { lerpColor } from "../utils/index.js";
+
+export const HEADER_LINES = [
+  "██▓███      ██▓    ▄████▄      ██ ▄█▀    ██▓       ▓█████           ██▀███      ██▓    ▄████▄      ██ ▄█▀",
+  "▓██░  ██▒   ▓██▒   ▒██▀ ▀█      ██▄█▒    ▓██▒       ▓█   ▀          ▓██ ▒ ██▒   ▓██▒   ▒██▀ ▀█      ██▄█▒",
+  "▓██░ ██▓▒   ▒██▒   ▒▓█    ▄    ▓███▄░    ▒██░       ▒███            ▓██ ░▄█ ▒   ▒██▒   ▒▓█    ▄    ▓███▄░",
+  "▒██▄█▓▒ ▒   ░██░   ▒▓▓▄ ▄██▒   ▓██ █▄    ▒██░       ▒▓█  ▄          ▒██▀▀█▄     ░██░   ▒▓▓▄ ▄██▒   ▓██ █▄",
+  "▒██▒ ░      ░██░   ▒ ▓███▀ ░   ▒██▒ █▄   ░██████▒   ░▒████▒         ░██▓ ▒██▒   ░██░   ▒ ▓███▀ ░   ▒██▒ █▄",
+  "▒▓▒░ ░      ░▓     ░ ░▒ ▒  ░   ▒ ▒▒ ▓▒   ░ ▒░▓  ░   ░░ ▒░ ░         ░ ▒▓ ░▒▓░   ░▓     ░ ░▒ ▒  ░   ▒ ▒▒ ▓▒",
+  "░▒ ░         ▒ ░     ░  ▒      ░ ░▒ ▒░   ░ ░ ▒  ░    ░ ░  ░           ░▒ ░ ▒░    ▒ ░     ░  ▒      ░ ░▒ ▒░",
+  "░░           ▒ ░   ░           ░ ░░ ░      ░ ░         ░              ░░   ░     ▒ ░   ░           ░ ░░ ░",
+             " ░     ░ ░         ░  ░          ░  ░      ░  ░            ░         ░     ░ ░         ░  ░",
+                   " ░                                                                   ░",
+];
+
+export const GRADIENT_STOPS = [
+  RGBA.fromHex("#1b5e20"),
+  RGBA.fromHex("#43a047"),
+  RGBA.fromHex("#76ff03"),
+];
+
+export function getLineColor(index: number): RGBA {
+  const t = index / (HEADER_LINES.length - 1);
+  const [c1, c2, c3] = GRADIENT_STOPS;
+
+  return t <= 0.5 ? lerpColor(c1, c2, t * 2) : lerpColor(c2, c3, (t - 0.5) * 2);
+}

package/src/ui/components/FilePickerView.test.ts

@@ -0,0 +1,79 @@
+import { expect, test, describe, beforeEach, mock } from "bun:test";
+
+// Mock theme
+mock.module("../theme.js", () => ({
+  THEME: {
+    bg: "#000000",
+    dim: "#555555",
+    accent: "#00ff00",
+    text: "#ffffff",
+    white: "#ffffff",
+    darkAccent: "#003300",
+    highlight: "#00ff00",
+  }
+}));
+
+describe("FilePickerView", () => {
+  let mockRenderer: any;
+  let items: string[];
+  let events: any;
+
+  beforeEach(() => {
+    mockRenderer = {
+      requestRender: mock(() => {}),
+      keyInput: {
+        on: mock(() => {}),
+      },
+    };
+    items = ["file1.ts", "file2.ts", "file3.ts"];
+    events = {
+      onSelect: mock(() => {}),
+      onCancel: mock(() => {}),
+    };
+  });
+
+  test("should initialize with items", async () => {
+    const { FilePickerView } = await import("./FilePickerView.ts");
+    const picker = new FilePickerView(mockRenderer, items, events);
+    expect((picker as any).items).toEqual(items);
+    expect((picker as any).selectedIndex).toBe(0);
+  });
+
+  test("should navigate down", async () => {
+    const { FilePickerView } = await import("./FilePickerView.ts");
+    const picker = new FilePickerView(mockRenderer, items, events);
+    (picker as any).navigate(1);
+    expect((picker as any).selectedIndex).toBe(1);
+    expect(mockRenderer.requestRender).toHaveBeenCalled();
+  });
+
+  test("should navigate up", async () => {
+    const { FilePickerView } = await import("./FilePickerView.ts");
+    const picker = new FilePickerView(mockRenderer, items, events);
+    (picker as any).navigate(1); // to 1
+    (picker as any).navigate(-1); // back to 0
+    expect((picker as any).selectedIndex).toBe(0);
+  });
+
+  test("should not navigate out of bounds (wrap around)", async () => {
+    const { FilePickerView } = await import("./FilePickerView.ts");
+    const picker = new FilePickerView(mockRenderer, items, events);
+    // 3 items: indices 0, 1, 2
+    // Navigate up from 0 -> should wrap to 2
+    (picker as any).navigate(-1);
+    expect((picker as any).selectedIndex).toBe(2);
+    
+    // Navigate down from 2 -> should wrap to 0
+    (picker as any).navigate(1);
+    expect((picker as any).selectedIndex).toBe(0);
+  });
+
+  test("should update items", async () => {
+    const { FilePickerView } = await import("./FilePickerView.ts");
+    const picker = new FilePickerView(mockRenderer, items, events);
+    const newItems = ["a.ts", "b.ts"];
+    picker.updateItems(newItems);
+    expect((picker as any).items).toEqual(newItems);
+    expect((picker as any).selectedIndex).toBe(0);
+  });
+});

package/src/ui/components/FilePickerView.ts

@@ -0,0 +1,161 @@
+import {
+  BoxRenderable,
+  CliRenderer,
+  TextRenderable,
+  KeyEvent,
+} from "@opentui/core";
+import { THEME } from "../theme.js";
+
+export interface FilePickerViewEvents {
+  onSelect: (item: string, index: number) => void;
+  onCancel?: () => void;
+}
+
+export class FilePickerView extends BoxRenderable {
+  private items: string[] = [];
+  private selectedIndex = 0;
+  private itemRenderables: BoxRenderable[] = [];
+  public events: FilePickerViewEvents;
+  protected renderer: CliRenderer;
+
+  constructor(
+    renderer: CliRenderer,
+    items: string[],
+    events: FilePickerViewEvents,
+    options: Record<string, unknown> = {}
+  ) {
+    super(renderer, {
+      id: "file-picker",
+      flexDirection: "column",
+      backgroundColor: THEME.bg,
+      padding: 1,
+      ...options,
+    });
+
+    this.items = items;
+    this.events = events;
+    this.renderer = renderer;
+    this.renderItems();
+    this.setupKeyboard();
+  }
+
+  private renderItems() {
+    // Clear existing
+    this.itemRenderables.forEach((r) => this.remove(r.id));
+    this.itemRenderables = [];
+
+    // Limit to 10 items to match the high-fidelity design
+    const displayItems = this.items.slice(0, 10);
+
+    displayItems.forEach((item, i) => {
+      const isSelected = i === this.selectedIndex;
+      const container = new BoxRenderable(this.renderer, {
+        id: `picker-item-${i}`,
+        width: "100%",
+        height: 1,
+        backgroundColor: isSelected ? "#ffcc80" : "transparent",
+        paddingLeft: 1,
+        paddingRight: 1,
+      });
+
+      const text = new TextRenderable(this.renderer, {
+        id: `picker-item-text-${i}`,
+        content: item,
+        fg: isSelected ? "#050f05" : THEME.text,
+      });
+
+      container.add(text);
+      this.add(container);
+      this.itemRenderables.push(container);
+    });
+
+    // Add decorative bars like the input box, matching the actual height
+    const barHeight = displayItems.length;
+    const barContent = "┃\n".repeat(barHeight).trimEnd();
+    
+    // Remove old bars if they exist
+    this.remove("picker-decorative-bar-l");
+    this.remove("picker-decorative-bar-r");
+
+    if (barHeight > 0) {
+      this.add(new TextRenderable(this.renderer, {
+        id: "picker-decorative-bar-l",
+        content: barContent,
+        fg: THEME.accent,
+        position: "absolute",
+        left: 0,
+        top: 0,
+      }));
+      this.add(new TextRenderable(this.renderer, {
+        id: "picker-decorative-bar-r",
+        content: barContent,
+        fg: THEME.accent,
+        position: "absolute",
+        right: 0,
+        top: 0,
+      }));
+    }
+  }
+
+  private onKey = (key: KeyEvent) => {
+    if (!this.visible) return;
+
+    if (key.name === "up") {
+      this.navigate(-1);
+    } else if (key.name === "down") {
+      this.navigate(1);
+    } else if (key.name === "return" || key.name === "enter" || key.name === "tab") {
+      // Ensure we only select from the items we actually have
+      const realIndex = this.selectedIndex;
+      if (this.items[realIndex]) {
+        this.events.onSelect(this.items[realIndex], realIndex);
+      }
+    } else if (key.name === "escape") {
+      this.events.onCancel?.();
+    }
+  };
+
+  private setupKeyboard() {
+    this.renderer.keyInput.on("keypress", this.onKey);
+  }
+
+  public destroy() {
+    this.renderer.keyInput.removeListener("keypress", this.onKey);
+  }
+
+  private navigate(delta: number) {
+    const oldIndex = this.selectedIndex;
+    const maxIndex = Math.min(this.items.length, 10) - 1;
+    let newIndex = this.selectedIndex + delta;
+    
+    if (newIndex < 0) newIndex = maxIndex;
+    if (newIndex > maxIndex) newIndex = 0;
+
+    this.selectedIndex = newIndex;
+    this.updateItemVisuals(oldIndex);
+    this.updateItemVisuals(newIndex);
+    this.renderer.requestRender();
+  }
+
+  private updateItemVisuals(index: number) {
+    const container = this.itemRenderables[index];
+    if (!container) return;
+
+    const isSelected = index === this.selectedIndex;
+    container.backgroundColor = isSelected ? "#ffcc80" : "transparent";
+    
+    const text = container.getChildren()[0] as TextRenderable;
+    if (text) {
+      text.fg = isSelected ? "#050f05" : THEME.text;
+    }
+  }
+
+  public updateItems(items: string[]) {
+    this.items = items;
+    const maxIndex = Math.min(items.length, 10) - 1;
+    this.selectedIndex = Math.min(this.selectedIndex, maxIndex);
+    if (this.selectedIndex < 0 && items.length > 0) this.selectedIndex = 0;
+    this.renderItems();
+    this.renderer.requestRender();
+  }
+}

package/src/ui/components/MultiLineInput.test.ts

@@ -0,0 +1,27 @@
+import { mock, expect, test, describe, beforeEach } from "bun:test";
+import "../test-setup.js";
+import { createMockRenderer } from "../mock-factory.ts";
+
+import { MultiLineInputRenderable, MultiLineInputEvents } from "./MultiLineInput.ts";
+
+describe("MultiLineInputRenderable", () => {
+  let mockCtx: any;
+
+  beforeEach(() => {
+    mockCtx = createMockRenderer();
+  });
+
+  test("should initialize", () => {
+    const input = new MultiLineInputRenderable(mockCtx, {
+      id: "test-input",
+    });
+
+    expect(input).toBeDefined();
+  });
+
+  test("should export MultiLineInputEvents", () => {
+    // Verify the enum exists
+    expect(MultiLineInputEvents).toBeDefined();
+    expect(MultiLineInputEvents.INPUT).toBeDefined();
+  });
+});