bigpowers 2.88.9 → 2.88.10

package/.gemini/extensions/bigpowers/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.9",
+  "version": "2.88.10",
   "description": "81 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "gemini-extension"

package/.pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.9",
+  "version": "2.88.10",
   "description": "81 skills — 73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "keywords": [
     "pi-package"

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [2.88.10](https://github.com/danielvm-git/bigpowers/compare/v2.88.9...v2.88.10) (2026-10-25)
+
+
+### Bug Fixes
+
+* **install:** support Windows without symlink privilege ([#135](https://github.com/danielvm-git/bigpowers/issues/135)) ([c47e3c5](https://github.com/danielvm-git/bigpowers/commit/c47e3c5465679046fe980be0c5593a489efee793)), closes [#134](https://github.com/danielvm-git/bigpowers/issues/134)
+* **srp:** resolve bash via PATH so adapters run on Windows ([#137](https://github.com/danielvm-git/bigpowers/issues/137)) ([c89f4f5](https://github.com/danielvm-git/bigpowers/commit/c89f4f563ed981a312f84cc6ac38e82a9826cd08))
+
 ## [2.88.9](https://github.com/danielvm-git/bigpowers/compare/v2.88.8...v2.88.9) (2026-09-21)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.88.9",
+  "version": "2.88.10",
   "description": "73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "main": "index.js",
   "scripts": {

package/scripts/lib/install-helpers.js

@@ -14,6 +14,7 @@
 // story: e72s02
 // story: e68s02
 // story: e65s02
+// story: #134
 // install-helpers.js — symlink helpers for bigpowers setup
 
 const fs = require('fs');
@@ -23,6 +24,50 @@ const path = require('path');
 // directory, which is how "managed" is detected (see assertReplaceable).
 const REPO_ROOT = path.resolve(__dirname, '..', '..');
 
+// Windows denies symlink creation unless the shell is elevated or Developer
+// Mode is on (EPERM). Directory *junctions* need no privilege, and Node reports
+// a junction through lstat/readlink exactly like a symlink — so install,
+// detectExistingInstall, and uninstall keep working. A file cannot be junctioned
+// (the result is a broken reparse point), so a file link on Windows becomes a
+// copy, tracked here so a reinstall replaces it and uninstall removes it.
+const copiesPath = () => path.join(require('os').homedir(), '.bigpowers', 'managed-copies.json');
+
+function managedCopies() {
+  try {
+    return new Set(JSON.parse(fs.readFileSync(copiesPath(), 'utf8')));
+  } catch {
+    return new Set();
+  }
+}
+
+function saveCopies(copies) {
+  fs.mkdirSync(path.dirname(copiesPath()), { recursive: true });
+  fs.writeFileSync(copiesPath(), JSON.stringify([...copies], null, 2));
+}
+
+// Symlink on POSIX; on Windows junction directories and copy (tracked) files.
+function createLink(src, dst) {
+  if (process.platform !== 'win32') {
+    fs.symlinkSync(src, dst);
+    return;
+  }
+  if (!fs.existsSync(src)) return; // source absent from this build (e.g. AGENTS.md)
+  if (fs.statSync(src).isDirectory()) {
+    fs.symlinkSync(src, dst, 'junction');
+    return;
+  }
+  try {
+    fs.symlinkSync(src, dst);
+    const copies = managedCopies();
+    if (copies.delete(dst)) saveCopies(copies); // was a copy; now a real link
+  } catch {
+    fs.copyFileSync(src, dst);
+    const copies = managedCopies();
+    copies.add(dst);
+    saveCopies(copies);
+  }
+}
+
 // Refuse to replace a destination that is not already a bigpowers-managed
 // symlink. Prevents setup from silently destroying a user's own file or
 // directory (e.g. an existing ~/.claude/hooks/rtk-rewrite.sh installed by
@@ -42,6 +87,9 @@ function assertReplaceable(dst) {
       return; // managed by bigpowers — safe to re-link
     }
   }
+  if (st.isFile() && managedCopies().has(dst)) {
+    return; // file copy placed by the Windows fallback — safe to re-link
+  }
   throw new Error(
     `Refusing to replace ${dst}: it exists and is not a bigpowers-managed symlink. ` +
     `Back it up or remove it manually, then re-run setup.`
@@ -58,7 +106,7 @@ function linkSkills(skillsDir, targetDir) {
 
     assertReplaceable(dst);
     fs.rmSync(dst, { force: true });
-    fs.symlinkSync(src, dst);
+    createLink(src, dst);
   }
 }
 
@@ -70,13 +118,13 @@ function linkDir(src, dst) {
   }
   assertReplaceable(dst);
   fs.rmSync(dst, { force: true });
-  fs.symlinkSync(src, dst);
+  createLink(src, dst);
 }
 
 function linkFile(src, dst) {
   assertReplaceable(dst);
   fs.rmSync(dst, { force: true });
-  fs.symlinkSync(src, dst);
+  createLink(src, dst);
 }
 
 function linkRenderedSkills(renderedDir, targetDir) {
@@ -106,7 +154,7 @@ function linkHook(src, dst) {
   }
   assertReplaceable(dst);
   fs.rmSync(dst, { force: true });
-  fs.symlinkSync(src, dst);
+  createLink(src, dst);
   try { fs.chmodSync(src, 0o755); } catch {}
 }
 
@@ -667,6 +715,13 @@ function removeSymlink(p) {
       fs.unlinkSync(p);
       return true;
     }
+    const copies = managedCopies();
+    if (stat.isFile() && copies.has(p)) {
+      fs.unlinkSync(p);
+      copies.delete(p);
+      saveCopies(copies);
+      return true;
+    }
   } catch {}
   return false;
 }

package/scripts/lib/srp-engine.py

@@ -5,6 +5,7 @@ import os
 import sys
 import json
 import glob
+import shutil
 import subprocess
 
 # Ensure scripts/lib is on the path so sibling modules (link_utils, and the
@@ -191,6 +192,20 @@ def render_okf_concept(skill_data, okf_wiki_skills):
     with open(okf_file, 'w', encoding='utf-8') as f:
         f.write('\n'.join(lines) + '\n')
 
+def resolve_bash():
+    """Return an explicit path to a usable bash interpreter.
+
+    On Windows, subprocess(['bash', ...]) goes through the Win32
+    CreateProcess search order, which checks C:\\Windows\\System32 before
+    PATH. That finds the WSL launcher stub (System32\\bash.exe) instead of
+    Git Bash and aborts with 'Windows Subsystem for Linux has no installed
+    distributions' on hosts without a WSL distro. shutil.which() honors PATH
+    order, so ask it for an explicit path first; fall back to the bare name
+    for minimal non-Windows environments where nothing is on PATH.
+    """
+    return os.environ.get("BIGPOWERS_BASH") or shutil.which("bash") or "bash"
+
+
 def dispatch_to_adapter(skill_data, target, repo_root):
     adapter_path = os.path.join(repo_root, "scripts", "adapters", f"{target}.sh")
     if not os.path.isfile(adapter_path):
@@ -199,7 +214,7 @@ def dispatch_to_adapter(skill_data, target, repo_root):
 
     # Pipe JSON to the adapter
     proc = subprocess.Popen(
-        ['bash', adapter_path],
+        [resolve_bash(), adapter_path],
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,

package/scripts/test-install-helpers.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // story: e60s01
+// story: #134
 // Regression selftest for scripts/lib/install-helpers.js (Wave 0 closeout).
 'use strict';
 
@@ -12,9 +13,25 @@ const { mkdtempSync, rmSync } = fs;
 const ROOT = path.resolve(__dirname, '..');
 const tmpHome = mkdtempSync(path.join(os.tmpdir(), 'bp-install-helpers-'));
 process.env.HOME = tmpHome;
+process.env.USERPROFILE = tmpHome; // os.homedir() prefers USERPROFILE on Windows
 
 const { installGlobal, linkHook } = require('../scripts/lib/install-helpers.js');
 
+const isWindows = process.platform === 'win32';
+
+// Directories become junctions on Windows, which lstat reports as symlinks.
+// Files cannot be symlinked without Developer Mode, so createLink copies them;
+// accept either shape and prove a copy matches the source byte-for-byte.
+function assertLinkedFile(dst, src, msg) {
+  const st = fs.lstatSync(dst);
+  if (st.isSymbolicLink()) {
+    assert.strictEqual(fs.readlinkSync(dst), src, msg);
+    return;
+  }
+  assert.ok(isWindows && st.isFile(), `${msg} (expected a symlink, or a Windows copy)`);
+  assert.strictEqual(fs.readFileSync(dst, 'utf8'), fs.readFileSync(src, 'utf8'), msg);
+}
+
 try {
   const hookSrc = path.join(ROOT, 'skills', 'guard-git', 'scripts', 'block-dangerous-git.sh');
   assert.ok(fs.existsSync(hookSrc), `Claude guard-git hook source must exist: ${hookSrc}`);
@@ -40,8 +57,7 @@ try {
   installGlobal({ id: 'claude', name: 'Claude Code' }, ROOT);
 
   const linked = path.join(tmpHome, '.claude', 'hooks', 'block-dangerous-git.sh');
-  assert.ok(fs.lstatSync(linked).isSymbolicLink(), 'block-dangerous-git.sh must be symlinked');
-  assert.strictEqual(fs.readlinkSync(linked), hookSrc, 'symlink must point at skills/guard-git path');
+  assertLinkedFile(linked, hookSrc, 'block-dangerous-git.sh must link to skills/guard-git');
 
   const libLinked = path.join(tmpHome, '.claude', 'hooks', 'lib');
   const libSrc = path.join(ROOT, 'skills', 'guard-git', 'scripts', 'lib');
@@ -53,8 +69,29 @@ try {
   );
 
   const rtkLinked = path.join(tmpHome, '.claude', 'hooks', 'rtk-rewrite.sh');
-  assert.ok(fs.lstatSync(rtkLinked).isSymbolicLink(), 'rtk-rewrite.sh must be symlinked');
-  assert.strictEqual(fs.readlinkSync(rtkLinked), rtkSrc, 'rtk-rewrite symlink must point at scripts/hooks source');
+  assertLinkedFile(rtkLinked, rtkSrc, 'rtk-rewrite.sh must link to scripts/hooks source');
+
+  if (isWindows) {
+    // Windows EPERM regression: without Developer Mode the hooks above are
+    // copies. A reinstall must not trip the "Refusing to replace" guard, and
+    // uninstall must remove the copies and clear them from the manifest.
+    const manifest = path.join(tmpHome, '.bigpowers', 'managed-copies.json');
+    const tracked = () => (fs.existsSync(manifest) ? JSON.parse(fs.readFileSync(manifest, 'utf8')) : []);
+    for (const p of [linked, rtkLinked]) {
+      if (!fs.lstatSync(p).isSymbolicLink()) {
+        assert.ok(tracked().includes(p), `Windows copy must be tracked in the manifest: ${p}`);
+      }
+    }
+    installGlobal({ id: 'claude', name: 'Claude Code' }, ROOT); // idempotent reinstall
+    uninstallTool('claude', ROOT);
+    assert.ok(!fs.existsSync(linked), 'uninstall must remove the block-dangerous-git hook');
+    assert.ok(!fs.existsSync(rtkLinked), 'uninstall must remove the rtk-rewrite hook');
+    assert.deepStrictEqual(
+      tracked().filter((p) => p === linked || p === rtkLinked),
+      [],
+      'uninstall must clear removed copies from the manifest'
+    );
+  }
 
   installGlobal({ id: 'pi', name: 'pi' }, ROOT);
   const piSkill = path.join(tmpHome, '.pi', 'agent', 'skills');
@@ -173,9 +210,10 @@ try {
 
     installLocal({ id: 'codex', name: 'Codex' }, ROOT);
     const localCodexAgents = path.join(tmpCwd, '.codex', 'AGENTS.md');
-    assert.ok(fs.lstatSync(localCodexAgents).isSymbolicLink(), 'local codex install must symlink AGENTS.md');
+    assertLinkedFile(localCodexAgents, path.join(ROOT, 'templates', 'codex', 'AGENTS.md'),
+      'local codex install must link AGENTS.md');
     uninstallTool('codex', ROOT);
-    assert.ok(!fs.existsSync(localCodexAgents), 'uninstallTool(codex) must remove LOCAL AGENTS.md symlink');
+    assert.ok(!fs.existsSync(localCodexAgents), 'uninstallTool(codex) must remove LOCAL AGENTS.md');
   } finally {
     process.chdir(savedCwd);
     rmSync(tmpCwd, { recursive: true, force: true });
@@ -353,8 +391,12 @@ try {
   // package root (e.g. <ROOT>-evil) as managed — needs a path-separator boundary.
   {
     const dst = path.join(tmpHome, 'prefix-boundary-hook.sh');
-    fs.symlinkSync(path.join(`${ROOT}-evil`, 'x.sh'), dst); // dangling foreign link
-      assert.throws(
+    if (isWindows) {
+      fs.writeFileSync(dst, 'foreign\n'); // Windows cannot make this link unprivileged
+    } else {
+      fs.symlinkSync(path.join(`${ROOT}-evil`, 'x.sh'), dst); // dangling foreign link
+    }
+    assert.throws(
         () => linkHook(rtkSrc, dst),
         /Refusing to replace/,
         'managed-symlink check must require a path-separator boundary (prefix sibling is NOT managed)'

package/tests/test_srp_engine.py

@@ -6,7 +6,9 @@ Run: python3 -m pytest tests/test_srp_engine.py -v
 """
 import os
 import sys
+import tempfile
 import unittest
+from unittest import mock
 
 # Make scripts/lib importable without installation.
 _REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
@@ -144,5 +146,66 @@ class TestRewriteLinksForPi(unittest.TestCase):
         self.assertNotIn("](REFERENCE.md)", result)  # real link rewritten
 
 
+class TestResolveBash(unittest.TestCase):
+    """Regression: dispatch must not make subprocess resolve the bare name
+    'bash'. On Windows the Win32 CreateProcess search order finds the WSL
+    stub in System32 before Git Bash on PATH, so setup aborted with
+    'Windows Subsystem for Linux has no installed distributions'."""
+
+    def test_env_override_wins(self):
+        with mock.patch.dict(os.environ, {"BIGPOWERS_BASH": "/custom/bash"}):
+            self.assertEqual(_srp.resolve_bash(), "/custom/bash")
+
+    def test_uses_path_resolved_bash(self):
+        env = {k: v for k, v in os.environ.items() if k != "BIGPOWERS_BASH"}
+        with mock.patch.dict(os.environ, env, clear=True):
+            with mock.patch.object(_srp.shutil, "which", return_value="/usr/bin/bash"):
+                self.assertEqual(_srp.resolve_bash(), "/usr/bin/bash")
+
+    def test_falls_back_to_bare_bash(self):
+        env = {k: v for k, v in os.environ.items() if k != "BIGPOWERS_BASH"}
+        with mock.patch.dict(os.environ, env, clear=True):
+            with mock.patch.object(_srp.shutil, "which", return_value=None):
+                self.assertEqual(_srp.resolve_bash(), "bash")
+
+
+class TestDispatchUsesResolvedBash(unittest.TestCase):
+    """The adapter subprocess must receive the PATH-resolved bash path, not
+    the bare name that Windows resolves to the WSL stub."""
+
+    def setUp(self):
+        self._tmp = tempfile.TemporaryDirectory()
+        self.repo_root = self._tmp.name
+        adapter_dir = os.path.join(self.repo_root, "scripts", "adapters")
+        os.makedirs(adapter_dir)
+        self.adapter = os.path.join(adapter_dir, "fake.sh")
+        with open(self.adapter, "w", encoding="utf-8") as f:
+            f.write("#!/usr/bin/env bash\n")
+
+    def tearDown(self):
+        self._tmp.cleanup()
+
+    def test_dispatch_passes_resolved_bash_to_popen(self):
+        captured = {}
+
+        class _FakeProc:
+            returncode = 0
+
+            def communicate(self, input=None):
+                return ("", "")
+
+        def _fake_popen(cmd, **kwargs):
+            captured["cmd"] = cmd
+            return _FakeProc()
+
+        sentinel = os.path.join(self.repo_root, "git-bash")
+        with mock.patch.object(_srp, "resolve_bash", return_value=sentinel):
+            with mock.patch.object(_srp.subprocess, "Popen", side_effect=_fake_popen):
+                _srp.dispatch_to_adapter({"name": "x"}, "fake", self.repo_root)
+
+        self.assertEqual(captured["cmd"][0], sentinel)
+        self.assertEqual(captured["cmd"][1], self.adapter)
+
+
 if __name__ == "__main__":
     unittest.main()

package/allure-results/categories.json

@@ -1,23 +0,0 @@
-[
-  {
-    "name": "P0 Risk",
-    "matchedStatuses": [
-      "failed"
-    ],
-    "messageRegex": ".*risk.*P0.*"
-  },
-  {
-    "name": "Security Review",
-    "matchedStatuses": [
-      "failed"
-    ],
-    "messageRegex": ".*security.*(?:medium|high).*"
-  },
-  {
-    "name": "Open Bugs",
-    "matchedStatuses": [
-      "failed"
-    ],
-    "messageRegex": ".*Bug.*"
-  }
-]

package/allure-results/executor.json

@@ -1,6 +0,0 @@
-{
-  "name": "bigpowers",
-  "type": "bigpowers",
-  "buildName": "2.76.2",
-  "buildOrder": 328
-}