@hanzlaa/rcode 2.1.0

package/rihal/workflows/review-edge-case-hunter.md

@@ -0,0 +1,214 @@
+# Workflow: rihal:review-edge-case-hunter
+
+<purpose>
+Systematically enumerate edge cases by category (input, state, concurrency, network) with severity (critical/high/medium/low). Callable during code-review.md workflow. Output feeds into story AC or subtasks. Focuses on "what breaks?" rather than security.
+</purpose>
+
+
+## Step 0 — Usage check
+
+If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
+
+```
+/rihal:review-edge-case-hunter <argument-here>
+```
+
+**Examples:**
+```
+/rihal:review-edge-case-hunter example 1
+/rihal:review-edge-case-hunter example 2
+```
+
+STOP — do not proceed.
+
+<available_agent_types>
+- `rihal-edge-case-hunter` — edge case enumeration agent
+</available_agent_types>
+
+## Step 0 — Initialize
+
+```bash
+INIT=$(node .rihal/bin/rihal-tools.cjs init review-edge-case-hunter "$ARGUMENTS")
+```
+
+Parse:
+- `flags.phase` — specific phase to analyze (optional)
+- `flags.component` — specific component (optional)
+- `output_path` — `.rihal/EDGE-CASES-{phase}.md` or `.rihal/EDGE-CASES.md`
+- `targets` — files/components to audit
+
+## Step 1 — Identify Review Targets
+
+Same as review-adversarial Step 1:
+
+Collect files by phase or component, extract:
+- Function/method signatures
+- Input parameters and types
+- State mutations
+- External API calls
+- Error handling
+
+## Step 2 — Spawn Edge Case Hunter
+
+Spawn `rihal-edge-case-hunter` subagent:
+
+```
+Task tool call:
+  subagent_type: "rihal-edge-case-hunter"
+  description: "Enumerate edge cases"
+  prompt: |
+    Enumerate all edge cases that could cause failures or unexpected behavior.
+    Focus on: What inputs break? What state combinations are invalid? What network scenarios fail?
+    
+    **Files/functions to analyze:**
+    {target_files_with_signatures}
+    
+    **Enumerate by category:**
+    
+    1. INPUT EDGE CASES
+       - Empty inputs (null, undefined, empty string, empty array)
+       - Boundary values (0, -1, MAX_INT, MAX_FLOAT)
+       - Invalid types (string instead of number, object instead of array)
+       - Malformed data (invalid JSON, truncated, oversized)
+       - Special characters (unicode, newlines, control chars, emoji)
+       - Whitespace variations (leading/trailing spaces, tabs, mixed)
+    
+    2. STATE EDGE CASES
+       - Uninitialized/missing state
+       - State mutations during async operations
+       - Re-entrance (function called again while executing)
+       - State transitions not covered (skipped steps, out-of-order)
+       - Stale cached state
+       - Conflicting state values
+    
+    3. CONCURRENCY EDGE CASES
+       - Two requests for same resource simultaneously
+       - Writes during reads
+       - Partial updates (write interrupted)
+       - Lock contention or deadlock
+       - Race conditions between check and use
+       - Order-dependent operations executed out of order
+    
+    4. NETWORK EDGE CASES
+       - Timeouts (slow/hanging requests)
+       - Connection drops (mid-response)
+       - Retries (request sent twice, duplicate processing)
+       - Invalid responses (malformed JSON, wrong status code)
+       - Cascading failures (API A calls B, B fails)
+       - Rate limiting (429 Too Many Requests)
+    
+    For each edge case:
+    - Category (input, state, concurrency, network)
+    - Severity (critical, high, medium, low)
+    - Scenario (specific input/state combination)
+    - Expected behavior (what should happen)
+    - Actual behavior (what might go wrong)
+    - Test case (how to reproduce)
+    - Acceptance criteria for handling
+    
+    Output: EDGE-CASES.md with severity-ordered list
+```
+
+## Step 3 — Categorize by Severity
+
+Critical: Causes data loss, security breach, complete feature failure
+High: Causes incorrect output, feature partially broken, user-facing error
+Medium: Degrades performance, confuses user, edge case not handled gracefully
+Low: Minor inconsistency, cosmetic issue, optimization opportunity
+
+Organize output:
+
+```markdown
+# Edge Cases: {phase_name}
+
+## Critical ({count})
+- {edge_case_1}
+- {edge_case_2}
+
+## High ({count})
+- {edge_case_1}
+- {edge_case_2}
+
+## Medium ({count})
+- {edge_case_1}
+
+## Low ({count})
+- {edge_case_1}
+```
+
+## Step 4 — File as AC or Tasks
+
+For each critical/high edge case, add to story AC:
+
+Update `.rihal/story-current.md` acceptance criteria:
+
+```markdown
+## Edge Case Handling
+
+**Critical:**
+- [ ] {edge_case_1}: {acceptance_criteria}
+
+**High:**
+- [ ] {edge_case_2}: {acceptance_criteria}
+```
+
+Or file as subtasks:
+
+```bash
+node .rihal/bin/rihal-tools.cjs state add-task \
+  --title "Handle edge case: {scenario}" \
+  --category edge-case \
+  --severity {critical|high}
+```
+
+Print:
+```
+🔍 Edge Case Analysis Complete
+
+By severity:
+  • Critical: {count}
+  • High: {count}
+  • Medium: {count}
+  • Low: {count}
+
+Analysis: {output_path}
+
+Critical/high cases filed as AC or tasks.
+```
+
+## Integration: code-review.md
+
+In code-review.md workflow, after completing main review, optionally offer:
+
+```bash
+AskUserQuestion([
+  {
+    header: "Edge Cases",
+    question: "Run edge case analysis on this code?",
+    multiSelect: false,
+    options: [
+      { label: "Yes, find edge cases", description: "Comprehensive edge case hunt" },
+      { label: "Skip for now", description: "Continue review" }
+    ]
+  }
+])
+```
+
+If "Yes, find edge cases":
+```
+/rihal:review-edge-case-hunter --phase {current_phase}
+```
+
+## Success Criteria
+
+- EDGE-CASES.md created with all 4 categories
+- Minimum 3 edge cases per category (if applicable)
+- Severity-ordered list
+- Test case included for each critical/high
+- Critical/high filed as AC or tasks
+
+## On Error
+
+- If subagent fails: provide template edge-case structure
+- If no edge cases found: report "No new edge cases identified" (acceptable)
+- If too many cases: prioritize by severity, file medium/low in backlog

package/rihal/workflows/review.md

@@ -0,0 +1,281 @@
+<purpose>
+Cross-AI peer review — invoke external AI CLIs to independently review phase plans.
+Each CLI gets the same prompt (PROJECT.md context, phase plans, requirements) and
+produces structured feedback. Results are combined into REVIEWS.md for the planner
+to incorporate via --reviews flag.
+
+This implements adversarial review: different AI models catch different blind spots.
+A plan that survives review from 2-3 independent AI systems is more robust.
+</purpose>
+
+<process>
+
+<step name="detect_clis">
+Check which AI CLIs are available on the system:
+
+```bash
+# Check each CLI
+command -v gemini >/dev/null 2>&1 && echo "gemini:available" || echo "gemini:missing"
+command -v claude >/dev/null 2>&1 && echo "claude:available" || echo "claude:missing"
+command -v codex >/dev/null 2>&1 && echo "codex:available" || echo "codex:missing"
+command -v coderabbit >/dev/null 2>&1 && echo "coderabbit:available" || echo "coderabbit:missing"
+command -v opencode >/dev/null 2>&1 && echo "opencode:available" || echo "opencode:missing"
+```
+
+Parse flags from `$ARGUMENTS`:
+- `--gemini` → include Gemini
+- `--claude` → include Claude
+- `--codex` → include Codex
+- `--coderabbit` → include CodeRabbit
+- `--opencode` → include OpenCode
+- `--all` → include all available
+- No flags → include all available
+
+If no CLIs are available:
+```
+No external AI CLIs found. Install at least one:
+- gemini: https://github.com/google-gemini/gemini-cli
+- codex: https://github.com/openai/codex
+- claude: https://github.com/anthropics/claude-code
+- opencode: https://opencode.ai (leverages GitHub Copilot subscription models)
+
+Then run /rihal:review again.
+```
+Exit.
+
+Determine which CLI to skip based on the current runtime environment:
+
+```bash
+# Environment-based runtime detection (priority order)
+if [ "$ANTIGRAVITY_AGENT" = "1" ]; then
+  # Antigravity is a separate client — all CLIs are external, skip none
+  SELF_CLI="none"
+elif [ -n "$CLAUDE_CODE_ENTRYPOINT" ]; then
+  # Running inside Claude Code CLI — skip claude for independence
+  SELF_CLI="claude"
+else
+  # Other environments (Gemini CLI, Codex CLI, etc.)
+  # Fall back to AI self-identification to decide which CLI to skip
+  SELF_CLI="auto"
+fi
+```
+
+Rules:
+- If `SELF_CLI="none"` → invoke ALL available CLIs (no skip)
+- If `SELF_CLI="claude"` → skip claude, use gemini/codex
+- If `SELF_CLI="auto"` → the executing AI identifies itself and skips its own CLI
+- At least one DIFFERENT CLI must be available for the review to proceed.
+</step>
+
+<step name="gather_context">
+Collect phase artifacts for the review prompt:
+
+```bash
+INIT=$(node ".rihal/bin/rihal-tools.cjs" init phase-op "${PHASE_ARG}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Read from init: `phase_dir`, `phase_number`, `padded_phase`.
+
+Then read:
+1. `.planning/PROJECT.md` (first 80 lines — project context)
+2. Phase section from `.planning/ROADMAP.md`
+3. All `*-SPRINT.md` files in the phase directory
+4. `*-CONTEXT.md` if present (user decisions)
+5. `*-RESEARCH.md` if present (domain research)
+6. `.planning/REQUIREMENTS.md` (requirements this phase addresses)
+</step>
+
+<step name="build_prompt">
+Build a structured review prompt:
+
+```markdown
+# Cross-AI Plan Review Request
+
+You are reviewing implementation plans for a software project phase.
+Provide structured feedback on plan quality, completeness, and risks.
+
+## Project Context
+{first 80 lines of PROJECT.md}
+
+## Phase {N}: {phase name}
+### Roadmap Section
+{roadmap phase section}
+
+### Requirements Addressed
+{requirements for this phase}
+
+### User Decisions (CONTEXT.md)
+{context if present}
+
+### Research Findings
+{research if present}
+
+### Plans to Review
+{all SPRINT.md contents}
+
+## Review Instructions
+
+Analyze each plan and provide:
+
+1. **Summary** — One-paragraph assessment
+2. **Strengths** — What's well-designed (bullet points)
+3. **Concerns** — Potential issues, gaps, risks (bullet points with severity: HIGH/MEDIUM/LOW)
+4. **Suggestions** — Specific improvements (bullet points)
+5. **Risk Assessment** — Overall risk level (LOW/MEDIUM/HIGH) with justification
+
+Focus on:
+- Missing edge cases or error handling
+- Dependency ordering issues
+- Scope creep or over-engineering
+- Security considerations
+- Performance implications
+- Whether the plans actually achieve the phase goals
+
+Output your review in markdown format.
+```
+
+Write to a temp file: `/tmp/rihal:review-prompt-{phase}.md`
+</step>
+
+<step name="invoke_reviewers">
+For each selected CLI, invoke in sequence (not parallel — avoid rate limits):
+
+**Gemini:**
+```bash
+gemini -p "$(cat /tmp/rihal:review-prompt-{phase}.md)" 2>/dev/null > /tmp/rihal:review-gemini-{phase}.md
+```
+
+**Claude (separate session):**
+```bash
+claude -p "$(cat /tmp/rihal:review-prompt-{phase}.md)" 2>/dev/null > /tmp/rihal:review-claude-{phase}.md
+```
+
+**Codex:**
+```bash
+codex exec --skip-git-repo-check "$(cat /tmp/rihal:review-prompt-{phase}.md)" 2>/dev/null > /tmp/rihal:review-codex-{phase}.md
+```
+
+**CodeRabbit:**
+
+Note: CodeRabbit reviews the current git diff/working tree — it does not accept a prompt. It may take up to 5 minutes. Use `timeout: 360000` on the Bash tool call.
+
+```bash
+coderabbit review --prompt-only 2>/dev/null > /tmp/rihal:review-coderabbit-{phase}.md
+```
+
+**OpenCode (via GitHub Copilot):**
+```bash
+cat /tmp/rihal:review-prompt-{phase}.md | opencode run - 2>/dev/null > /tmp/rihal:review-opencode-{phase}.md
+if [ ! -s /tmp/rihal:review-opencode-{phase}.md ]; then
+  echo "OpenCode review failed or returned empty output." > /tmp/rihal:review-opencode-{phase}.md
+fi
+```
+
+If a CLI fails, log the error and continue with remaining CLIs.
+
+Display progress:
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ Rihal ► CROSS-AI REVIEW — Phase {N}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+◆ Reviewing with {CLI}... done ✓
+◆ Reviewing with {CLI}... done ✓
+```
+</step>
+
+<step name="write_reviews">
+Combine all review responses into `{phase_dir}/{padded_phase}-REVIEWS.md`:
+
+```markdown
+---
+phase: {N}
+reviewers: [gemini, claude, codex, coderabbit, opencode]
+reviewed_at: {ISO timestamp}
+plans_reviewed: [{list of SPRINT.md files}]
+---
+
+# Cross-AI Plan Review — Phase {N}
+
+## Gemini Review
+
+{gemini review content}
+
+---
+
+## Claude Review
+
+{claude review content}
+
+---
+
+## Codex Review
+
+{codex review content}
+
+---
+
+## CodeRabbit Review
+
+{coderabbit review content}
+
+---
+
+## OpenCode Review
+
+{opencode review content}
+
+---
+
+## Consensus Summary
+
+{synthesize common concerns across all reviewers}
+
+### Agreed Strengths
+{strengths mentioned by 2+ reviewers}
+
+### Agreed Concerns
+{concerns raised by 2+ reviewers — highest priority}
+
+### Divergent Views
+{where reviewers disagreed — worth investigating}
+```
+
+Commit:
+```bash
+node ".rihal/bin/rihal-tools.cjs" commit "docs: cross-AI review for phase {N}" --files {phase_dir}/{padded_phase}-REVIEWS.md
+```
+</step>
+
+<step name="present_results">
+Display summary:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ Rihal ► REVIEW COMPLETE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Phase {N} reviewed by {count} AI systems.
+
+Consensus concerns:
+{top 3 shared concerns}
+
+Full review: {padded_phase}-REVIEWS.md
+
+To incorporate feedback into planning:
+  /rihal:plan {N} --reviews
+```
+
+Clean up temp files.
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] At least one external CLI invoked successfully
+- [ ] REVIEWS.md written with structured feedback
+- [ ] Consensus summary synthesized from multiple reviewers
+- [ ] Temp files cleaned up
+- [ ] User knows how to use feedback (/rihal:plan --reviews)
+</success_criteria>

package/rihal/workflows/scan.md

@@ -0,0 +1,135 @@
+<purpose>
+Lightweight codebase assessment. Spawns a single rihal-codebase-mapper agent for one focus area,
+producing targeted documents in `.planning/codebase/`.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<available_agent_types>
+Valid Rihal subagent types (use exact names — do not fall back to 'general-purpose'):
+- rihal-codebase-mapper — Maps project structure and dependencies
+</available_agent_types>
+
+## Step 0 — Usage check
+
+If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
+- Print the usage block below
+- STOP — do not proceed
+
+**Usage:**
+```
+/rihal:scan [--focus tech|arch|quality|concerns|tech+arch]
+```
+
+**Examples:**
+```
+/rihal:scan --focus tech
+/rihal:scan --focus arch
+/rihal:scan --focus tech+arch
+```
+
+<process>
+
+## Focus-to-Document Mapping
+
+| Focus | Documents Produced |
+|-------|-------------------|
+| `tech` | STACK.md, INTEGRATIONS.md |
+| `arch` | ARCHITECTURE.md, STRUCTURE.md |
+| `quality` | CONVENTIONS.md, TESTING.md |
+| `concerns` | CONCERNS.md |
+| `tech+arch` | STACK.md, INTEGRATIONS.md, ARCHITECTURE.md, STRUCTURE.md |
+
+## Step 1: Parse arguments and resolve focus
+
+Parse the user's input for `--focus <area>`. Default to `tech+arch` if not specified.
+
+Validate that the focus is one of: `tech`, `arch`, `quality`, `concerns`, `tech+arch`.
+
+If invalid:
+```
+Unknown focus area: "{input}". Valid options: tech, arch, quality, concerns, tech+arch
+```
+Exit.
+
+## Step 2: Check for existing documents
+
+```bash
+INIT=$(node "$PROJECT_ROOT/.rihal/bin/rihal-tools.cjs" init scan 2>/dev/null || echo "{}")
+if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
+```
+
+Look up which documents would be produced for the selected focus (from the mapping table above).
+
+For each target document, check if it already exists in `.planning/codebase/`:
+```bash
+ls -la .planning/codebase/{DOCUMENT}.md 2>/dev/null
+```
+
+If any exist, show their modification dates and ask:
+```
+Existing documents found:
+  - STACK.md (modified 2026-04-03)
+  - INTEGRATIONS.md (modified 2026-04-01)
+
+Overwrite with fresh scan? [y/N]
+```
+
+If user says no, exit.
+
+## Step 3: Create output directory
+
+```bash
+mkdir -p .planning/codebase
+```
+
+## Step 4: Spawn mapper agent
+
+Spawn a single `rihal-codebase-mapper` agent with the selected focus area:
+
+```
+Task(
+  prompt="Scan this codebase with focus: {focus}. Write results to .planning/codebase/. Produce only: {document_list}",
+  subagent_type="rihal-codebase-mapper",
+  model="{resolved_model}"
+)
+```
+
+## Step 5: Report
+
+```
+## Scan Complete
+
+**Focus:** {focus}
+**Documents produced:**
+{list of documents written with line counts}
+
+Use `/rihal:map-codebase` for a comprehensive 4-area parallel scan.
+```
+
+</process>
+
+<success_criteria>
+- [ ] Focus area correctly parsed (default: tech+arch)
+- [ ] Existing documents detected with modification dates shown
+- [ ] User prompted before overwriting
+- [ ] Single mapper agent spawned with correct focus
+- [ ] Output documents written to .planning/codebase/
+</success_criteria>
+
+## Success Criteria
+
+- [ ] Task completed as requested
+- [ ] Output saved or reported
+- [ ] State updated if necessary
+- [ ] No errors encountered
+
+## On Error
+
+If arguments are invalid, missing files, or subagent fails:
+- Validate inputs match expected format
+- Check that required files exist
+- Retry with clearer arguments or report the specific error to the user
+