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

@hanzlaa/rcode 3.6.15 → 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 (1484) hide show

package/rihal/workflows/new-workspace.md DELETED Viewed

@@ -1,167 +0,0 @@
-# Workflow: rihal-new-workspace
-<purpose>
-Create an isolated workspace for parallel work. Workspaces are independent planning directories with their own ROADMAP, STATE, and phases. Use when multiple concurrent initiatives need to run without interfering (e.g., "Q2 Platform Work" + "Bug Fix Sprint" in parallel).
-</purpose>
-## Step 0 — Usage check
-If `$ARGUMENTS` is empty or only `--help` or `-h`:
-```
-/rihal-new-workspace <workspace-name> [--from-current]
-```
-**Examples:**
-```
-/rihal-new-workspace Bug Fix Sprint
-/rihal-new-workspace --from-current Emergency Hotfix
-```
-STOP — do not proceed.
-## Step 1 — Parse arguments
-Extract from `$ARGUMENTS`:
-- `$WORKSPACE_NAME` — the workspace name (e.g., "Bug Fix Sprint")
-- `--from-current` flag → copy current planning state into new workspace
-If `$WORKSPACE_NAME` is empty, ask:
-```
-AskUserQuestion(
-  header: "New Workspace",
-  question: "Give the workspace a name (e.g., 'Q2 Performance')",
-  followUp: null
-)
-```
-## Step 2 — Create workspace directory
-Create workspace structure:
-```bash
-WORKSPACE_DIR=".rihal/workspaces/$(echo $WORKSPACE_NAME | tr ' ' '-' | tr '[:upper:]' '[:lower:]')"
-mkdir -p "$WORKSPACE_DIR"
-```
-Initialize subdirectories:
-```bash
-mkdir -p "$WORKSPACE_DIR/planning"
-mkdir -p "$WORKSPACE_DIR/phases"
-mkdir -p "$WORKSPACE_DIR/artifacts"
-```
-## Step 3 — Initialize workspace state
-If `--from-current` flag:
-- Copy `.planning/ROADMAP.md` to `$WORKSPACE_DIR/planning/ROADMAP.md`
-- Copy `.planning/STATE.md` to `$WORKSPACE_DIR/planning/STATE.md`
-- Update timestamps and mark as "forked from main workspace"
-Otherwise, create fresh files:
-Create `$WORKSPACE_DIR/planning/ROADMAP.md`:
-```markdown
-# Workspace: {WORKSPACE_NAME}
-**Created:** ISO-DATE
-**Status:** PLANNING
-## Scope
-_Describe the work for this workspace._
-## Phases
-None yet.
-## Success Criteria
-None yet.
-```
-Create `$WORKSPACE_DIR/planning/STATE.md`:
-```markdown
-# Workspace State: {WORKSPACE_NAME}
-**Created:** ISO-DATE
-**Current Phase:** PLANNING
-## Active Work
-None yet.
-## Decisions
-None yet.
-## Blockers
-None yet.
-```
-## Step 4 — Create workspace metadata
-Create `$WORKSPACE_DIR/.workspace-meta.json`:
-```json
-{
-  "name": "{WORKSPACE_NAME}",
-  "created": "ISO-DATE",
-  "status": "active",
-  "parent_workspace": "main" or "null if independent",
-  "description": "Isolated workspace for parallel work"
-}
-```
-## Step 5 — Register workspace
-Create or append to `.rihal/workspaces.csv`:
-```csv
-name,path,created,status,parent
-{WORKSPACE_NAME},{WORKSPACE_DIR},ISO-DATE,active,main
-```
-## Step 6 — Report
-Print:
-```
-✓ Workspace created: {WORKSPACE_NAME}
-  Location: {WORKSPACE_DIR}
-Start work:
-  /rihal-plan <task> --workspace={WORKSPACE_NAME}
-Switch context:
-  /rihal-workstream switch --name {WORKSPACE_NAME}
-```
-## Success Criteria
-- Workspace directory created at `.rihal/workspaces/{name}/`
-- ROADMAP.md and STATE.md initialized
-- Workspace metadata file created
-- Workspace registered in `.rihal/workspaces.csv`
-- User can plan/execute within this workspace
-## On Error
-If workspace with that name already exists:
-```
-⚠ Workspace '{WORKSPACE_NAME}' already exists.
-  Use a different name or: /rihal-remove-workspace {WORKSPACE_NAME}
-```
-If permissions prevent directory creation:
-```
-⚠ Cannot create workspace directory. Check permissions:
-  {WORKSPACE_DIR}
-```

package/rihal/workflows/next.md DELETED Viewed

@@ -1,162 +0,0 @@
-<purpose>
-Detect current project state and automatically advance to the next logical Rihal workflow step.
-Reads project state to determine: plan → execute → verify → complete progression.
-Zero-friction — detects and invokes, no confirmation needed.
-</purpose>
-<required_reading>
-@.rihal/references/output-format.md
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-<output_format>
-Print a routing banner when dispatching to the next command:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► ROUTING
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Current: Phase {N} — {name} | Sprint {sprint_id}
-Status:  {status description}
-▶ Next: `/rihal-{command} {args}`
-  {One-line explanation}
-```
-Follow all banner and status-symbol conventions from output-format.md.
-</output_format>
-<process>
-<step name="detect_state">
-Read project state to determine current position:
-```bash
-STATE=$(node .rihal/bin/rihal-tools.cjs state read 2>/dev/null || echo '{}')
-SPRINT_STATUS=$(node .rihal/bin/rihal-tools.cjs state sprint status 2>/dev/null || echo '{}')
-VELOCITY=$(node .rihal/bin/rihal-tools.cjs state sprint velocity 2>/dev/null || echo '{}')
-```
-Also read:
-- `.planning/STATE.md` — current phase, progress
-- `.planning/ROADMAP.md` — milestone structure and phase list
-Extract from state JSON:
-- `current_phase` — which phase is active
-- `current_sprint` — active sprint ID (or null)
-- `phases[]` — all phases with status
-- `velocity_history[]` — sprint velocity data
-If no `.planning/` directory AND no `.rihal/state.json`:
-```
-No Rihal project detected. Run `/rihal-new-project` to get started.
-```
-Exit.
-</step>
-<step name="safety_gates">
-Run hard-stop checks before routing. Exit on first hit unless `--force` was passed.
-If `--force` flag was passed, skip all gates.
-Print: `Warning: --force — skipping safety gates`
-Then proceed to `determine_next_action`.
-**Gate 1: Unresolved checkpoint**
-```bash
-[ -f .planning/.continue-here.md ]
-```
-If found:
-```
-Stop: Unresolved checkpoint
-`.planning/.continue-here.md` exists — a previous session left
-unfinished work. Read it, resolve, then delete to continue.
-Use `--force` to bypass.
-```
-Exit.
-**Gate 2: Error state**
-Check STATE.md for `status: error` or `status: failed`.
-If found:
-```
-Stop: Project in error state
-Resolve the error before advancing. Run `/rihal-health` to diagnose.
-Use `--force` to bypass.
-```
-Exit.
-**Gate 3: Unchecked verification**
-Check if current phase has VERIFICATION.md with FAIL items:
-If found:
-```
-Stop: Unchecked verification failures
-Phase {N} has {count} unresolved failures. Address them first.
-Use `--force` to bypass.
-```
-Exit.
-</step>
-<step name="determine_next_action">
-Apply routing rules based on state:
-**Route 1: No phases exist yet**
-ROADMAP.md exists but no phase directories on disk:
-Next: `/rihal-sprint-planning`
-**Route 2: Phase exists but no sprint**
-Current phase directory exists but has no SPRINT.md:
-Next: `/rihal-sprint-planning --phase {current_phase}`
-**Route 3: Sprint exists, stories incomplete**
-SPRINT.md exists and has stories with status != done:
-Next: `/rihal-execute .planning/phases/{phase_dir}/SPRINT.md`
-**Route 4: All stories done, sprint not closed**
-All stories are done but sprint status is still "active":
-Next: complete the sprint via `rihal-tools.cjs state sprint complete`, then suggest `/rihal-sprint-planning` for next sprint
-**Route 5: Sprint complete, next phase exists**
-Current phase is complete, next phase exists in ROADMAP:
-Next: `/rihal-sprint-planning --phase {next_phase}`
-**Route 6: All phases complete**
-All phases in ROADMAP are complete:
-Next: `/rihal-complete-milestone`
-**Route 7: Paused**
-State shows paused_at is set:
-Next: `/rihal-resume-work`
-**Route 8: No sprint system, fallback**
-State has no sprints[] data — legacy or empty project:
-Next: `/rihal-sprint-planning`
-</step>
-<step name="show_and_execute">
-Display the determination:
-```
-## Rihal Next
-**Current:** Phase {N} — {name} | Sprint {sprint_id}
-**Sprint:** {done}/{total} stories ({points_done}/{points_total} pts)
-Next: `/rihal-{command} {args}`
-  {One-line explanation}
-```
-Then immediately invoke the determined command.
-Do not ask for confirmation — `/rihal-next` is zero-friction advancement.
-</step>
-</process>
-<success_criteria>
-- [ ] Project state correctly detected
-- [ ] Next action correctly determined from routing rules
-- [ ] Command invoked immediately without user confirmation
-- [ ] Clear status shown before invoking
-</success_criteria>

package/rihal/workflows/note.md DELETED Viewed

@@ -1,156 +0,0 @@
-# Workflow: rihal-note
-<purpose>
-Capture inline notes instantly without friction. Appends text to a dated note file with YAML frontmatter. No subagents, no user questions, no bash chains — single Write operation.
-</purpose>
-## Step 0 — Usage check
-If `$ARGUMENTS` is empty or contains only `--help` or `-h`:
-```
-/rihal-note <argument-here>
-```
-**Examples:**
-```
-/rihal-note example 1
-/rihal-note example 2
-```
-STOP — do not proceed.
-## Step 1 — Parse arguments and flags
-Extract from `$ARGUMENTS`:
-- `--global` flag: write to `~/.rihal-notes/` instead of `.rihal/notes/`
-- Text content: everything else is the note text
-```bash
-GLOBAL_MODE=false
-NOTE_TEXT="$ARGUMENTS"
-if [[ "$ARGUMENTS" == *"--global"* ]]; then
-  GLOBAL_MODE=true
-  NOTE_TEXT=$(echo "$ARGUMENTS" | sed 's/--global[[:space:]]*//' | xargs)
-fi
-```
-If `NOTE_TEXT` is empty:
-```
-❌ Usage: /rihal-note <text>
-   Example: /rihal-note refactor auth module to use async/await
-   Flags:
-   --global  Save to ~/.rihal-notes/ instead of .rihal/notes/
-```
-Exit.
-## Step 2 — Generate slug and filename
-From NOTE_TEXT, create a URL-safe slug (lowercase, hyphens, max 50 chars):
-- "refactor auth module to use async/await" → "refactor-auth-module"
-Create filename: `YYYY-MM-DD-{slug}.md`
-- Example: `2026-04-12-refactor-auth-module.md`
-Determine target directory:
-- If GLOBAL_MODE: `~/.rihal-notes/`
-- Else: `.rihal/notes/`
-## Step 3 — Build note content with YAML frontmatter
-Create YAML frontmatter:
-```yaml
----
-date: YYYY-MM-DD
-slug: {slug}
-promoted: false
----
-```
-Append note text:
-```
-{NOTE_TEXT}
-```
-Final content:
-```
----
-date: 2026-04-12
-slug: refactor-auth-module
-promoted: false
----
-refactor auth module to use async/await
-```
-## Step 4 — Write note file (single operation, no chains)
-Write the complete note to target file. Create parent directory if needed.
-One operation only:
-```bash
-mkdir -p {target_dir}
-cat > {target_dir}/{filename} << 'EOF'
-{note content}
-EOF
-```
-Print:
-```
-✓ Note saved: {target_dir}/{filename}
----
-date: 2026-04-12
-slug: refactor-auth-module
-promoted: false
----
-refactor auth module to use async/await
-```
-## Step 5 — List subcommand: /rihal-note list
-If ARGUMENTS contains `list`:
-Call node helper:
-```bash
-node .rihal/bin/rihal-tools.cjs notes list
-```
-Expected output format: JSON array of recent notes:
-```json
-[
-  { "path": ".rihal/notes/2026-04-12-refactor-auth.md", "date": "2026-04-12", "slug": "refactor-auth", "summary": "refactor auth module..." },
-  { "path": ".rihal/notes/2026-04-11-api-design.md", "date": "2026-04-11", "slug": "api-design", "summary": "design new API endpoint..." }
-]
-```
-Parse and display (10 most recent):
-```
-## Recent Notes
-1. 2026-04-12 — refactor-auth
-   refactor auth module...
-2. 2026-04-11 — api-design
-   design new API endpoint...
-```
-## Success Criteria
-- [ ] Note saved with YAML frontmatter
-- [ ] File created in `.rihal/notes/` or `~/.rihal-notes/`
-- [ ] Filename follows YYYY-MM-DD-{slug}.md pattern
-- [ ] `promoted` field set to false
-- [ ] Output confirms save location and content
-- [ ] `--global` flag switches to home directory
-- [ ] `list` subcommand returns 10 most recent notes
-## On Error
-- **Empty note text:** print usage and exit
-- **Cannot create directory:** print error, suggest checking permissions
-- **File write fails:** print error, suggest checking disk space

package/rihal/workflows/notify-test.md DELETED Viewed

@@ -1,113 +0,0 @@
-# Workflow: rihal-notify-test
-<purpose>
-Verify a webhook URL is configured and reachable by posting a "test" message. Use this immediately after adding `slack_webhook_url`, `discord_webhook_url`, or `teams_webhook_url` to `.rihal/config.yaml` so you catch typos and permission errors before relying on notifications from `/rihal-execute`.
-</purpose>
-<output_format>
-Open with banner:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- RIHAL ► NOTIFY TEST
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-End with a per-platform result table: sent / skipped / failed.
-</output_format>
-<required_reading>
-@.rihal/references/output-format.md
-</required_reading>
-<process>
-## Step 0 — Usage check
-If `$ARGUMENTS` contains `--help` / `-h`:
-```
-/rihal-notify-test [--only slack|discord|teams] [--title "<t>"] [--body "<b>"]
-  --only <platform>   Limit the test to one platform
-  --title "<t>"       Override test title (default: "Rihal notify test")
-  --body "<b>"        Override test body
-```
-STOP — do not proceed.
-## Step 1 — Parse flags
-```bash
-ONLY=""
-TITLE="Rihal notify test"
-BODY="If you see this in your channel, webhook wiring works. Sent at $(date -u +%FT%TZ) from project $(basename "$PWD")."
-if echo "$ARGUMENTS" | grep -q -- "--only";  then ONLY=$(echo "$ARGUMENTS" | grep -oE -- "--only [a-z]+" | awk '{print $2}'); fi
-if echo "$ARGUMENTS" | grep -q -- "--title"; then TITLE=$(echo "$ARGUMENTS" | sed -n 's/.*--title "\([^"]*\)".*/\1/p'); fi
-if echo "$ARGUMENTS" | grep -q -- "--body";  then BODY=$(echo  "$ARGUMENTS" | sed -n 's/.*--body "\([^"]*\)".*/\1/p');  fi
-```
-## Step 2 — Send
-```bash
-ONLY_FLAG=""
-[ -n "$ONLY" ] && ONLY_FLAG="--only $ONLY"
-RESULT=$(node .rihal/bin/rihal-tools.cjs notify send \
-  --title "$TITLE" \
-  --body "$BODY" \
-  --event "notify-test" \
-  $ONLY_FLAG)
-```
-Parse the JSON result. Show:
-```
-| Platform | Result   | Detail                          |
-|----------|----------|----------------------------------|
-| slack    | sent     | —                                |
-| discord  | skipped  | no webhook configured            |
-| teams    | failed   | 403: invalid webhook token       |
-```
-## Step 3 — Guidance
-If ALL platforms are `skipped`:
-```
-No webhooks configured. Add at least one to .rihal/config.yaml:
-  slack_webhook_url: "https://hooks.slack.com/services/..."
-  discord_webhook_url: "https://discord.com/api/webhooks/..."
-  teams_webhook_url: "https://outlook.office.com/webhook/..."
-Then re-run /rihal-notify-test.
-```
-If any platform `failed`, echo the failure detail and list common causes:
-- Slack: revoked webhook, channel archived, rate-limited (429)
-- Discord: deleted webhook, wrong guild, content over 4000 chars
-- Teams: connector removed from the channel, legacy MessageCard rejected by newer tenant policy (if so, switch to Workflow-based connector)
-If any platform `sent`, print:
-```
-✓ Open your channel to confirm the test message appeared.
-  Then configure where notifications fire:
-    - /rihal-execute runs post-phase notify automatically
-    - /rihal-council --notify to ping after a council session
-```
-</process>
-## Success Criteria
-- No webhooks configured → clear setup guidance, not a crash
-- Per-platform success/failure surfaced individually (one failure doesn't mask others)
-- `--only` restricts the test to the chosen platform
-- Non-zero HTTP responses from webhooks are reported with their status and first 200 chars of the response body (already handled by the tool)
-## On Error
-- Missing `fetch` (Node <18) → the tool call will throw; tell the user to upgrade to Node 20+
-- Corporate proxy blocks outbound HTTPS → failure body will show a network error; suggest `HTTPS_PROXY` env var or testing from outside the proxy