npm - @hanzlaa/rcode - Versions diffs - 3.6.16 → 4.0.0 - Mend

@hanzlaa/rcode 3.6.16 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1480) hide show

package/rihal/workflows/pause-work.md DELETED Viewed

@@ -1,249 +0,0 @@
-# Workflow: rihal-pause-work
-<purpose>
-Capture full project context and blocking constraints before pausing work. Creates `.rihal/HANDOFF.json` (structured machine-readable handoff) and `.rihal/.continue-here.md` (human-readable summary) for seamless context restoration on resume.
-</purpose>
-## Step 0 — Usage check
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
-```
-/rihal-pause-work <argument-here>
-```
-**Examples:**
-```
-/rihal-pause-work example 1
-/rihal-pause-work example 2
-```
-STOP — do not proceed.
-<available_tools>
-- Bash — read git status, log, file listing
-- Read — read state.json, current SPRINT.md
-- AskUserQuestion — collect blocking notes and constraints
-- Write — write HANDOFF.json and .continue-here.md
-</available_tools>
-## Step 1 — Load Project State
-```bash
-# Check Rihal project exists
-[ -d .rihal ] || (echo "❌ Not a Rihal project" && exit 1)
-# Load state.json
-cat .rihal/state.json 2>/dev/null || echo "{}"
-# Get git status
-git status --short
-# Get recent commits
-git log -5 --oneline --no-decorate
-# List current planning files
-find .planning -type f -name "*.md" 2>/dev/null | sort || true
-```
-Extract from state.json:
-- `current_phase` — active phase name
-- `current_sprint` — active plan index
-- `phases` — list of all phases
-- `executions` — completed executions
-- `blockers` — unresolved blockers
-- `decisions` — recent decisions
-## Step 2 — Read Active Plan (if any)
-If `current_sprint > 0`:
-```bash
-# Find the active SPRINT.md
-PLAN_FILE=$(find .planning/plans -name "SPRINT.md" -type f | head -1)
-[ -f "$PLAN_FILE" ] && cat "$PLAN_FILE" || true
-```
-Extract from active SPRINT.md:
-- Objective
-- Task list
-- Checkpoint status
-- Any in-progress or blocked tasks
-## Step 3 — Collect Blocking Constraints
-```bash
-CONFIG_MODE=$(node .rihal/bin/rihal-tools.cjs config-get mode 2>/dev/null || echo "guided")
-```
-**If `CONFIG_MODE == "yolo"`:** Set `blocking_constraints = ""` and skip to Step 4.
-Otherwise ask user via AskUserQuestion:
-```
-Question:
-Are there any blocking constraints, external dependencies, or critical notes
-the next session should know about?
-Examples:
-  - Waiting for Figma designs (due Friday)
-  - Auth service down, can't test login
-  - Blocked on customer approval for Feature X
-  - Database migration needs manual intervention on production
-Leave blank if none.
-Your answer:
-```
-Store response as `blocking_constraints` string.
-## Step 4 — Analyze Uncommitted Work
-```bash
-GIT_STATUS=$(git status --short)
-UNCOMMITTED_COUNT=$(echo "$GIT_STATUS" | wc -l)
-# Categorize changes
-MODIFIED=$(echo "$GIT_STATUS" | grep "^ M" | awk '{print $2}' | tr '\n' ', ')
-ADDED=$(echo "$GIT_STATUS" | grep "^A " | awk '{print $2}' | tr '\n' ', ')
-DELETED=$(echo "$GIT_STATUS" | grep "^ D" | awk '{print $2}' | tr '\n' ', ')
-UNTRACKED=$(echo "$GIT_STATUS" | grep "^?" | awk '{print $2}' | tr '\n' ', ')
-```
-## Step 5 — Build HANDOFF.json
-Write `.rihal/HANDOFF.json` with structured data:
-```json
-{
-  "timestamp": "ISO-8601 timestamp",
-  "project": "project name from state.json",
-  "current_phase": "name of current phase or null",
-  "current_sprint": "index of current plan or 0",
-  "phases": [
-    {
-      "name": "phase name",
-      "status": "not-started|in-progress|completed",
-      "slug": "phase-slug"
-    }
-  ],
-  "completed_tasks": [
-    {
-      "plan": "SPRINT.md filename",
-      "task": "task description",
-      "completed_at": "ISO-8601 timestamp"
-    }
-  ],
-  "remaining_tasks": [
-    {
-      "plan": "SPRINT.md filename",
-      "task": "task description",
-      "status": "in-progress|blocked|pending"
-    }
-  ],
-  "uncommitted_files": {
-    "modified": ["file1", "file2"],
-    "added": ["file3"],
-    "deleted": ["file4"],
-    "untracked": ["file5"]
-  },
-  "blocking_constraints": "user-provided notes",
-  "notes": "auto-generated summary",
-  "decisions": [
-    {
-      "summary": "decision text",
-      "phase": "phase name",
-      "date": "ISO-8601 timestamp"
-    }
-  ],
-  "next_steps": [
-    "Suggested action 1",
-    "Suggested action 2"
-  ]
-}
-```
-## Step 6 — Write .continue-here.md
-Write `.rihal/.continue-here.md` with human-readable summary:
-```markdown
-# Resume from: {timestamp}
-## Project Status
-- **Phase:** {current_phase or "Not started"}
-- **Progress:** {X of Y phases completed}
-## Current Work
-{If current plan active:}
-- **Plan:** {filename}
-- **Objective:** {objective from SPRINT.md}
-- **Status:** {in-progress|paused|blocked}
-## Uncommitted Work
-{If uncommitted_count > 0:}
-```
-Modified: {list}
-Added: {list}
-Deleted: {list}
-Untracked: {list}
-```
-{Else:}
-No uncommitted changes.
-## Blocking Constraints
-{blocking_constraints or "None"}
-## Key Decisions
-{list 3 most recent decisions}
-## Next Steps
-1. {suggested action 1}
-2. {suggested action 2}
-3. {suggested action 3}
----
-To resume work, run:
-\`\`\`bash
-/rihal-resume-work
-\`\`\`
-```
-## Step 7 — Print Summary
-```
-✓ Work paused successfully!
-Handoff saved:
-  - Machine-readable: .rihal/HANDOFF.json
-  - Human-readable: .rihal/.continue-here.md
-  - State snapshot: .rihal/state.json (updated)
-Current phase: {current_phase or "Not started"}
-Uncommitted changes: {count}
-Blocking constraints:
-  {blocking_constraints or "None"}
-To resume work, run:
-/rihal-resume-work
-```
-## 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

package/rihal/workflows/phase.md DELETED Viewed

@@ -1,89 +0,0 @@
-<purpose>
-Unified phase CRUD command. Routes to add (default — append integer phase to current milestone), insert (decimal phase under a parent — useful for urgent work mid-flight), or remove (delete an unstarted future phase + renumber). Replaces the muscle-memory pattern of remembering which of /rihal-add-phase, /rihal-insert-phase, /rihal-remove-phase to invoke.
-</purpose>
-## Step 0 — Usage check
-If `$ARGUMENTS` is empty AND no flag is set:
-```
-/rihal-phase <name>                          # append next integer phase (default)
-/rihal-phase --insert <parent> <name>        # insert decimal under <parent> (e.g. 14.1)
-/rihal-phase --remove <id>                   # remove unstarted future phase + renumber
-```
-STOP — do not proceed.
-## Step 1 — Disambiguate numeric arguments BEFORE routing
-If `$ARGUMENTS` is a bare integer (e.g. `116`, `20`, `7`) with no other words or flags:
-```bash
-# Check if a phase directory matching this number already exists
-PHASE_NUM="$ARGUMENTS"
-EXISTING=$(find .planning/phases -maxdepth 1 -type d -name "${PHASE_NUM}-*" 2>/dev/null | head -1)
-```
-If `$EXISTING` is non-empty, the user typed a phase number that already exists — they almost certainly meant to operate on it, not create a new one. Stop and ask:
-```
-Phase {N} already exists: {directory name}
-What did you mean to do?
-  /rihal-execute {N}   — execute the sprint plan for this phase
-  /rihal-plan {N}      — re-plan or view the plan for this phase
-  /rihal-status        — see overall project status
-  /rihal-phase "{description}"   — add a NEW phase (put the description in quotes)
-```
-Do NOT proceed to add/insert/remove. Wait for the user to clarify.
-If `$ARGUMENTS` is a bare integer and `$EXISTING` is empty, it's an ambiguous but plausible new-phase name. Proceed to Step 2 but warn:
-```
-Note: "{N}" looks like a number. If you meant to execute/plan phase {N}, use /rihal-execute {N} or /rihal-plan {N}.
-Adding a new phase named "{N}" — press Ctrl+C to cancel, or continue.
-```
-Then proceed to Step 2.
-## Step 1b — Parse mode flags
-Inspect `$ARGUMENTS`:
-- `--insert <parent>` → insert mode (delegates to insert-phase workflow with the parent + name)
-- `--remove <id>` → remove mode (delegates to remove-phase workflow)
-- (none) → add mode (default, delegates to add-phase workflow)
-Strip the mode flag and pass remaining args to the underlying workflow.
-## Step 2 — Dispatch to underlying workflow (after disambiguation)
-Each mode is implemented by an existing workflow:
-- **add (default):** read and execute `@.rihal/workflows/add-phase.md`. Output identical to `/rihal-add-phase`.
-- **insert (`--insert <parent>`):** read and execute `@.rihal/workflows/insert-phase.md`. Output identical to `/rihal-insert-phase`.
-- **remove (`--remove <id>`):** read and execute `@.rihal/workflows/remove-phase.md`. Output identical to `/rihal-remove-phase`.
-The underlying workflows are unchanged — `/rihal-phase` is a thin router. Behaviour, output format, and disk side-effects are byte-identical to invoking the underlying command directly.
-## Step 3 — Footer
-After the underlying workflow's output, append:
-```
-(rihal-phase: routed to {add|insert|remove} mode)
-```
-## Migration note
-The three absorbed commands continue to work as first-class aliases. `/rihal-phase` exists as the unified entry. Future minor versions may consolidate further; until then, both invocation paths are supported.
-## Acceptance
-- [ ] `/rihal-phase "fix authentication"` produces the same artefacts as `/rihal-add-phase "fix authentication"`
-- [ ] `/rihal-phase --insert 14 "hotfix wave"` produces the same artefacts as `/rihal-insert-phase 14 "hotfix wave"`
-- [ ] `/rihal-phase --remove 99` produces the same artefacts as `/rihal-remove-phase 99`
-- [ ] Unknown flag combinations produce a clear error

package/rihal/workflows/plan-milestone-gaps.md DELETED Viewed

@@ -1,273 +0,0 @@
-<purpose>
-Create all phases necessary to close gaps identified by `/rihal-audit-milestone`. Reads MILESTONE-AUDIT.md, groups gaps into logical phases, creates phase entries in ROADMAP.md, and offers to plan each phase. One command creates all fix phases — no manual `/rihal-add-phase` per gap.
-</purpose>
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-<process>
-## 1. Load Audit Results
-```bash
-# Find the most recent audit file
-(ls -t .planning/v*-MILESTONE-AUDIT.md 2>/dev/null || true) | head -1
-```
-Parse YAML frontmatter to extract structured gaps:
-- `gaps.requirements` — unsatisfied requirements
-- `gaps.integration` — missing cross-phase connections
-- `gaps.flows` — broken E2E flows
-If no audit file exists or has no gaps, error:
-```
-No audit gaps found. Run `/rihal-audit-milestone` first.
-```
-## 2. Prioritize Gaps
-Group gaps by priority from REQUIREMENTS.md:
-| Priority | Action |
-|----------|--------|
-| `must` | Create phase, blocks milestone |
-| `should` | Create phase, recommended |
-| `nice` | Ask user: include or defer? |
-For integration/flow gaps, infer priority from affected requirements.
-## 3. Group Gaps into Phases
-Cluster related gaps into logical phases:
-**Grouping rules:**
-- Same affected phase → combine into one fix phase
-- Same subsystem (auth, API, UI) → combine
-- Dependency order (fix stubs before wiring)
-- Keep phases focused: 2-4 tasks each
-**Example grouping:**
-```
-Gap: DASH-01 unsatisfied (Dashboard doesn't fetch)
-Gap: Integration Phase 1→3 (Auth not passed to API calls)
-Gap: Flow "View dashboard" broken at data fetch
-→ Phase 6: "Wire Dashboard to API"
-  - Add fetch to Dashboard.tsx
-  - Include auth header in fetch
-  - Handle response, update state
-  - Render user data
-```
-## 4. Determine Phase Numbers
-Find highest existing phase:
-```bash
-# Get sorted phase list, extract last one
-HIGHEST=$(node ".rihal/bin/rihal-tools.cjs" phases list --pick directories[-1])
-```
-New phases continue from there:
-- If Phase 5 is highest, gaps become Phase 6, 7, 8...
-## 5. Present Gap Closure Plan
-```markdown
-## Gap Closure Plan
-**Milestone:** {version}
-**Gaps to close:** {N} requirements, {M} integration, {K} flows
-### Proposed Phases
-**Phase {N}: {Name}**
-Closes:
-- {REQ-ID}: {description}
-- Integration: {from} → {to}
-Tasks: {count}
-**Phase {N+1}: {Name}**
-Closes:
-- {REQ-ID}: {description}
-- Flow: {flow name}
-Tasks: {count}
-{If nice-to-have gaps exist:}
-### Deferred (nice-to-have)
-These gaps are optional. Include them?
-- {gap description}
-- {gap description}
----
-Create these {X} phases? (yes / adjust / defer all optional)
-```
-Wait for user confirmation.
-## 6. Update ROADMAP.md
-Add new phases to current milestone:
-```markdown
-### Phase {N}: {Name}
-**Goal:** {derived from gaps being closed}
-**Requirements:** {REQ-IDs being satisfied}
-**Gap Closure:** Closes gaps from audit
-### Phase {N+1}: {Name}
-...
-```
-## 7. Update REQUIREMENTS.md Traceability Table (REQUIRED)
-For each REQ-ID assigned to a gap closure phase:
-- Update the Phase column to reflect the new gap closure phase
-- Reset Status to `Pending`
-Reset checked-off requirements the audit found unsatisfied:
-- Change `[x]` → `[ ]` for any requirement marked unsatisfied in the audit
-- Update coverage count at top of REQUIREMENTS.md
-```bash
-# Verify traceability table reflects gap closure assignments
-grep -c "Pending" .planning/REQUIREMENTS.md
-```
-## 8. Create Phase Directories
-```bash
-mkdir -p ".planning/phases/{NN}-{name}"
-```
-## 9. Commit Roadmap and Requirements Update
-```bash
-node ".rihal/bin/rihal-tools.cjs" commit "docs(roadmap): add gap closure phases {N}-{M}" --files .planning/ROADMAP.md .planning/REQUIREMENTS.md
-```
-## 10. Offer Next Steps
-```markdown
-## ✓ Gap Closure Phases Created
-**Phases added:** {N} - {M}
-**Gaps addressed:** {count} requirements, {count} integration, {count} flows
----
-## ▶ Next Up
-**Plan first gap closure phase**
-`/clear` then:
-`/rihal-plan {N}`
----
-**Also available:**
-- `/rihal-execute {N}` — if plans already exist
-- `cat .planning/ROADMAP.md` — see updated roadmap
----
-**After all gap phases complete:**
-`/rihal-audit-milestone` — re-audit to verify gaps closed
-`/rihal-complete-milestone {version}` — archive when audit passes
-```
-</process>
-<gap_to_phase_mapping>
-## How Gaps Become Tasks
-**Requirement gap → Tasks:**
-```yaml
-gap:
-  id: DASH-01
-  description: "User sees their data"
-  reason: "Dashboard exists but doesn't fetch from API"
-  missing:
-    - "useEffect with fetch to /api/user/data"
-    - "State for user data"
-    - "Render user data in JSX"
-becomes:
-phase: "Wire Dashboard Data"
-tasks:
-  - name: "Add data fetching"
-    files: [src/components/Dashboard.tsx]
-    action: "Add useEffect that fetches /api/user/data on mount"
-  - name: "Add state management"
-    files: [src/components/Dashboard.tsx]
-    action: "Add useState for userData, loading, error states"
-  - name: "Render user data"
-    files: [src/components/Dashboard.tsx]
-    action: "Replace placeholder with userData.map rendering"
-```
-**Integration gap → Tasks:**
-```yaml
-gap:
-  from_phase: 1
-  to_phase: 3
-  connection: "Auth token → API calls"
-  reason: "Dashboard API calls don't include auth header"
-  missing:
-    - "Auth header in fetch calls"
-    - "Token refresh on 401"
-becomes:
-phase: "Add Auth to Dashboard API Calls"
-tasks:
-  - name: "Add auth header to fetches"
-    files: [src/components/Dashboard.tsx, src/lib/api.ts]
-    action: "Include Authorization header with token in all API calls"
-  - name: "Handle 401 responses"
-    files: [src/lib/api.ts]
-    action: "Add interceptor to refresh token or redirect to login on 401"
-```
-**Flow gap → Tasks:**
-```yaml
-gap:
-  name: "User views dashboard after login"
-  broken_at: "Dashboard data load"
-  reason: "No fetch call"
-  missing:
-    - "Fetch user data on mount"
-    - "Display loading state"
-    - "Render user data"
-becomes:
-# Usually same phase as requirement/integration gap
-# Flow gaps often overlap with other gap types
-```
-</gap_to_phase_mapping>
-<success_criteria>
-- [ ] MILESTONE-AUDIT.md loaded and gaps parsed
-- [ ] Gaps prioritized (must/should/nice)
-- [ ] Gaps grouped into logical phases
-- [ ] User confirmed phase plan
-- [ ] ROADMAP.md updated with new phases
-- [ ] REQUIREMENTS.md traceability table updated with gap closure phase assignments
-- [ ] Unsatisfied requirement checkboxes reset (`[x]` → `[ ]`)
-- [ ] Coverage count updated in REQUIREMENTS.md
-- [ ] Phase directories created
-- [ ] Changes committed (includes REQUIREMENTS.md)
-- [ ] User knows to run `/rihal-plan` next
-</success_criteria>

package/rihal/workflows/plan-milestone.md DELETED Viewed

@@ -1,105 +0,0 @@
-<purpose>
-Plan all phases in a milestone using parallel dependency-wave execution. Closes #732.
-Groups independent phases into waves, spawns rihal-planner agents concurrently per wave, and verifies each SPRINT.md with rihal-sprint-checker before advancing.
-</purpose>
-<required_reading>
-@.rihal/references/output-format.md
-@.rihal/references/revision-loop.md
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-## 1. Parse arguments and load context
-Parse `$ARGUMENTS`:
-- `--milestone <name>` — filter to a named milestone (optional)
-- `--dry-run` — show wave plan without spawning agents
-- `--skip-research` — skip rihal-phase-researcher for all phases
-- `--wave <N>` — start from wave N (resume after partial failure)
-```bash
-INIT_JSON=$(node ".rihal/bin/rihal-tools.cjs" state read 2>/dev/null || echo '{}')
-ROADMAP_PHASES=$(node ".rihal/bin/rihal-tools.cjs" roadmap list-phases 2>/dev/null || echo '[]')
-```
-## 2. Build dependency wave graph
-Read ROADMAP.md. For each planned phase:
-1. Extract its `**Dependencies:**` line (if present) — list of phase numbers it depends on.
-2. Phases with no dependencies → Wave 1.
-3. Phases whose all dependencies are in Wave N → Wave N+1.
-4. Repeat until all phases are assigned.
-**Display wave plan:**
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► PLAN MILESTONE: {MILESTONE_NAME}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Wave 1 (parallel): Phase {N1}, Phase {N2}
-Wave 2 (parallel): Phase {N3}
-Wave 3 (serial):   Phase {N4}  ← depends on N3
-```
-If `--dry-run`: print the plan and exit.
-## 3. Execute waves sequentially, phases in parallel
-For each wave:
-**3a. Spawn rihal-planner agents in parallel (one per phase in wave):**
-Use `run_in_background: true` for each Agent dispatch. Wait for all to complete before next wave.
-```
-◆ Wave {N}: planning {count} phase(s) in parallel...
-  - Phase {N1}: {name}
-  - Phase {N2}: {name}
-```
-Each planner agent receives:
-- Phase number, name, goal from ROADMAP
-- `--skip-research` if flag is set
-- Research from RESEARCH.md if it exists
-**3b. Verify each SPRINT.md with rihal-sprint-checker:**
-After all planners in the wave complete, spawn rihal-sprint-checker for each SPRINT.md (in parallel, same run_in_background pattern). Collect CHECK.md results.
-On `FAIL` for any phase:
-```
-⚠ Phase {N} sprint-checker FAIL — entering revision loop (max 2 iterations)
-```
-Spawn a revision planner with checker feedback. Max 2 revision rounds per phase.
-**3c. Advance to next wave:**
-Only advance when all phases in the current wave have a passing CHECK.md.
-## 4. Completion summary
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► MILESTONE PLANNED ✓  {MILESTONE_NAME}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Waves: {N}
-Phases planned: {M}
-SPRINT.md files created: {M}
-Next step: /rihal-execute-milestone
-```
-## Output Format
-Open with wave-plan banner (step 2). Per-phase progress indicators. Closure banner (step 4).
-## Examples
-**Happy path:** `/rihal-plan-milestone` → plans all pending phases in parallel dependency waves.
-**Skip research:** `/rihal-plan-milestone --skip-research` → faster, uses CONTEXT.md if available.
-**Resume:** `/rihal-plan-milestone --wave 2` → skip wave 1 (already planned), start from wave 2.
-**Dry run:** `/rihal-plan-milestone --dry-run` → print wave assignment, exit.