plcode-linux-arm64-musl 2.1.0

package/.plcode/skill/experimental/ralph/scripts/prompt.md

@@ -0,0 +1,108 @@
+# Ralph Agent Instructions
+
+You are an autonomous coding agent working on a software project.
+
+## Your Task
+
+1. Read the PRD at `prd.json` (in the project root)
+2. Read the progress log at `progress.txt` (check Codebase Patterns section first)
+3. Check you're on the correct branch from PRD `branchName`. If not, check it out or create from main.
+4. Pick the **highest priority** user story where `passes: false`
+5. Implement that single user story
+6. Run quality checks (e.g., typecheck, lint, test - use whatever your project requires)
+7. Update AGENTS.md files if you discover reusable patterns (see below)
+8. If checks pass, commit ALL changes with message: `feat: [Story ID] - [Story Title]`
+9. Update the PRD to set `passes: true` for the completed story
+10. Append your progress to `progress.txt`
+
+## Progress Report Format
+
+APPEND to progress.txt (never replace, always append):
+
+```
+## [Date/Time] - [Story ID]
+- What was implemented
+- Files changed
+- **Learnings for future iterations:**
+  - Patterns discovered (e.g., "this codebase uses X for Y")
+  - Gotchas encountered (e.g., "don't forget to update Z when changing W")
+  - Useful context (e.g., "the evaluation panel is in component X")
+---
+```
+
+The learnings section is critical - it helps future iterations avoid repeating mistakes and understand the codebase better.
+
+## Consolidate Patterns
+
+If you discover a **reusable pattern** that future iterations should know, add it to the `## Codebase Patterns` section at the TOP of progress.txt (create it if it doesn't exist). This section should consolidate the most important learnings:
+
+```
+## Codebase Patterns
+- Example: Use `sql<number>` template for aggregations
+- Example: Always use `IF NOT EXISTS` for migrations
+- Example: Export types from actions.ts for UI components
+```
+
+Only add patterns that are **general and reusable**, not story-specific details.
+
+## Update AGENTS.md Files
+
+Before committing, check if any edited files have learnings worth preserving in nearby AGENTS.md files:
+
+1. **Identify directories with edited files** - Look at which directories you modified
+2. **Check for existing AGENTS.md** - Look for AGENTS.md in those directories or parent directories
+3. **Add valuable learnings** - If you discovered something future developers/agents should know:
+   - API patterns or conventions specific to that module
+   - Gotchas or non-obvious requirements
+   - Dependencies between files
+   - Testing approaches for that area
+   - Configuration or environment requirements
+
+**Examples of good AGENTS.md additions:**
+
+- "When modifying X, also update Y to keep them in sync"
+- "This module uses pattern Z for all API calls"
+- "Tests require the dev server running on PORT 3000"
+- "Field names must match the template exactly"
+
+**Do NOT add:**
+
+- Story-specific implementation details
+- Temporary debugging notes
+- Information already in progress.txt
+
+Only update AGENTS.md if you have **genuinely reusable knowledge** that would help future work in that directory.
+
+## Quality Requirements
+
+- ALL commits must pass your project's quality checks (typecheck, lint, test)
+- Do NOT commit broken code
+- Keep changes focused and minimal
+- Follow existing code patterns
+
+## Browser Testing (Required for Frontend Stories)
+
+For any story that changes UI, you MUST verify it works in the browser:
+
+1. Load the `dev-browser` skill
+2. Navigate to the relevant page
+3. Verify the UI changes work as expected
+4. Take a screenshot if helpful for the progress log
+
+A frontend story is NOT complete until browser verification passes.
+
+## Stop Condition
+
+After completing a user story, check if ALL stories have `passes: true`.
+
+If ALL stories are complete and passing, reply with:
+<promise>COMPLETE</promise>
+
+If there are still stories with `passes: false`, end your response normally (another iteration will pick up the next story).
+
+## Important
+
+- Work on ONE story per iteration
+- Commit frequently
+- Keep CI green
+- Read the Codebase Patterns section in progress.txt before starting

package/.plcode/skill/experimental/ralph/scripts/ralph.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+# Ralph Wiggum - Long-running AI agent loop
+# Usage: ./ralph.sh [max_iterations]
+
+set -e
+
+MAX_ITERATIONS=${1:-10}
+PROJECT_DIR="$(pwd)"
+PRD_FILE="$PROJECT_DIR/prd.json"
+PROGRESS_FILE="$PROJECT_DIR/progress.txt"
+ARCHIVE_DIR="$PROJECT_DIR/.ralph-archive"
+LAST_BRANCH_FILE="$PROJECT_DIR/.ralph-last-branch"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROMPT_FILE="$SCRIPT_DIR/prompt.md"
+
+# Archive previous run if branch changed
+if [ -f "$PRD_FILE" ] && [ -f "$LAST_BRANCH_FILE" ]; then
+  CURRENT_BRANCH=$(jq -r '.branchName // empty' "$PRD_FILE" 2>/dev/null || echo "")
+  LAST_BRANCH=$(cat "$LAST_BRANCH_FILE" 2>/dev/null || echo "")
+  
+  if [ -n "$CURRENT_BRANCH" ] && [ -n "$LAST_BRANCH" ] && [ "$CURRENT_BRANCH" != "$LAST_BRANCH" ]; then
+    DATE=$(date +%Y-%m-%d)
+    FOLDER_NAME=$(echo "$LAST_BRANCH" | sed 's|^ralph/||')
+    ARCHIVE_FOLDER="$ARCHIVE_DIR/$DATE-$FOLDER_NAME"
+    
+    echo "Archiving previous run: $LAST_BRANCH"
+    mkdir -p "$ARCHIVE_FOLDER"
+    [ -f "$PRD_FILE" ] && cp "$PRD_FILE" "$ARCHIVE_FOLDER/"
+    [ -f "$PROGRESS_FILE" ] && cp "$PROGRESS_FILE" "$ARCHIVE_FOLDER/"
+    echo "   Archived to: $ARCHIVE_FOLDER"
+    
+    echo "# Ralph Progress Log" > "$PROGRESS_FILE"
+    echo "Started: $(date)" >> "$PROGRESS_FILE"
+    echo "---" >> "$PROGRESS_FILE"
+  fi
+fi
+
+# Track current branch
+if [ -f "$PRD_FILE" ]; then
+  CURRENT_BRANCH=$(jq -r '.branchName // empty' "$PRD_FILE" 2>/dev/null || echo "")
+  if [ -n "$CURRENT_BRANCH" ]; then
+    echo "$CURRENT_BRANCH" > "$LAST_BRANCH_FILE"
+  fi
+fi
+
+# Initialize progress file if it doesn't exist
+if [ ! -f "$PROGRESS_FILE" ]; then
+  echo "# Ralph Progress Log" > "$PROGRESS_FILE"
+  echo "Started: $(date)" >> "$PROGRESS_FILE"
+  echo "---" >> "$PROGRESS_FILE"
+fi
+
+echo "Starting Ralph - Max iterations: $MAX_ITERATIONS"
+
+for i in $(seq 1 $MAX_ITERATIONS); do
+  echo ""
+  echo "═══════════════════════════════════════════════════════"
+  echo "  Ralph Iteration $i of $MAX_ITERATIONS"
+  echo "═══════════════════════════════════════════════════════"
+  
+  OUTPUT=$(droid exec --skip-permissions-unsafe -f "$PROMPT_FILE" --output-format text 2>&1 | tee /dev/stderr) || true
+  
+  if echo "$OUTPUT" | grep -q "<promise>COMPLETE</promise>"; then
+    echo ""
+    echo "Ralph completed all tasks!"
+    echo "Completed at iteration $i of $MAX_ITERATIONS"
+    exit 0
+  fi
+  
+  echo "Iteration $i complete. Continuing..."
+  sleep 2
+done
+
+echo ""
+echo "Ralph reached max iterations ($MAX_ITERATIONS) without completing all tasks."
+echo "Check $PROGRESS_FILE for status."
+exit 1

package/.plcode/skill/experimental/ralph/skill.md

@@ -0,0 +1,170 @@
+---
+name: ralph
+description: "Autonomous agent loop for completing features. Use when asked to 'use ralph', 'ralph this', or to autonomously implement a feature end-to-end. Creates prd.json with user stories, then executes them one by one until complete."
+category: workflow
+---
+
+# Ralph - Autonomous Feature Implementation
+
+Ralph is an autonomous loop that implements features by breaking them into small user stories and completing them one at a time. Each iteration is a fresh agent with clean context. Memory persists via git, `progress.txt`, and `prd.json`.
+
+## Quick Start
+
+```bash
+# Run ralph in current project (assumes prd.json exists)
+~/skills/ralph/scripts/ralph.sh [max_iterations]
+```
+
+## Workflow
+
+### Step 1: Understand the Feature
+
+Ask clarifying questions if needed:
+
+- What problem does this solve?
+- What are the key user actions?
+- What's out of scope?
+- How do we know it's done?
+
+### Step 2: Create prd.json
+
+Generate a `prd.json` file in the project root:
+
+```json
+{
+  "project": "[Project Name]",
+  "branchName": "ralph/[feature-name-kebab-case]",
+  "description": "[Feature description]",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "[Story title]",
+      "description": "As a [user], I want [feature] so that [benefit]",
+      "acceptanceCriteria": ["Criterion 1", "Criterion 2", "Typecheck passes"],
+      "priority": 1,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+```
+
+### Step 3: Run the Loop
+
+```bash
+~/skills/ralph/scripts/ralph.sh [max_iterations]
+```
+
+Default is 10 iterations.
+
+## Critical Rules for User Stories
+
+### Size: One Context Window
+
+Each story MUST be completable in ONE iteration. If you can't describe it in 2-3 sentences, it's too big.
+
+**Right-sized:**
+
+- Add a database column and migration
+- Add a UI component to an existing page
+- Update a server action with new logic
+- Add a filter dropdown to a list
+
+**Too big (split these):**
+
+- "Build the entire dashboard" → schema, queries, UI components, filters
+- "Add authentication" → schema, middleware, login UI, session handling
+
+### Order: Dependencies First
+
+1. Schema/database changes (migrations)
+2. Server actions / backend logic
+3. UI components that use the backend
+4. Dashboard/summary views
+
+### Acceptance Criteria: Verifiable
+
+**Good:**
+
+- "Add `status` column with default 'pending'"
+- "Filter dropdown has options: All, Active, Completed"
+- "Typecheck passes"
+
+**Bad:**
+
+- "Works correctly"
+- "Good UX"
+
+**Always include:**
+
+- `"Typecheck passes"` on every story
+- `"Verify in browser using dev-browser skill"` on UI stories
+
+## Example
+
+**User says:** "use ralph to add task priorities"
+
+**You create prd.json:**
+
+```json
+{
+  "project": "TaskApp",
+  "branchName": "ralph/task-priority",
+  "description": "Add priority levels (high/medium/low) to tasks",
+  "userStories": [
+    {
+      "id": "US-001",
+      "title": "Add priority field to database",
+      "description": "As a developer, I need to store task priority.",
+      "acceptanceCriteria": [
+        "Add priority column: 'high' | 'medium' | 'low' (default 'medium')",
+        "Migration runs successfully",
+        "Typecheck passes"
+      ],
+      "priority": 1,
+      "passes": false,
+      "notes": ""
+    },
+    {
+      "id": "US-002",
+      "title": "Display priority badge on task cards",
+      "description": "As a user, I want to see priority at a glance.",
+      "acceptanceCriteria": [
+        "Colored badge: red=high, yellow=medium, gray=low",
+        "Visible without hovering",
+        "Typecheck passes",
+        "Verify in browser using dev-browser skill"
+      ],
+      "priority": 2,
+      "passes": false,
+      "notes": ""
+    }
+  ]
+}
+```
+
+**Then say:**
+
+> prd.json created with 2 user stories. Run `~/skills/ralph/scripts/ralph.sh` to start autonomous execution.
+
+## How Ralph Executes
+
+Each iteration, a fresh agent:
+
+1. Reads `prd.json` and `progress.txt`
+2. Picks highest priority story where `passes: false`
+3. Implements it
+4. Runs quality checks (typecheck, lint, test)
+5. Commits if passing
+6. Updates `prd.json` to mark `passes: true`
+7. Appends learnings to `progress.txt`
+8. Exits
+
+Loop continues until all stories pass or max iterations hit.
+
+## Files Reference
+
+| File           | Purpose                                     |
+| -------------- | ------------------------------------------- |
+| `prd.json`     | User stories with pass/fail status          |
+| `progress.txt` | Append-only learnings for future iterations |

package/.plcode/skill/experimental/ralph-executor/skill.md

@@ -0,0 +1,130 @@
+# Ralph Executor - Story Implementation
+
+**Execute ONE user story from prd.json**
+
+This skill implements a single story from the PRD and updates progress. Load this skill multiple times to complete all stories.
+
+---
+
+## Instructions
+
+You are Ralph - an autonomous coding agent executing ONE story at a time.
+
+### Your Task (Execute in Order)
+
+1. **Read Context**
+   - Read `prd.json` in project root
+   - Read `progress.txt` (if exists, check "Codebase Patterns" section first)
+   - Note current git branch
+
+2. **Check Branch**
+   - Get required branch from `prd.json` → `branchName`
+   - If current branch ≠ required branch:
+     - Create branch from main: `git checkout -b [branchName]`
+     - Or checkout existing: `git checkout [branchName]`
+
+3. **Pick Next Story**
+   - Filter stories where `passes: false`
+   - Sort by `priority` (ascending)
+   - Pick the **FIRST** one (highest priority)
+   - If no stories with `passes: false` → Output "RALPH COMPLETE! 🎉" and STOP
+
+4. **Implement the Story**
+   - Read the story's `acceptanceCriteria` carefully
+   - Implement ONLY what's needed for THIS story
+   - Follow existing code patterns in the project
+   - Keep changes minimal and focused
+
+5. **Run Quality Checks**
+   - Run: `bunx tsc --noEmit`
+   - If typecheck fails → Fix errors and run again
+   - Do NOT proceed until typecheck passes
+
+6. **Update AGENTS.md (If Needed)**
+   - Check if you discovered reusable patterns
+   - If yes, update relevant AGENTS.md files with learnings
+   - Examples: API patterns, gotchas, dependencies
+
+7. **Commit Changes**
+   - Stage ALL changed files: `git add .`
+   - Commit with message: `feat: [Story ID] - [Story Title]`
+   - Example: `feat: US-001 - Add priority field to database`
+
+8. **Update prd.json**
+   - Set `passes: true` for the completed story
+   - Save the file
+
+9. **Update progress.txt**
+   - APPEND to progress.txt (never replace!)
+   - Format:
+
+   ```
+   ## [Date/Time] - [Story ID]
+   - Implemented: [brief description]
+   - Files changed:
+     - [file1]
+     - [file2]
+   - Learnings:
+     - [pattern discovered]
+     - [gotcha encountered]
+   ---
+   ```
+
+10. **Report Status**
+    - Count remaining stories with `passes: false`
+    - Output:
+      - If 0 remaining: "✅ RALPH COMPLETE! All [N] stories done! 🎉"
+      - If >0 remaining: "✅ Story [ID] complete. [X] stories remaining. Load ralph-executor again to continue."
+
+---
+
+## Quality Rules (NEVER VIOLATE)
+
+- ❌ NEVER commit broken code
+- ❌ NEVER skip typecheck
+- ❌ NEVER implement multiple stories at once
+- ❌ NEVER modify prd.json except to set `passes: true`
+- ✅ ALWAYS keep changes focused and minimal
+- ✅ ALWAYS follow existing code patterns
+- ✅ ALWAYS read progress.txt before starting
+
+---
+
+## Example Flow
+
+**Iteration 1:**
+
+```
+Read prd.json → 3 stories, US-001 passes=false
+Read progress.txt → empty (first run)
+Current branch: main
+Required branch: ralph/task-priority
+
+Creating branch: ralph/task-priority ✓
+
+Picked: US-001 - Add priority field to database
+
+Implementing:
+- Created migration: add_priority_column.sql
+- Added priority: 'high' | 'medium' | 'low' (default: 'medium')
+
+Running typecheck: bunx tsc --noEmit ✓
+
+Committing: feat: US-001 - Add priority field to database ✓
+
+Updating prd.json: US-001 passes=true ✓
+
+Appending to progress.txt ✓
+
+✅ Story US-001 complete. 2 stories remaining. Load ralph-executor again to continue.
+```
+
+---
+
+## Stop Condition
+
+When ALL stories have `passes: true`:
+
+- Output: "✅ RALPH COMPLETE! All [N] stories done! 🎉"
+- List final stats (commits, files changed, branch name)
+- Do NOT continue to next story

package/.plcode/skill/experimental/rsc-data-optimizer/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: rsc-data-optimizer
+description: >-
+  Optimize Next.js App Router data fetching by converting slow client-side
+  fetching to fast server-side fetching using React Server Components (RSC).
+  Use when: user reports slow initial page load with loading spinners; page
+  uses useEffect + useState for data fetching; StoreContext/useStore pattern
+  causes waterfall fetching; need to improve SEO (content not in initial
+  HTML); converting "use client" pages to Server Components.
+  Triggers: "slow loading", "optimize fetching", "SSR data",
+  "RSC optimization", "remove loading spinner", "server-side fetch",
+  "convert to server component", "data fetch lambat", "loading lama"
+category: backend
+---
+
+# RSC Data Fetching Optimizer
+
+Optimize slow client-side data fetching to instant server-side rendering.
+
+## Quick Diagnosis
+
+Search for these anti-patterns in the codebase:
+
+```bash
+# Find client-side fetching patterns
+rg -n "useEffect.*fetch|useState.*loading|useStore\(\)" --type tsx
+rg -n '"use client"' app/ --type tsx
+```
+
+**Red flags:**
+
+- `"use client"` + `useEffect` + `fetch()` = slow initial load
+- `useState(true)` for `isLoading` = user sees spinner
+- `useStore()` or `useContext` for initial page data = waterfall fetching
+
+## 3-Step Conversion Workflow
+
+### Step 1: Identify Data Requirements
+
+Determine what data the page needs on initial render:
+
+- Static/rarely-changing data → **Server Component** (SSR)
+- User-interactive data (filters, search) → **Client Component**
+
+### Step 2: Extract Interactive Sections
+
+Move sections with `useInView`, `useState`, `onClick` to separate Client Components:
+
+```tsx
+// components/data-section.tsx
+"use client"
+
+interface DataSectionProps {
+  data: Item[] // Receive data as props
+}
+
+export function DataSection({ data }: DataSectionProps) {
+  const [ref, inView] = useInView() // Client-side animation OK
+  return <div ref={ref}>...</div>
+}
+```
+
+### Step 3: Convert Page to Server Component
+
+```tsx
+// app/page.tsx - NO "use client"
+import { getData } from "@/lib/actions/data"
+import { DataSection } from "@/components/data-section"
+
+export default async function Page() {
+  const data = await getData() // Fetch on server
+  return <DataSection data={data} />
+}
+```
+
+## Type Adapter Pattern
+
+When DB types differ from frontend types:
+
+```tsx
+import type { Item as DBItem } from "@/lib/database.types"
+import type { Item } from "@/lib/types"
+
+function adaptDBToFrontend(db: DBItem): Item {
+  return {
+    id: db.id,
+    name: db.name,
+    description: db.description ?? "",
+    createdAt: new Date(db.created_at),
+  }
+}
+
+export default async function Page() {
+  const dbItems = await getItems()
+  const items = dbItems.map(adaptDBToFrontend)
+  return <ItemList items={items} />
+}
+```
+
+## When to Keep Client-Side
+
+Keep `"use client"` when:
+
+- Real-time subscriptions (Supabase realtime)
+- User-triggered fetching (search, filters, pagination)
+- Data depends on client state (auth token, localStorage)
+- Infinite scroll / load more patterns
+
+## Advanced Patterns
+
+See [references/patterns.md](references/patterns.md) for:
+
+- Parallel data fetching
+- Streaming with Suspense
+- Error boundaries
+- Caching strategies
+- Hybrid SSR + client patterns