@hanzlaa/rcode 3.4.24 → 3.4.25

package/cli/install.js

@@ -324,6 +324,11 @@ function detectIdeSignals(target) {
  * actually wanted cursor or gemini.
  */
 async function resolveIde(opts) {
+  // Issue #692: when the wizard has already collected opts.ides (interactive
+  // run from main()), resolveIde was re-prompting because it only checked
+  // opts.ideProvided (set by --ide flag, not by the wizard). Honor any
+  // pre-existing array result so we don't double-prompt.
+  if (Array.isArray(opts.ides) && opts.ides.length > 0) return opts.ides;
   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) {
@@ -1491,6 +1496,86 @@ async function install(opts) {
     return 2;
   }
 
+  // Issue #691: file lock prevents concurrent installs from racing on the
+  // same .rihal/_config/manifest.yaml + files-manifest.csv. Without it, two
+  // parallel runs (two terminals, postinstall + manual install, etc.) can
+  // each write a manifest the OTHER doesn't see → orphan sweep on the next
+  // install deletes files the other run considered legit.
+  let releaseLock = () => {};
+  if (!opts.global) {
+    const lockResult = acquireInstallLock(opts.target);
+    if (!lockResult.ok) {
+      console.log('');
+      console.log('  ' + warn(`Another install is already running here (PID ${lockResult.pid}).`));
+      console.log('  ' + dim(`  Lock: ${lockResult.lockPath}`));
+      console.log('  ' + dim('  If the other process crashed, delete the lock file and retry:'));
+      console.log('  ' + dim(`    rm ${lockResult.lockPath}`));
+      console.log('');
+      return 3;
+    }
+    releaseLock = lockResult.release;
+    // Make sure the lock is released even if install throws unexpectedly.
+    process.on('exit', releaseLock);
+  }
+
+  try {
+    return await installInner(opts);
+  } finally {
+    releaseLock();
+    process.removeListener('exit', releaseLock);
+  }
+}
+
+/**
+ * Acquire an exclusive install lock at .rihal/.install.lock (issue #691).
+ *
+ * Returns:
+ *   { ok: true, release: () => void }                 lock acquired
+ *   { ok: false, pid: number, lockPath: string }      another process holds it
+ *
+ * Stale-lock detection: if the recorded PID is not alive, the lock is
+ * reclaimed automatically.
+ */
+function acquireInstallLock(target) {
+  const lockDir = path.join(target, '.rihal');
+  const lockPath = path.join(lockDir, '.install.lock');
+  try {
+    fs.mkdirSync(lockDir, { recursive: true });
+  } catch { /* fall through; openSync will fail with a clearer error */ }
+
+  function isAlive(pid) {
+    try { process.kill(pid, 0); return true; } catch { return false; }
+  }
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = fs.openSync(lockPath, 'wx'); // exclusive create
+      fs.writeSync(fd, String(process.pid));
+      fs.closeSync(fd);
+      return {
+        ok: true,
+        release: () => {
+          try { fs.unlinkSync(lockPath); } catch {}
+        },
+      };
+    } catch (err) {
+      if (err.code !== 'EEXIST') throw err;
+      // Lock exists — check if holder is alive.
+      let pid = 0;
+      try { pid = parseInt(fs.readFileSync(lockPath, 'utf8'), 10); } catch {}
+      if (pid && !isAlive(pid)) {
+        // Stale lock — remove and retry once.
+        try { fs.unlinkSync(lockPath); } catch {}
+        continue;
+      }
+      return { ok: false, pid, lockPath };
+    }
+  }
+  // Should be unreachable, but degrade gracefully.
+  return { ok: false, pid: 0, lockPath };
+}
+
+async function installInner(opts) {
   const pkgVersion = readPackageVersion();
 
   // Header banner — only shown for interactive runs to keep CI/non-TTY logs terse.
@@ -2423,6 +2508,11 @@ async function runInstallWizard(opts) {
   });
   if (isCancel(editorChoices)) { cancel('Installation cancelled.'); process.exit(0); }
   opts.ides = editorChoices;
+  // Issue #692: keep opts.ide and opts.ides consistent so downstream callers
+  // that historically read either field see the same answer. Mark provided
+  // so any later resolveIde call exits early.
+  opts.ide = editorChoices[0];
+  opts.ideProvided = true;
 
   // ── 3. Communication language ─────────────────────────────────────────
   const langChoice = await select({

package/cli/uninstall.js

@@ -220,35 +220,29 @@ function buildPlan(cwd, editors) {
 }
 
 /**
- * List of action-skill names the installer places in .claude/skills/.
- * These do NOT start with `rihal-` (e.g., `rihal-domain-research` does, but
- * for safety we also keep a known list).
+ * Names of action-skill directories the installer places under .claude/skills/.
+ *
+ * Issue #693: this used to be a hardcoded array of 23 names that drifted from
+ * the source the moment anyone added or removed a skill in `rihal/skills/`.
+ * We now derive it from the package's own manifest (cli/lib/manifest.cjs)
+ * with a static fallback for the rare case where the manifest module isn't
+ * resolvable from the uninstall context.
  */
-const KNOWN_ACTION_SKILLS = [
-  'rihal-check-implementation-readiness',
-  'rihal-code-review',
-  'rihal-correct-course',
-  'rihal-create-architecture',
-  'rihal-create-epics-and-stories',
-  'rihal-create-prd',
-  'rihal-create-story',
-  'rihal-create-ux-design',
-  'rihal-dev-story',
-  'rihal-document-project',
-  'rihal-domain-research',
-  'rihal-edit-prd',
-  'rihal-frontend-design',
-  'rihal-generate-project-context',
-  'rihal-market-research',
-  'rihal-product-brief',
-  'rihal-qa-generate-e2e-tests',
-  'rihal-retrospective',
-  'rihal-sprint-planning',
-  'rihal-sprint-status',
-  'rihal-technical-research',
-  'rihal-validate-prd',
-  'rihal-clone-website',
-];
+function discoverKnownActionSkills() {
+  try {
+    const { readPackageManifest } = require(path.join(__dirname, 'lib', 'manifest.cjs'));
+    const packageRoot = path.resolve(__dirname, '..');
+    const pkg = readPackageManifest(packageRoot);
+    if (pkg && pkg.actions instanceof Set && pkg.actions.size > 0) {
+      return Array.from(pkg.actions);
+    }
+  } catch { /* fall through to static list */ }
+  // Static fallback — kept minimal, only the names that don't start with
+  // 'rihal-' would actually need this list since we already match
+  // 'rihal-*' via prefix. This is defensive only.
+  return [];
+}
+const KNOWN_ACTION_SKILLS = discoverKnownActionSkills();
 
 function isKnownSkillName(name) {
   return KNOWN_ACTION_SKILLS.includes(name);
@@ -425,9 +419,15 @@ async function runUninstall(args) {
   const opts = parseArgs(args);
   const cwd = process.cwd();
 
+  // Issue #693: keep the IDE list in sync with the installer. The installer
+  // ships claude/cursor/gemini/vscode/antigravity. The previous uninstaller
+  // list (claude/cursor/windsurf/antigravity) was missing gemini + vscode
+  // and included windsurf (which the installer never writes). Result: a
+  // user with vscode-style commands could never `rcode uninstall`.
+  const SUPPORTED_EDITORS = ['claude', 'cursor', 'gemini', 'vscode', 'antigravity'];
   const editors = opts.editor
-    ? (opts.editor === 'all' ? ['claude', 'cursor', 'windsurf', 'antigravity'] : [opts.editor])
-    : ['claude', 'cursor', 'windsurf', 'antigravity'];
+    ? (opts.editor === 'all' ? SUPPORTED_EDITORS : [opts.editor])
+    : SUPPORTED_EDITORS;
 
   console.log(`\n🕌 Rihal Code — Uninstall\n`);
   console.log(`   Project: ${cwd}`);

package/dist/rcode.js

@@ -15158,6 +15158,7 @@ var require_install = __commonJS({
       return signals;
     }
     async function resolveIde(opts) {
+      if (Array.isArray(opts.ides) && opts.ides.length > 0) return opts.ides;
       if (opts.ideProvided) return [opts.ide];
       if (opts.noPrompt || opts.global) return ["claude"];
       if (opts.yes || !process.stdin.isTTY) {
@@ -16046,6 +16047,78 @@ ${BLOCK}`, { mode: 493 });
         console.log("");
         return 2;
       }
+      let releaseLock = () => {
+      };
+      if (!opts.global) {
+        const lockResult = acquireInstallLock(opts.target);
+        if (!lockResult.ok) {
+          console.log("");
+          console.log("  " + warn(`Another install is already running here (PID ${lockResult.pid}).`));
+          console.log("  " + dim(`  Lock: ${lockResult.lockPath}`));
+          console.log("  " + dim("  If the other process crashed, delete the lock file and retry:"));
+          console.log("  " + dim(`    rm ${lockResult.lockPath}`));
+          console.log("");
+          return 3;
+        }
+        releaseLock = lockResult.release;
+        process.on("exit", releaseLock);
+      }
+      try {
+        return await installInner(opts);
+      } finally {
+        releaseLock();
+        process.removeListener("exit", releaseLock);
+      }
+    }
+    function acquireInstallLock(target) {
+      const lockDir = path2.join(target, ".rihal");
+      const lockPath = path2.join(lockDir, ".install.lock");
+      try {
+        fs2.mkdirSync(lockDir, { recursive: true });
+      } catch {
+      }
+      function isAlive(pid) {
+        try {
+          process.kill(pid, 0);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+          const fd = fs2.openSync(lockPath, "wx");
+          fs2.writeSync(fd, String(process.pid));
+          fs2.closeSync(fd);
+          return {
+            ok: true,
+            release: () => {
+              try {
+                fs2.unlinkSync(lockPath);
+              } catch {
+              }
+            }
+          };
+        } catch (err) {
+          if (err.code !== "EEXIST") throw err;
+          let pid = 0;
+          try {
+            pid = parseInt(fs2.readFileSync(lockPath, "utf8"), 10);
+          } catch {
+          }
+          if (pid && !isAlive(pid)) {
+            try {
+              fs2.unlinkSync(lockPath);
+            } catch {
+            }
+            continue;
+          }
+          return { ok: false, pid, lockPath };
+        }
+      }
+      return { ok: false, pid: 0, lockPath };
+    }
+    async function installInner(opts) {
       const pkgVersion = readPackageVersion();
       const isInteractive = process.stdin.isTTY && !opts.yes;
       if (isInteractive) printInstallHeader(pkgVersion);
@@ -16796,6 +16869,8 @@ commit_planning: ${desired}
         process.exit(0);
       }
       opts.ides = editorChoices;
+      opts.ide = editorChoices[0];
+      opts.ideProvided = true;
       const langChoice = await select({
         message: "Communication language?",
         options: [
@@ -17779,31 +17854,19 @@ var require_uninstall = __commonJS({
       }
       return plan;
     }
-    var KNOWN_ACTION_SKILLS = [
-      "rihal-check-implementation-readiness",
-      "rihal-code-review",
-      "rihal-correct-course",
-      "rihal-create-architecture",
-      "rihal-create-epics-and-stories",
-      "rihal-create-prd",
-      "rihal-create-story",
-      "rihal-create-ux-design",
-      "rihal-dev-story",
-      "rihal-document-project",
-      "rihal-domain-research",
-      "rihal-edit-prd",
-      "rihal-frontend-design",
-      "rihal-generate-project-context",
-      "rihal-market-research",
-      "rihal-product-brief",
-      "rihal-qa-generate-e2e-tests",
-      "rihal-retrospective",
-      "rihal-sprint-planning",
-      "rihal-sprint-status",
-      "rihal-technical-research",
-      "rihal-validate-prd",
-      "rihal-clone-website"
-    ];
+    function discoverKnownActionSkills() {
+      try {
+        const { readPackageManifest } = require(path2.join(__dirname, "lib", "manifest.cjs"));
+        const packageRoot = path2.resolve(__dirname, "..");
+        const pkg = readPackageManifest(packageRoot);
+        if (pkg && pkg.actions instanceof Set && pkg.actions.size > 0) {
+          return Array.from(pkg.actions);
+        }
+      } catch {
+      }
+      return [];
+    }
+    var KNOWN_ACTION_SKILLS = discoverKnownActionSkills();
     function isKnownSkillName(name) {
       return KNOWN_ACTION_SKILLS.includes(name);
     }
@@ -17918,7 +17981,8 @@ var require_uninstall = __commonJS({
     async function runUninstall(args) {
       const opts = parseArgs(args);
       const cwd = process.cwd();
-      const editors = opts.editor ? opts.editor === "all" ? ["claude", "cursor", "windsurf", "antigravity"] : [opts.editor] : ["claude", "cursor", "windsurf", "antigravity"];
+      const SUPPORTED_EDITORS = ["claude", "cursor", "gemini", "vscode", "antigravity"];
+      const editors = opts.editor ? opts.editor === "all" ? SUPPORTED_EDITORS : [opts.editor] : SUPPORTED_EDITORS;
       console.log(`
 \u{1F54C} Rihal Code \u2014 Uninstall
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hanzlaa/rcode",
-  "version": "3.4.24",
+  "version": "3.4.25",
   "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": {