@hanzlaa/rcode 3.4.6 → 3.4.8

package/cli/install.js

@@ -137,6 +137,12 @@ function parseArgs(argv) {
     // #199 — git pre-commit hook. null = install if .git/ present (default).
     // Set false by --no-git-hooks, true by --git-hooks.
     gitHooks: null,
+    // global install mode — targets ~/.claude/, skips per-project artifacts
+    global: false,
+    // silent — suppress non-error output (used by postinstall auto-run)
+    silent: false,
+    // noPrompt — skip all interactive prompts (used by postinstall auto-run)
+    noPrompt: false,
   };
   const positional = [];
   for (let i = 0; i < argv.length; i++) {
@@ -162,6 +168,9 @@ function parseArgs(argv) {
     else if (arg === '--no-backup') opts.noBackup = true;             // #381
     else if (arg === '--no-git-hooks') opts.gitHooks = false;         // #199
     else if (arg === '--git-hooks') opts.gitHooks = true;             // #199
+    else if (arg === '--global') opts.global = true;
+    else if (arg === '--silent') opts.silent = true;
+    else if (arg === '--no-prompt') opts.noPrompt = true;
     else if (!arg.startsWith('--')) positional.push(arg);
   }
   if (positional[0]) {
@@ -305,6 +314,7 @@ function detectIdeSignals(target) {
  */
 async function resolveIde(opts) {
   if (opts.ideProvided) return [opts.ide];            // user passed --ide, respect it
+  if (opts.noPrompt || opts.global) return ['claude']; // auto-install: always claude
   if (opts.yes || !process.stdin.isTTY) {
     // #182 — non-interactive mode: install into every detected IDE, not just
     // the default claude. The interactive flow already preselects detected
@@ -352,6 +362,7 @@ async function resolveIde(opts) {
  */
 async function resolveCommitPlanning(opts) {
   if (opts.commitPlanning !== null) return opts.commitPlanning;
+  if (opts.noPrompt || opts.global) return false; // global install: no planning artifacts
   if (opts.yes || !process.stdin.isTTY) return true; // non-interactive default
 
   const choice = await clack.select({
@@ -1654,6 +1665,27 @@ async function install(opts) {
     console.log('');
   }
 
+  // In global install mode (~/.claude/), skip per-project artifacts — those are
+  // created by `rcode install` inside each project directory at project-init time.
+  // Global install only ships the read-only tooling: commands, skills, workflows, bin.
+  if (opts.global) {
+    // Still write the manifest so the global install is traceable/upgradeable
+    const configDir = path.join(opts.target, '.rihal', '_config');
+    ensureDir(configDir);
+    fs.writeFileSync(path.join(configDir, 'manifest.yaml'), generateInstallManifest(opts));
+    // Install skills + sidebar stubs globally
+    let skillsInstalled = installSkills(PACKAGE_ROOT, opts.target);
+    try {
+      const { main: generateCommandSkills } = require(path.join(PACKAGE_ROOT, 'cli', 'generate-command-skills.cjs'));
+      const stubsDir = path.join(opts.target, '.claude', 'skills');
+      const result = generateCommandSkills(PACKAGE_ROOT, stubsDir, readPackageVersion());
+      skillsInstalled += result.generated;
+    } catch { /* non-fatal */ }
+    console.log('');
+    console.log(`  ${dim(`${skillsInstalled} skills installed globally`)}`);
+    return 0;
+  }
+
   // Write .rihal/_config/manifest.yaml + agent-manifest.csv + files-manifest.csv
   const configDir = path.join(opts.target, '.rihal', '_config');
   ensureDir(configDir);

package/cli/postinstall.js

@@ -1,18 +1,78 @@
 /**
- * rihal-code postinstall hook — runs automatically after `npm install`
+ * rihal-code postinstall hook — runs automatically after `npm install -g`
+ *
+ * Auto-installs commands, skills, workflows, and bin tools into the global
+ * Claude Code directory (~/.claude/) so every project can use rihal immediately
+ * without needing a per-project `rcode install` run.
+ *
+ * Artifacts (.planning/, STATE.md, ROADMAP.md) are always created in the
+ * project CWD at runtime — the global install only ships read-only tooling.
  */
 
-// Only print the welcome if not running in CI/test environments
+'use strict';
+const os = require('os');
+const path = require('path');
+
+// Skip in CI or test environments
 if (process.env.CI || process.env.NODE_ENV === 'test') {
   process.exit(0);
 }
 
-console.log(`
+// Only auto-install when invoked as a global package (npm install -g).
+// A local devDependency install should not touch the user's ~/.claude/.
+const isGlobalInstall = (() => {
+  try {
+    // npm sets npm_config_global=true for global installs
+    if (process.env.npm_config_global === 'true') return true;
+    // Fallback: check if the install prefix is a global npm prefix
+    const prefix = process.env.npm_config_prefix || '';
+    const home = os.homedir();
+    if (prefix && !prefix.startsWith(home) && !prefix.includes('node_modules')) return true;
+    return false;
+  } catch {
+    return false;
+  }
+})();
+
+const globalTarget = path.join(os.homedir(), '.claude');
+
+if (isGlobalInstall) {
+  // Run the global install in the background so npm output isn't blocked
+  const { install } = require('./install.js');
+  install({
+    target: globalTarget,
+    ides: ['claude'],
+    ide: 'claude',
+    yes: true,
+    noPrompt: true,
+    commitPlanning: false,
+    global: true,        // signal: skip per-project artifacts (STATE.md, ROADMAP.md, .planning/)
+    silent: false,
+  }).then((code) => {
+    if (code === 0) {
+      console.log(`\n✓ Rihal commands + skills installed globally → ${globalTarget}`);
+      console.log('  All /rihal-* commands are now available in every project.\n');
+    } else {
+      console.warn(`\n⚠ Global auto-install exited with code ${code}. Run 'rcode install' manually if needed.\n`);
+    }
+    printWelcome();
+  }).catch((err) => {
+    console.warn(`\n⚠ Global auto-install failed: ${err.message}`);
+    console.warn('  Run "rcode install" manually to set up rihal commands.\n');
+    printWelcome();
+  });
+} else {
+  printWelcome();
+}
+
+function printWelcome() {
+  console.log(`
 🕌 Rihal Code installed.
 
-First-time setup:
-  rcode install      # set up agents + slash commands
-  rcode tiers        # see the tier map
+Commands are available globally in every Claude Code project.
+To set up per-project state + planning structure, run inside your project:
+
+  rcode install      # creates .rihal/config.yaml, .planning/, STATE.md
 
 🌱 The Golden Path (say these phrases in your AI IDE):
   1. "scaffold a new project"     → rihal-scaffold-project
@@ -28,5 +88,5 @@ More:
   rcode dashboard    # view-only Diwan on :7717
 
 Docs: https://github.com/hanzlahabib/rihal-code
-Tiers: docs/TIERS.md   ·   Standards: docs/STANDARDS.md
 `);
+}

package/dist/rcode.js

@@ -15020,7 +15020,13 @@ var require_install = __commonJS({
         noBackup: false,
         // #199 — git pre-commit hook. null = install if .git/ present (default).
         // Set false by --no-git-hooks, true by --git-hooks.
-        gitHooks: null
+        gitHooks: null,
+        // global install mode — targets ~/.claude/, skips per-project artifacts
+        global: false,
+        // silent — suppress non-error output (used by postinstall auto-run)
+        silent: false,
+        // noPrompt — skip all interactive prompts (used by postinstall auto-run)
+        noPrompt: false
       };
       const positional = [];
       for (let i = 0; i < argv.length; i++) {
@@ -15048,6 +15054,9 @@ var require_install = __commonJS({
         else if (arg === "--no-backup") opts.noBackup = true;
         else if (arg === "--no-git-hooks") opts.gitHooks = false;
         else if (arg === "--git-hooks") opts.gitHooks = true;
+        else if (arg === "--global") opts.global = true;
+        else if (arg === "--silent") opts.silent = true;
+        else if (arg === "--no-prompt") opts.noPrompt = true;
         else if (!arg.startsWith("--")) positional.push(arg);
       }
       if (positional[0]) {
@@ -15146,6 +15155,7 @@ var require_install = __commonJS({
     }
     async function resolveIde(opts) {
       if (opts.ideProvided) return [opts.ide];
+      if (opts.noPrompt || opts.global) return ["claude"];
       if (opts.yes || !process.stdin.isTTY) {
         const signals2 = detectIdeSignals(opts.target);
         const detected2 = ["claude", "cursor", "gemini", "vscode", "antigravity"].filter((k) => signals2[k]);
@@ -15174,6 +15184,7 @@ var require_install = __commonJS({
     }
     async function resolveCommitPlanning(opts) {
       if (opts.commitPlanning !== null) return opts.commitPlanning;
+      if (opts.noPrompt || opts.global) return false;
       if (opts.yes || !process.stdin.isTTY) return true;
       const choice = await clack.select({
         message: "\u{1F4CB} .planning/ holds PRDs, roadmaps, sprints, SUMMARY files. How should they be tracked?",
@@ -16213,6 +16224,22 @@ ${BLOCK}`);
         }
         console.log("");
       }
+      if (opts.global) {
+        const configDir2 = path2.join(opts.target, ".rihal", "_config");
+        ensureDir(configDir2);
+        fs2.writeFileSync(path2.join(configDir2, "manifest.yaml"), generateInstallManifest(opts));
+        let skillsInstalled2 = installSkills(PACKAGE_ROOT2, opts.target);
+        try {
+          const { main: generateCommandSkills } = require(path2.join(PACKAGE_ROOT2, "cli", "generate-command-skills.cjs"));
+          const stubsDir = path2.join(opts.target, ".claude", "skills");
+          const result = generateCommandSkills(PACKAGE_ROOT2, stubsDir, readPackageVersion());
+          skillsInstalled2 += result.generated;
+        } catch {
+        }
+        console.log("");
+        console.log(`  ${dim(`${skillsInstalled2} skills installed globally`)}`);
+        return 0;
+      }
       const configDir = path2.join(opts.target, ".rihal", "_config");
       ensureDir(configDir);
       fs2.writeFileSync(path2.join(configDir, "manifest.yaml"), generateInstallManifest(opts));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzlaa/rcode",
-  "version": "3.4.6",
+  "version": "3.4.8",
   "description": "rcode — the memory bank for AI-driven SaaS teams. Persistent project context, distinctive engineering personas, and phase-based workflows. Built by Rihal. Works in Claude Code, Cursor, Gemini, VS Code, and Antigravity.",
   "main": "cli/index.js",
   "bin": {

package/rihal/agents/rules/executor/task-commit-protocol.md

@@ -6,6 +6,26 @@ After completing a task's implementation, follow this protocol to atomically com
 
 ---
 
+## Step 0: Detect Project Commit Standard (Run Once Per Sprint)
+
+Before writing any commit messages, read the project's commit standard from source — do NOT invent one or ask the user unless nothing is found.
+
+**Check in this order (stop at first hit):**
+
+1. `.github/COMMIT_CONVENTION.md` — explicit commit format doc
+2. `CONTRIBUTING.md` — look for a "Commit" or "Git" section
+3. `.commitlintrc`, `.commitlintrc.json`, `.commitlintrc.yaml`, `commitlint.config.js`, `commitlint.config.cjs` — commitlint config
+4. `package.json` → `"commitlint"` key
+5. `.github/pull_request_template.md` — PR template reveals expected format (e.g., ticket prefix, changelog format)
+
+**If a standard is found:** Use it silently for all commits in this sprint. No need to confirm with user.
+
+**If nothing is found:** Default to Conventional Commits (`type(scope): subject`). Mention the format once in your sprint opening summary — do not ask the user to choose.
+
+**Never ask the user "what commit format do you want?"** — that's noise. Read first, decide, proceed.
+
+---
+
 ## Step 1: Check Git Status
 ```bash
 git status --short
@@ -62,14 +82,16 @@ Match the change to a conventional commit type:
 
 ## Step 4: Choose Scope
 
-Scope is the area affected, in parentheses:
+Scope is the **subsystem or domain** affected, in parentheses — NOT the phase/sprint number.
 
 - `feat(auth)` - authentication feature
 - `fix(payments)` - payments bug fix
 - `test(api)` - API tests
 - `refactor(ui)` - UI code cleanup
 
-Scope should match the PLAN task name or subsystem.
+**NEVER use a phase or sprint number as the scope.** `fix(114):` or `feat(114-03):` are wrong.
+Use the name of the subsystem the task touches (e.g., `sequence-builder`, `auth`, `dashboard`, `api`).
+If no obvious subsystem exists, omit the scope: `fix: correct delay type in email templates`.
 
 ---
 
@@ -210,6 +232,8 @@ Bad:
 feat(auth): Adds JWT refresh tokens.
 fix: I fixed the payment thing
 Updated auth code
+fix(114): correct delay type       ← phase number as scope — WRONG
+feat(114-03): add drag-and-drop    ← sprint ID as scope — WRONG
 ```
 
 ---

package/rihal/references/auto-init-guard.md

@@ -0,0 +1,104 @@
+# Auto-Init Guard
+
+Run this check at the very start of any workflow that needs project state.
+
+## Step: Detect project initialization
+
+```bash
+test -f .rihal/config.yaml && echo "rihal-ready" || echo "rihal-not-initialized"
+```
+
+**If `rihal-ready`:** continue with the workflow normally.
+
+**If `rihal-not-initialized`:** the user has never set up Rihal for this project. Do NOT fail or continue blindly. Run the project init flow inline before proceeding:
+
+---
+
+### Inline init flow (when config.yaml is missing)
+
+Tell the user:
+
+```
+Rihal isn't configured for this project yet. Let me set it up — takes 30 seconds.
+```
+
+**1. Bootstrap local tooling** — copy bin and workflows from the global install:
+
+```bash
+GLOBAL_RIHAL="$HOME/.rihal"
+if [ -d "$GLOBAL_RIHAL/bin" ]; then
+  mkdir -p .rihal/bin .rihal/workflows .rihal/references
+  cp "$GLOBAL_RIHAL/bin/rihal-tools.cjs" .rihal/bin/ 2>/dev/null || true
+  # workflows and references are read from ~/.rihal at runtime via @.rihal/ resolution
+fi
+```
+
+**2. Ask the 5 config questions** using AskUserQuestion:
+
+| # | Question | Options | Default |
+|---|----------|---------|---------|
+| 1 | Your name (what Rihal calls you) | free text | `$USER` |
+| 2 | Language for agent responses | English / Arabic / Urdu / Roman Urdu | English |
+| 3 | Mode (how Rihal handles decision gates) | `guided` / `yolo` | guided |
+| 4 | Model profile (cost vs quality) | `quality` / `balanced` / `budget` | balanced |
+| 5 | Commit planning artifacts to git? | yes / no | yes |
+
+**3. Write `.rihal/config.yaml` directly** (no rihal-tools needed — plain Bash):
+
+```bash
+mkdir -p .rihal
+cat > .rihal/config.yaml << 'YAML'
+# Rihal project config — edit any time
+user_name: "{name}"
+project_name: "{basename_of_cwd}"
+communication_language: "{lang}"
+mode: "{mode}"
+model_profile: "{profile}"
+commit_planning: {commit_planning_bool}
+rihal_source_path: ""
+workflow:
+  research_by_default: false
+  plan_checker: true
+  post_execute_gates: true
+  ui_safety_gate: true
+git:
+  branching_strategy: "none"
+YAML
+```
+
+**4. Seed `.rihal/state.json` and `.planning/` structure**:
+
+```bash
+mkdir -p .planning/phases .planning/council-sessions .rihal/context
+
+# state.json
+cat > .rihal/state.json << 'JSON'
+{"project":"{project_name}","phase":null,"sprint":null,"sessions":[],"initialized":"now"}
+JSON
+
+# context stubs
+echo "# Active Context\n\n_Run /rihal-init for full setup._" > .rihal/context/active.md
+echo "# Project Brief\n\n_Run /rihal-init for full setup._" > .rihal/context/project-brief.md
+```
+
+**5. Tell the user:**
+
+```
+✓ Rihal configured for this project.
+
+Config saved to .rihal/config.yaml — edit any time.
+Run /rihal-init for a full project scan and context setup.
+
+Continuing with your original request...
+```
+
+**6. Continue** with the original workflow as if it had been initialized from the start.
+
+---
+
+## Notes
+
+- This guard is **non-blocking** — it asks questions but does not stop the session; once config is written it resumes the original request automatically.
+- If `AskUserQuestion` is unavailable (non-interactive mode), use all defaults and skip the questions.
+- If the bootstrap `cp` fails (global rihal not found), print a warning and attempt to continue — some workflows work without local rihal-tools if they only need config.
+- On **subsequent runs**, the guard exits immediately (config exists) with zero overhead.

package/rihal/workflows/council.md

@@ -28,6 +28,7 @@ Closure: `RIHAL ► COUNCIL COMPLETE ✓` + Next Up with decision options.
 </output_format>
 
 <required_reading>
+@.rihal/references/auto-init-guard.md
 @.rihal/references/output-format.md
 @.rihal/references/council-protocol.md
 </required_reading>

package/rihal/workflows/do.md

@@ -3,6 +3,7 @@ Analyze freeform text from the user and route to the most appropriate Rihal comm
 </purpose>
 
 <required_reading>
+@.rihal/references/auto-init-guard.md
 @.rihal/references/output-format.md
 @.rihal/references/verb-dictionary.md
 @.rihal/references/dispatch-banner.md
@@ -11,6 +12,11 @@ Read all files referenced by the invoking prompt's execution_context before star
 
 <process>
 
+<step name="auto_init_check">
+Run the auto-init guard from `@.rihal/references/auto-init-guard.md` before anything else.
+If the project is not initialized, complete the inline init flow, then continue.
+</step>
+
 <step name="parse_args">
 Extract `$ARGUMENTS`, detect `--auto` flag, and check config mode:
 

package/rihal/workflows/execute.md

@@ -143,6 +143,7 @@ via filesystem and git state.
 </runtime_compatibility>
 
 <required_reading>
+@.rihal/references/auto-init-guard.md
 @.rihal/references/output-format.md
 Read STATE.md before any operation to load project context.
 

package/rihal/workflows/init.md

@@ -1,9 +1,9 @@
 # Workflow: rihal-init
 
 <purpose>
-Begin the rihla. This is the first command a user runs after dropping Rihal files into a project. It detects project state, asks a handful of configuration questions, scans existing context (if any), writes `.rihal/RIHLA.md` as the journey baseline, and routes to the right next command.
+Begin the rihla. This is the entry point for configuring Rihal in a project. Runs automatically on first use of any rihal command (via auto-init-guard in do.md), or explicitly via /rihal-init for a full setup with codebase scan.
 
-This replaces the older `/rihal-generate-project-context` workflow — init is the single entry point for configuring Rihal in a project.
+No manual "rcode install" needed per project — just use any /rihal-* command and this triggers automatically when config is missing.
 </purpose>
 
 ## Step 0 — Usage check

package/rihal/workflows/new-project.md

@@ -4,6 +4,7 @@ Initialize a new project through unified flow: questioning, research (optional),
 </purpose>
 
 <required_reading>
+@.rihal/references/auto-init-guard.md
 @.rihal/references/output-format.md
 
 Read all files referenced by the invoking prompt's execution_context before starting.

package/rihal/workflows/plan.md

@@ -41,6 +41,7 @@ End with Next Up routing to /rihal-execute.
 </output_format>
 
 <required_reading>
+@.rihal/references/auto-init-guard.md
 @.rihal/references/output-format.md
 Read all files referenced by the invoking prompt's execution_context before starting.
 

package/rihal/workflows/status.md

@@ -7,6 +7,7 @@ Render a human-readable project status dashboard. All data comes from a single `
 </purpose>
 
 <required_reading>
+@.rihal/references/auto-init-guard.md
 @.rihal/references/output-format.md
 </required_reading>