bigpowers 2.77.1 → 2.77.2

package/.pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.77.1",
+  "version": "2.77.2",
   "description": "79 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,10 @@
+## [2.77.2](https://github.com/danielvm-git/bigpowers/compare/v2.77.1...v2.77.2) (2026-07-19)
+
+
+### Bug Fixes
+
+* **scripts:** fall back to simple_yaml when PyYAML is absent during setup ([#81](https://github.com/danielvm-git/bigpowers/issues/81)) ([2608c64](https://github.com/danielvm-git/bigpowers/commit/2608c645e1143f1bbf96c3174341b107c672ae8e))
+
 ## [2.77.1](https://github.com/danielvm-git/bigpowers/compare/v2.77.0...v2.77.1) (2026-07-19)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.77.1",
+  "version": "2.77.2",
   "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/simple_yaml.py

@@ -7,20 +7,30 @@ def parse_simple_yaml(text: str) -> dict:
     root: dict = {}
     # Each stack entry: (indent, container, parent_dict, key_in_parent)
     stack: list = [(0, root, None, None)]
-    skip_until_indent = None  # skip block scalar continuation lines (| and >)
+    skip_until_indent = None  # indent of an active block scalar's key line
+    block: dict = {}  # active block scalar: {'lines': [...], 'style': str, 'assign': fn}
+
+    def flush_block():
+        if block:
+            block['assign'](_fold_block(block['lines'], block['style']))
+            block.clear()
+
     for i, raw in enumerate(text.splitlines()):
         stripped = raw.strip()
-        if not stripped or stripped.startswith("#"):
-            # Reset block-scalar skip on blank lines
-            continue
         indent = len(raw) - len(raw.lstrip())
-        
-        # Skip block scalar continuation (| and > in YAML)
+
+        # Inside a block scalar: capture continuation lines verbatim. Blank and
+        # '#'-prefixed lines are literal content here, not comments.
         if skip_until_indent is not None:
-            if indent > skip_until_indent:
+            if not stripped or indent > skip_until_indent:
+                if block:
+                    block['lines'].append(raw)
                 continue
-            else:
-                skip_until_indent = None
+            flush_block()
+            skip_until_indent = None
+
+        if not stripped or stripped.startswith("#"):
+            continue
         
         # Pop stack until we're at the right nesting level
         # Don't pop list containers at same indent — sibling items stay in same list
@@ -68,8 +78,11 @@ def parse_simple_yaml(text: str) -> dict:
                 v = v.strip()
                 # Detect block scalars in list items too
                 if v in ("|", ">", "|-", ">-", "|+", ">+"):
-                    item = {k: v}
+                    item = {k: None}
                     container.append(item)
+                    block.clear()
+                    block.update(lines=[], style=v,
+                                 assign=lambda s, _i=item, _k=k: _i.__setitem__(_k, s))
                     skip_until_indent = indent
                     continue
                 item = {k: _yaml_scalar(v) if v else None}
@@ -87,12 +100,18 @@ def parse_simple_yaml(text: str) -> dict:
         key = key.strip()
         val = val.strip()
         
-        # Detect block scalars (|, >, |- etc.)
+        # Detect block scalars (|, >, |- etc.) and capture their folded content.
         if val in ("|", ">", "|-", ">-", "|+", ">+"):
+            tgt = None
             if isinstance(container, list) and container:
-                container[-1][key] = val  # store the marker
+                tgt = container[-1]
             elif isinstance(container, dict):
-                container[key] = val
+                tgt = container
+            if tgt is not None:
+                tgt[key] = None
+                block.clear()
+                block.update(lines=[], style=val,
+                             assign=lambda s, _t=tgt, _k=key: _t.__setitem__(_k, s))
             skip_until_indent = indent
             continue
         
@@ -111,11 +130,43 @@ def parse_simple_yaml(text: str) -> dict:
                 stack.append((indent, nxt, container, key))
             else:
                 container[key] = _yaml_scalar(val)
+    flush_block()
     return root
 
 
+def _fold_block(raw_lines, style):
+    """Fold a YAML block scalar (| literal / > folded) to match PyYAML."""
+    # Strip the common leading indentation of the block's content lines.
+    indents = [len(l) - len(l.lstrip()) for l in raw_lines if l.strip()]
+    ci = min(indents) if indents else 0
+    lines = [l[ci:] if len(l) >= ci else l.strip() for l in raw_lines]
+    if style[0] == "|":  # literal: keep line breaks
+        text = "\n".join(lines)
+    else:  # folded: single break -> space, blank line -> newline
+        parts, prev_blank = [], True
+        for l in lines:
+            if l == "":
+                parts.append("\n")
+                prev_blank = True
+            else:
+                if parts and not prev_blank:
+                    parts.append(" ")
+                parts.append(l)
+                prev_blank = False
+        text = "".join(parts)
+    text = text.rstrip("\n")
+    # Chomping indicator: '-' strip, default clip (single trailing newline).
+    return text if style.endswith("-") else text + "\n"
+
+
 def _yaml_scalar(val: str):
     """Convert a YAML scalar string to Python type."""
+    stripped = val.strip()
+    # Double-quoted scalar: unescape YAML escapes (\" and \\) like PyYAML, and
+    # keep it a string (no bool/int coercion). Keeps the PyYAML-free fallback
+    # byte-identical to PyYAML for quoted descriptions.
+    if len(stripped) >= 2 and stripped[0] == '"' and stripped[-1] == '"':
+        return stripped[1:-1].replace('\\"', '"').replace("\\\\", "\\")
     val = val.strip('"').strip("'")
     if val in ("true", "false"):
         return val == "true"

package/scripts/lib/srp-engine.py

@@ -1,19 +1,30 @@
 #!/usr/bin/env python3
 # story: e48s15
+# story: BUG-2026-07-18-setup-pyyaml-missing
 import os
 import sys
 import json
 import glob
 import subprocess
-import yaml
 
-# Ensure scripts/lib is on the path so link_utils resolves regardless of cwd.
+# Ensure scripts/lib is on the path so sibling modules (link_utils, and the
+# simple_yaml fallback below) resolve regardless of cwd.
 _LIB_DIR = os.path.dirname(os.path.abspath(__file__))
 if _LIB_DIR not in sys.path:
     sys.path.insert(0, _LIB_DIR)
 
 from link_utils import LINK_RE, EXTERNAL_RE, strip_code_spans  # noqa: E402
 
+# End-user setup (bigpowers setup) may run on a python3 without PyYAML.
+# Prefer PyYAML for exact parsing; fall back to the dependency-free
+# simple_yaml.py (story e38s01) so setup never hard-crashes.
+try:
+    import yaml
+    _load_yaml = yaml.safe_load
+except ModuleNotFoundError:
+    from simple_yaml import parse_simple_yaml
+    _load_yaml = parse_simple_yaml
+
 def rewrite_links_for_pi(body, name):
     """Repoint relative links so they resolve from .pi/skills/<name>/.
 
@@ -114,7 +125,7 @@ def parse_skill(skill_md_path):
     skill_body = '---'.join(parts[2:])
 
     try:
-        frontmatter = yaml.safe_load(frontmatter_raw)
+        frontmatter = _load_yaml(frontmatter_raw)
     except Exception as e:
         print(f"Error parsing YAML frontmatter in {skill_md_path}: {e}", file=sys.stderr)
         sys.exit(1)
@@ -160,7 +171,7 @@ def get_active_adapters(repo_root):
         return ["cursor", "gemini", "pi"]
     try:
         with open(targets_file, 'r', encoding='utf-8') as f:
-            data = yaml.safe_load(f)
+            data = _load_yaml(f.read())
         adapters = []
         for target in data.get('targets', []):
             if target.get('skill') is not None:

package/scripts/sync-skills.sh

@@ -74,7 +74,7 @@ if [[ -f "$TARGETS_FILE" ]] && command -v yq >/dev/null 2>&1; then
     [[ -n "$adapter" && "$adapter" != "null" ]] && SKILL_ADAPTERS+=("$adapter")
   done < <(yq -r '.targets[] | select(.skill != null) | .skill.adapter' "$TARGETS_FILE" | sort -u)
 else
-  echo "sync-skills: WARN — targets.yaml missing; using legacy render list" >&2
+  echo "sync-skills: WARN — yq unavailable or targets.yaml missing; using legacy render list (cursor gemini pi)" >&2
   SKILL_ADAPTERS=(cursor gemini pi)
 fi
 

package/scripts/test-setup-no-pyyaml.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# test-setup-no-pyyaml.sh — recurrence guard for BUG-2026-07-18-setup-pyyaml-missing
+#
+# `bigpowers setup` must not crash when the resolved python3 lacks PyYAML.
+# Two setup-path scripts hard-depended on PyYAML: srp-engine.py (import yaml)
+# and validate-skill-yaml.py (sys.exit(2) on ImportError). Both now fall back
+# to scripts/lib/simple_yaml.py. This guard asserts:
+#   1. srp-engine.py parses a skill under a PyYAML-free interpreter.
+#   2. validate-skill-yaml.py runs (does not exit 2) under the same.
+#   3. simple_yaml's output equals PyYAML's for every skill's frontmatter
+#      (covers escaped quotes and folded/literal block scalars).
+#
+# Usage: bash scripts/test-setup-no-pyyaml.sh
+set -euo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/lib/skill-common.sh"
+resolve_repo_root
+cd "$REPO_ROOT"
+
+GREEN='\033[0;32m'; RED='\033[0;31m'; NC='\033[0m'
+FAILURES=0
+pass() { echo -e "${GREEN}PASS${NC} $1"; }
+fail() { echo -e "${RED}FAIL${NC} $1"; FAILURES=$((FAILURES + 1)); }
+
+# Build a throwaway PyYAML-free interpreter — a fresh venv has no PyYAML,
+# reproducing a stock macOS python3 without touching the caller's environment.
+NOYAML_DIR="$(mktemp -d)"
+trap 'rm -rf "$NOYAML_DIR"' EXIT
+if ! python3 -m venv "$NOYAML_DIR/venv" >/dev/null 2>&1; then
+  echo "test-setup-no-pyyaml: SKIP — cannot create venv"; exit 0
+fi
+NOPY="$NOYAML_DIR/venv/bin/python"
+if "$NOPY" -c "import yaml" >/dev/null 2>&1; then
+  echo "test-setup-no-pyyaml: SKIP — fresh venv unexpectedly has PyYAML"; exit 0
+fi
+
+# 1. srp-engine.py must parse a skill's frontmatter without crashing.
+if "$NOPY" scripts/lib/srp-engine.py skills/fix-bug/SKILL.md >/dev/null 2>&1; then
+  pass "srp-engine.py parses frontmatter without PyYAML"
+else
+  fail "srp-engine.py crashed without PyYAML"
+fi
+
+# 2. validate-skill-yaml.py must not bail with exit 2 (the old PyYAML-required path).
+rc=0
+"$NOPY" scripts/validate-skill-yaml.py >/dev/null 2>&1 || rc=$?
+if [[ "$rc" -ne 2 ]]; then
+  pass "validate-skill-yaml.py runs without PyYAML (exit $rc)"
+else
+  fail "validate-skill-yaml.py bailed with exit 2 (PyYAML required)"
+fi
+
+# 3. Fallback fidelity: simple_yaml must equal PyYAML for every skill's
+#    frontmatter. Runs under python3 (CI has PyYAML); skips if PyYAML absent.
+if python3 - <<'PY'; then
+import glob, sys
+sys.path.insert(0, "scripts/lib")
+from simple_yaml import parse_simple_yaml
+try:
+    import yaml
+except ImportError:
+    print("skip: PyYAML not available for comparison"); sys.exit(0)
+bad = []
+for p in sorted(glob.glob("skills/*/SKILL.md")):
+    fm = open(p, encoding="utf-8").read().split("---")[1]
+    a = parse_simple_yaml(fm)
+    b = yaml.safe_load(fm)
+    for k in ("name", "description", "effort", "model"):
+        if a.get(k) != b.get(k):
+            bad.append(f"{p}:{k}")
+if bad:
+    print("mismatch: " + ", ".join(bad)); sys.exit(1)
+sys.exit(0)
+PY
+  pass "simple_yaml matches PyYAML for all skill frontmatter"
+else
+  fail "simple_yaml diverged from PyYAML for some skill frontmatter"
+fi
+
+if [[ "$FAILURES" -gt 0 ]]; then
+  echo "test-setup-no-pyyaml: $FAILURES failure(s)" >&2
+  exit 1
+fi
+echo "test-setup-no-pyyaml: PASS"

package/scripts/validate-skill-yaml.py

@@ -4,11 +4,18 @@ import glob
 import sys
 import os
 
+# Prefer PyYAML; fall back to the dependency-free scripts/lib/simple_yaml.py
+# (story e38s01) so `bigpowers setup` works on a python3 without PyYAML.
+# story: BUG-2026-07-18-setup-pyyaml-missing
+_LIB = os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib")
 try:
     import yaml
-except ImportError:
-    print("ERROR: PyYAML required — pip install pyyaml")
-    sys.exit(2)
+    _load_yaml = yaml.safe_load
+except ModuleNotFoundError:
+    if _LIB not in sys.path:
+        sys.path.insert(0, _LIB)
+    from simple_yaml import parse_simple_yaml
+    _load_yaml = parse_simple_yaml
 
 SKILLS_DIR = ".pi/skills"
 files = sorted(glob.glob(f"{SKILLS_DIR}/*/SKILL.md"))
@@ -30,8 +37,8 @@ for path in files:
     frontmatter = parts[1]
 
     try:
-        data = yaml.safe_load(frontmatter)
-    except yaml.YAMLError as e:
+        data = _load_yaml(frontmatter)
+    except Exception as e:
         parse_failures.append((skill_name, str(e).split("\n")[0]))
         continue