takomi 2.0.4 → 2.0.5

package/assets/.agent/skills/takomi/workflows/remotion-build.md

@@ -0,0 +1,323 @@
+---
+description: The Remotion Builder - Generate a detailed video spec, get approval, then build. Two-phase workflow for programmatic video creation.
+---
+
+# Remotion Builder Workflow
+
+> **Purpose**: Create programmatic videos using Remotion. This workflow forces mandatory rule reading, detailed planning, and an asset audit before any code is written.
+
+---
+
+## ⚠️ CRITICAL: MANDATORY RULE READING
+
+**YOU ARE NOT SMART ENOUGH TO GUESS REMOTION PATTERNS.**
+
+Before writing ANY Remotion code, you MUST read the relevant rule files. Do NOT proceed without reading these. Do NOT assume you know what you're doing.
+
+### Step 0.1: Read the Main Skill
+// turbo
+```bash
+cat ".agent/skills/remotion/SKILL.md"
+```
+
+### Step 0.2: Read REQUIRED Rule Files
+
+Based on what the video needs, you MUST read the corresponding rule files. This is NOT optional.
+
+**For ANY animation work (ALWAYS READ THESE):**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/animations.md"
+cat ".agent/skills/remotion/rules/timing.md"
+cat ".agent/skills/remotion/rules/sequencing.md"
+```
+
+**If using scene transitions:**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/transitions.md"
+```
+
+**If using text animations (typewriter, highlights, etc):**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/text-animations.md"
+cat ".agent/skills/remotion/rules/fonts.md"
+```
+
+**If using images, videos, or audio:**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/assets.md"
+cat ".agent/skills/remotion/rules/images.md"
+cat ".agent/skills/remotion/rules/videos.md"
+cat ".agent/skills/remotion/rules/audio.md"
+```
+
+**If using 3D elements:**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/3d.md"
+```
+
+**If using captions/subtitles:**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/display-captions.md"
+cat ".agent/skills/remotion/rules/transcribe-captions.md"
+```
+
+**If using charts/data visualization:**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/charts.md"
+```
+
+**If using Lottie animations:**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/lottie.md"
+```
+
+**If using GIFs:**
+// turbo
+```bash
+cat ".agent/skills/remotion/rules/gifs.md"
+```
+
+> ⛔ **DO NOT PROCEED TO PHASE 1 UNTIL YOU HAVE READ THE RELEVANT RULES.**
+
+---
+
+## PHASE 1: Video Specification
+
+Generate a **Video Spec Document** in `docs/remotion/[video_name]_spec.md`.
+
+### Step 1.1: Generate the Video Spec
+
+Create the spec with this structure:
+
+```markdown
+# 🎬 Video Spec: [Video Name]
+
+## Overview
+| Property | Value |
+|----------|-------|
+| **Type** | [Main/Short/B-Roll/Intro/Outro] |
+| **Duration** | [X seconds] (Y frames @ Zfps) |
+| **Resolution** | [WxH] |
+| **FPS** | 30 |
+| **Composition ID** | `[CompositionId]` |
+
+## Rules I Read Before Writing This Spec
+- [x] animations.md
+- [x] timing.md
+- [x] sequencing.md
+- [ ] transitions.md (if applicable)
+- [ ] text-animations.md (if applicable)
+- [ ] ... (list all rules you read)
+
+## Creative Direction
+[1-2 sentences describing the visual concept]
+
+### Color Palette
+| Color | Hex | Usage |
+|-------|-----|-------|
+| Primary | #XXXXXX | [usage] |
+
+### Typography
+| Font | Weight | Size | Usage |
+|------|--------|------|-------|
+| [Font Name] | [weight] | [px] | [usage] |
+
+---
+
+## Scene Breakdown
+
+### Scene 1: [Name] (0s - Xs)
+**Duration**: X seconds (Y frames)
+
+#### Visual Elements
+- [ ] Element 1: [Description]
+
+#### Animations (from timing.md / animations.md)
+| Element | Type | Start | End | Easing |
+|---------|------|-------|-----|--------|
+| [Element] | [fadeIn/spring/interpolate] | X | Y | [spring({damping:200}) / Easing.out(Easing.exp)] |
+
+#### Code Approach
+\```tsx
+// Frame-by-frame animation using useCurrentFrame() - NEVER CSS transitions
+const frame = useCurrentFrame();
+const opacity = interpolate(frame, [0, 30], [0, 1], { extrapolateRight: 'clamp' });
+\```
+
+---
+
+## Technical Requirements
+
+### Props Schema (Zod)
+\```ts
+import { z } from "zod";
+export const [Id]Schema = z.object({ ... });
+\```
+
+### Critical Rules (MEMORIZE THESE)
+> ⛔ FORBIDDEN: CSS transitions, CSS animations, Tailwind animation classes
+> ✅ REQUIRED: All animations via useCurrentFrame() + interpolate()/spring()
+> ✅ REQUIRED: premountFor={1 * fps} on all <Sequence> components
+> ✅ REQUIRED: staticFile() for public folder assets
+> ✅ REQUIRED: Clamp extrapolation to prevent values going beyond range
+```
+
+### Step 1.2: Request Approval
+
+Use `notify_user` with `BlockedOnUser: true` to request spec approval.
+
+---
+
+## PHASE 2: Asset Audit
+
+After spec approval, generate an **Asset Manifest**.
+
+### Step 2.1: Generate Asset Manifest
+
+Create `docs/remotion/[video_name]_assets.md`:
+
+```markdown
+# 🎨 Asset Manifest: [Video Name]
+
+## 1. Code-Generatable Components ✅
+*These can be built entirely with React/SVG code*
+
+| Component | Description | Complexity |
+|-----------|-------------|------------|
+| `ComponentName.tsx` | Description | Low/Medium/High |
+
+---
+
+## 2. Image Prompts for User 🖼️
+*I CANNOT generate these myself. I am providing prompts for YOU to generate.*
+
+> **Instructions for User:**
+> Use these prompts with your preferred image generation tool (Midjourney, DALL-E, generate_image tool, etc.)
+> After generating, save the images to `public/assets/[video_name]/`
+
+| Asset | Prompt | Size | Save As |
+|-------|--------|------|---------|
+| Background | "Abstract dark gradient with subtle grid pattern, cyberpunk aesthetic, 16:9 aspect ratio" | 1920x1080 | `bg_hero.png` |
+| Logo Icon | "Minimal geometric logo, neon cyan glow, dark background, icon style, square" | 512x512 | `logo.png` |
+
+**Total prompts**: X images for you to generate
+
+---
+
+## 3. External Assets Needed 📦
+*These require you to provide - stock footage, your logos, audio files*
+
+| Asset | Type | Description | Action |
+|-------|------|-------------|--------|
+| Your Logo | SVG/PNG | Your brand logo | You provide |
+| Background Music | MP3 | Ambient tech music | Source from [Epidemic Sound](https://epidemicsound.com) |
+| Screen Recording | MP4 | Demo of your app | You record |
+
+---
+
+## 4. Your Choices ⚡
+
+Tell me for each:
+
+| Item | Options |
+|------|---------|
+| UI Mockups | [ ] I'll build code components / [ ] I'll provide screenshots |
+| Background | [ ] Generate with prompt above / [ ] I'll provide my own |
+| Logo | [ ] Generate with prompt above / [ ] I'll provide my own |
+
+---
+
+## After You Decide
+
+**If you want me to proceed with code components:**
+Reply: "Build the components"
+
+**If you want to generate images first:**
+Run the prompts yourself, then reply: "Assets ready in public/assets/[folder]"
+
+**If you're providing your own assets:**
+Reply: "I'm providing: [list files] - they're in public/assets/[folder]"
+```
+
+### Step 2.2: Wait for User
+
+Use `notify_user` with `BlockedOnUser: true`. Do NOT proceed until user responds with their choices.
+
+---
+
+## PHASE 3: Component Building
+
+Only after user confirms assets OR chooses code-gen:
+
+### Step 3.1: Create Components
+
+For each component in the manifest:
+1. Re-read the relevant rule files (animations.md, timing.md, etc.)
+2. Create the component following patterns from the rules EXACTLY
+3. Use `useCurrentFrame()` for ALL animations
+4. NEVER use CSS transitions or Tailwind animation classes
+
+### Step 3.2: Create Main Composition
+
+1. Import all components
+2. Set up `<Sequence>` structure per the spec
+3. Add `premountFor={1 * fps}` to every Sequence
+4. Register in `Root.tsx`
+
+---
+
+## PHASE 4: Verification
+
+### Step 4.1: Start Studio
+// turbo
+```bash
+pnpm start
+```
+
+### Step 4.2: Manual Verification
+1. Open composition in browser
+2. Scrub through timeline
+3. Verify all animations trigger at correct frames
+4. Check console for errors
+
+---
+
+## Quick Reference (From Rules)
+
+### Interpolation (from timing.md)
+```tsx
+const opacity = interpolate(frame, [0, 30], [0, 1], {
+  extrapolateRight: 'clamp',
+  extrapolateLeft: 'clamp',
+});
+```
+
+### Spring (from timing.md)
+```tsx
+const scale = spring({
+  frame,
+  fps,
+  config: { damping: 200 }, // Smooth, no bounce
+});
+```
+
+### Sequence (from sequencing.md)
+```tsx
+<Sequence from={1 * fps} durationInFrames={2 * fps} premountFor={1 * fps}>
+  <MyComponent />
+</Sequence>
+```
+
+### Assets (from assets.md)
+```tsx
+import { Img, staticFile } from 'remotion';
+<Img src={staticFile('image.png')} />
+```

package/assets/.agent/skills/takomi/workflows/reverse_genesis.md

@@ -0,0 +1,132 @@
+---
+description: Onboard an AI to an existing codebase by generating an "Autopsy Report".
+---
+# Workflow: Reverse Genesis (Codebase Onboarding)
+
+**System Instruction:**
+This workflow is the OPPOSITE of `/init_vibecode_genesis`.
+Instead of planning a NEW project, you are **onboarding to an EXISTING codebase**.
+
+Your job is to generate a **Project Autopsy Report** — a comprehensive analysis of the current state of the code.
+
+---
+
+## Steps
+
+### 1. Reconnaissance (Auto-Scan)
+
+**A. Project Overview:**
+```bash
+cat README.md 2>/dev/null || echo "No README found"
+cat docs/Project_Requirements.md 2>/dev/null || echo "No PRD found"
+```
+
+**B. Tech Stack Detection:**
+```bash
+# Node/JS
+cat package.json 2>/dev/null | head -50
+# Python
+cat requirements.txt 2>/dev/null || cat pyproject.toml 2>/dev/null
+# Rust
+cat Cargo.toml 2>/dev/null
+```
+
+**C. Architecture Scan:**
+```bash
+# List top-level structure
+ls -la
+# List source structure
+find src -type f -name "*.ts" -o -name "*.py" -o -name "*.rs" 2>/dev/null | head -30
+```
+
+**D. Database Schema (if applicable):**
+```bash
+cat prisma/schema.prisma 2>/dev/null | head -100
+```
+
+**E. Recent Activity:**
+```bash
+git log --oneline -10
+```
+
+### 2. Generate Autopsy Report
+Create `docs/autopsy_report.md` with the following:
+
+```markdown
+# Project Autopsy Report
+
+**Generated:** [Current Date/Time]
+**Purpose:** Onboard a new AI Orchestrator to this existing codebase.
+
+---
+
+## 1. Project Elevator Pitch
+[One-sentence purpose of this application]
+
+## 2. Core Technology Stack
+| Category | Technology |
+| :--- | :--- |
+| Language | TypeScript / Python / etc. |
+| Framework | Next.js / FastAPI / etc. |
+| Database | PostgreSQL / SQLite / etc. |
+| Key Libraries | [List major dependencies] |
+
+## 3. Inferred Architecture
+[Describe the architectural pattern observed]
+- e.g., "Next.js App Router with Feature-Sliced Design"
+- e.g., "Modular Python with central event bus"
+
+## 4. Key Modules & Responsibilities
+| File/Module | Responsibility |
+| :--- | :--- |
+| `src/app/` | Next.js pages and routes |
+| `src/features/` | Domain-specific logic |
+| `src/lib/` | Shared utilities |
+
+## 5. Inferred Coding Conventions
+- **Naming:** snake_case / PascalCase / camelCase
+- **Components:** Server Components by default
+- **Validation:** Zod for all inputs
+- **Styling:** Tailwind CSS utility-first
+
+## 6. Entry Points
+- Main: `src/app/page.tsx` or `main.py`
+- API: `src/app/api/`
+
+## 7. Current State
+**Recent Commits:**
+[List from git log]
+
+**Open Issues:**
+[List from gh issue list]
+
+---
+
+## MISSION BRIEFING (For Orchestrator)
+
+You have now assimilated this codebase.
+
+**Your Directive:**
+1. Acknowledge you understand the existing architecture.
+2. Adopt the project's coding conventions.
+3. Ask the user: "What would you like to build or fix?"
+```
+
+### 3. Full File Embedding (Optional)
+If the project is complex, embed key files directly:
+- `src/lib/utils.ts`
+- Main config files
+- Core business logic
+
+### 4. Confirmation
+Tell the user:
+"🔬 **Autopsy Report Generated.**
+Saved to: `docs/autopsy_report.md`
+
+This report contains:
+- Tech stack analysis
+- Architecture breakdown
+- Coding conventions
+- Current state
+
+To onboard a new AI, paste this report into the new session."

package/assets/.agent/skills/takomi/workflows/review_code.md

@@ -0,0 +1,133 @@
+---
+description: Run the J-Star Code Reviewer loop to analyze and fix code quality issues.
+---
+
+# J-Star Code Review Workflow
+
+This workflow executes the J-Star Reviewer on staged changes, allowing the agent to iteratively fix issues.
+
+## 1. Build the Brain (Required once)
+If you haven't indexed the project yet, or if major files have changed, run:
+// turbo
+```bash
+jstar init
+```
+
+## 2. Stage Current Changes
+Ensure all recent changes are staged so the reviewer can see them.
+// turbo
+```bash
+git add .
+```
+
+## 3. Run Reviewer
+Execute the review pipeline.
+
+### Standard Review (Staged Changes)
+```bash
+jstar review
+```
+*Use this when changes are staged but not yet committed.*
+
+### Retroactive Review (Oops Mode)
+If you already committed changes but forgot to review:
+```bash
+jstar review --last
+```
+*Equivalent to checking the last commit `HEAD~1..HEAD`.*
+
+### Branch/PR Review
+If working on a feature branch, check against main:
+```bash
+jstar review --pr
+```
+*Equivalent to `git diff main...HEAD`. Use this for full feature verification.*
+
+## 4. Analyze and Fix
+**Agent Instructions:**
+1.  **Read the Output**: Check `.jstar/last-review.md` or the console summary.
+2.  **Prioritize**: Focus *only* on **P0_CRITICAL** and **P1_HIGH** issues first.
+3.  **Looping Strategy**:
+    - **IF** P0/P1 issues are found:
+        - Apply fixes to the code.
+        - Stage changes: `git add .`
+        - (Optional) Re-index if you added new files: `jstar init`
+        - Restart this workflow (Stage -> Review).
+    - **IF** only P2_MEDIUM issues remain:
+        - You may fix them if they are quick/obvious.
+        - Otherwise, consider the code "Good Enough" and stop.
+    - **MAX LOOPS**: 3. Do not run this cycle more than 3 times. If issues persist, stop and ask the user.
+
+## 5. Handling False Positives (Debate Mode)
+
+If the reviewer flags correct code as an issue (e.g., security false positives), use **Headless Chat** to resolve it.
+
+**Protocol:**
+1. **Start Session:**
+   Use the `run_command` tool to start the background process:
+   ```bash
+   jstar chat --headless
+   ```
+   *Note: Capture the `CommandId` returned by this tool.*
+
+2. **List Issues (Get IDs):**
+   Use `send_command_input` with the `CommandId`:
+   ```json
+   {"action": "list"}
+   ```
+   *Wait for output. Identify the numeric `id` of the issue you want to challenge.*
+
+3. **Debate:**
+   Use `send_command_input` to explain why it's a false positive:
+   ```json
+   {"action": "debate", "issueId": 0, "argument": "This is correct because..."}
+   ```
+   *Use the integer `id` from step 2.*
+
+4. **Verify Result:**
+   Check the output for `"status": "resolved"` and `"verdict": "LGTM"`.
+
+5. **Exit:**
+   Terminate the session cleanly:
+   ```json
+   {"action": "exit"}
+   ```
+
+---
+
+## AI Agent Mode (Headless)
+
+For programmatic interaction without TUI navigation, use headless mode.
+
+### JSON Review (One-Shot)
+Get findings as JSON for parsing:
+// turbo
+```bash
+jstar review --json > .jstar/report.json
+```
+
+### Headless Chat (Interactive Protocol)
+For debating specific issues via stdin/stdout:
+```bash
+echo '{"action": "list"}' | jstar chat --headless
+```
+
+**Commands:**
+| Action | Parameters | Description |
+|--------|------------|-------------|
+| `list` | — | List all current issues |
+| `debate` | `issueId`, `argument` | Challenge an issue |
+| `ignore` | `issueId` | Mark issue as ignored |
+| `exit` | — | End session, get final report |
+
+See [Headless Mode Docs](../docs/features/headless-mode.md) for full protocol.
+
+### AI Fix Cycle
+```
+1. jstar review --json  →  Parse findings
+2. Apply code fixes
+3. git add .            →  Stage changes
+4. jstar init           →  Update brain (if new files added)
+5. jstar review --json  →  Verify fixes
+6. Repeat until P0/P1 = 0
+```

package/assets/.agent/skills/takomi/workflows/spawn-jstar-code-review.md

@@ -0,0 +1,121 @@
+---
+description: Spawn J Star Code Review bot into the current repository
+---
+
+# /spawn-jstar - Add J Star Reviewer v2 to Any Project
+
+Works with **any programming language** — TypeScript, Python, Rust, Go, etc.
+
+## Prerequisites
+- Node.js 18+ installed on your machine
+
+## Steps
+
+### 1. Install the CLI Globally (One Time) use pnpm by default else revert to npm
+// turbo
+```bash
+pnpm install -g jstar-reviewer
+```
+
+### 2. Run your First Command
+// turbo
+```bash
+jstar setup
+```
+*(Or simply run `jstar review` if you already have your keys ready)*
+
+This **auto-creates** (or updates):
+- `.jstar/` directory
+- `.env.example` with required variables
+- `.gitignore` (appends `.jstar/` and `.env.local`)
+
+
+### 3. Configure Environment Variables
+```bash
+cp .env.example .env.local
+```
+
+Edit `.env.local` and add your API keys:
+```env
+GEMINI_API_KEY=your_gemini_api_key_here
+GROQ_API_KEY=your_groq_api_key_here
+```
+
+**Where to get keys:**
+- Google API Key: [Google AI Studio](https://aistudio.google.com/apikey)
+- Groq API Key: [console.groq.com](https://console.groq.com)
+
+### 4. Index Your Codebase (Build the Brain)
+```bash
+jstar init
+```
+
+This scans your codebase and creates embeddings for context-aware reviews.
+
+### 5. (Optional) Create Rules File
+Create `.jstar/rules.md` with your project-specific coding guidelines:
+
+```markdown
+# Project Coding Rules
+
+## General
+- Follow PEP 8 (Python) / Google Style Guide
+- Add docstrings to all public functions
+
+
+
+## Security  
+- Never log sensitive data
+- Validate all user inputs
+```
+
+### 6. Understanding Review Modes
+Before running a review, understand the available modes:
+
+| Mode | Command | Best For |
+| :--- | :--- | :--- |
+| **Standard** | `jstar review` | checking staged changes *before* committing. |
+| **Retroactive** | `jstar review --last` | checking the *last commit* (if you forgot to review). |
+| **Pull Request** | `jstar review --pr` | checking an entire feature branch against `main`. |
+
+### 7. Run Your First Review
+
+**Agent Instruction:** Ask the user: *"Would you like to run the review yourself, or should I run a headless check for you?"*
+
+#### Option A: User Runs It (Recommended)
+The user runs the interactive TUI command in their terminal:
+```bash
+jstar review
+```
+
+#### Option B: Agent Runs It (Headless)
+If the user asks YOU to do it, use the headless flag to avoid hanging:
+// turbo
+```bash
+jstar review --headless
+```
+*(This outputs JSON-formatted results that you can parse)*
+
+The dashboard will be saved to `.jstar/last-review.md`.
+
+## Done! 🎉
+
+**CLI Commands:**
+| Command | Description |
+|---------|-------------|
+| `jstar setup` | Create config files in current project |
+| `jstar init` | Index codebase (after major changes) |
+| `jstar review` | Review staged changes (Default) |
+| `jstar review --last` | Review last commit (Retroactive) |
+| `jstar review --pr` | Review branch against main (PR Mode) |
+
+**Output:**
+- Console: Quick summary with severity counts
+- `.jstar/last-review.md`: Full dashboard with fix prompts
+
+## Alternative: Without Global Install
+
+If you don't want to install globally:
+```bash
+npx jstar-reviewer review
+```