bigpowers 2.76.3 → 2.77.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "bigpowers",
-  "version": "2.76.3",
+  "version": "2.77.1",
   "description": "73 agent skills synthesizing 17 years of software engineering discipline into a prescriptive methodology for solo developers",
   "main": "index.js",
   "scripts": {
-    "compliance": "bash scripts/audit-compliance.sh specs/verifications/features && bash scripts/validate-doctrine.sh",
+    "compliance": "bash scripts/audit-compliance.sh specs/verifications/features && bash scripts/validate-doctrine.sh && python3 scripts/check-skill-links.py",
     "doctrine": "bash scripts/validate-doctrine.sh",
     "sync": "bash scripts/sync-skills.sh",
     "validate-specs": "bash scripts/validate-specs-yaml.sh",
@@ -15,7 +15,8 @@
     "dashboard:web": "node dashboard/bin/dashboard.js --web",
     "site:dev": "cd website && npm run dev",
     "site:build": "cd website && npm run build",
-    "site:preview": "cd website && npm run preview"
+    "site:preview": "cd website && npm run preview",
+    "check:skill-links": "python3 scripts/check-skill-links.py"
   },
   "keywords": [
     "skills",

package/scripts/adapters/pi.sh

@@ -17,7 +17,7 @@ render_skill() {
       echo "description: \"$IR_DESC_ESCAPED\""
       echo "---"
       echo ""
-      echo "$IR_BODY"
+      echo "${IR_BODY_SKILL:-$IR_BODY}"
     } > "${PI_SKILLS}/$IR_NAME/SKILL.md"
   }
 
@@ -45,6 +45,9 @@ if [[ ! -t 0 ]]; then
     IR_MODEL=$(echo "$JSON_INPUT" | jq -r '.model')
     IR_DESCRIPTION=$(echo "$JSON_INPUT" | jq -r '.description')
     IR_BODY=$(echo "$JSON_INPUT" | jq -r '.body')
+    # Skill files get link-rewritten bodies (relative links repointed from
+    # .pi/skills/<name>/ to the shipped source tree); prompts keep the raw body.
+    IR_BODY_SKILL=$(echo "$JSON_INPUT" | jq -r '.body_pi_skill // .body')
     IR_DESC_ESCAPED=$(echo "$IR_DESCRIPTION" | sed 's/\\/\\\\/g; s/\"/\\"/g')
     render_skill
   fi

package/scripts/check-skill-links.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# check-skill-links.py — fail on machine-absolute paths or dangling relative
+# links in skill docs. Scans skills/**/SKILL.md and .pi/skills/**/SKILL.md.
+# Run: python3 scripts/check-skill-links.py  (exit 1 with a report on failure)
+#
+# NOTE: .cursor/rules/ and .gemini/extensions/ are intentionally excluded.
+# Those trees are auto-generated from SKILL.md sources via sync-skills.sh and
+# are not published to npm, so dangling links there are a rendering gap, not a
+# source defect. Enable once the sync pipeline gains link-rewriting support.
+# See: https://github.com/danielvm-git/bigpowers/issues/78
+import glob
+import os
+import sys
+
+# Import shared patterns — single source of truth so the rewriter (srp-engine)
+# and the gate always agree on what constitutes a "link".
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from lib.link_utils import LINK_RE, EXTERNAL_RE, MACHINE_PATH_RE, strip_code_spans  # noqa: E402
+
+
+def resolve_repo_root() -> str:
+    here = os.path.dirname(os.path.abspath(__file__))
+    candidate = os.path.dirname(here)  # scripts/ -> repo root
+    if os.path.isdir(os.path.join(candidate, "skills")):
+        return candidate
+    return os.getcwd()
+
+
+def check_file_links(smd: str, root: str) -> list[str]:
+    """Return a list of problem strings for a single SKILL.md file."""
+    rel = os.path.relpath(smd, root)
+    with open(smd, encoding="utf-8") as f:
+        text = f.read()
+
+    problems = []
+
+    # Machine-absolute path check runs on raw text (line-by-line for location).
+    for i, line in enumerate(text.splitlines(), 1):
+        if MACHINE_PATH_RE.search(line):
+            problems.append(f"{rel}:{i}: machine-absolute path: {line.strip()[:100]}")
+
+    # Link check runs on shadow (code spans blanked) to avoid false positives
+    # on example paths shown inside fenced blocks or inline code.
+    shadow = strip_code_spans(text)
+    for m in LINK_RE.finditer(shadow):
+        target = m.group(2).split("#", 1)[0]  # strip fragment
+        if not target or EXTERNAL_RE.match(target) or target.startswith(("#", "/")):
+            continue
+        resolved = os.path.normpath(os.path.join(os.path.dirname(smd), target))
+        if not os.path.exists(resolved):
+            problems.append(f"{rel}: dangling link -> {target}")
+
+    return problems
+
+
+def check(root: str) -> list[str]:
+    problems = []
+    for tree in ("skills", os.path.join(".pi", "skills")):
+        pattern = os.path.join(root, tree, "*", "SKILL.md")
+        for smd in sorted(glob.glob(pattern)):
+            problems.extend(check_file_links(smd, root))
+    return problems
+
+
+def main() -> int:
+    root = resolve_repo_root()
+    problems = check(root)
+    if problems:
+        print(f"check-skill-links: {len(problems)} problem(s):")
+        for p in problems:
+            print(f"  {p}")
+        return 1
+    print("check-skill-links: OK — no machine paths or dangling links")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/generate-allure-report.sh

@@ -0,0 +1,146 @@
+#!/usr/bin/env bash
+# story: e76
+set -euo pipefail
+source "$(dirname "${BASH_SOURCE[0]}")/lib/python-env.sh"
+ROOT="$(git rev-parse --show-toplevel 2>/dev/null)" || ROOT="$(dirname "${BASH_SOURCE[0]}")/.."
+
+mkdir -p "$ROOT/allure-results"
+
+$PYTHON - "$ROOT" <<'PY'
+import json
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+root = Path(sys.argv[1])
+out = root / "allure-results"
+
+exec_status_file = root / "specs" / "execution-status.yaml"
+release_plan_file = root / "specs" / "release-plan.yaml"
+cycle_times_file = root / "specs" / "metrics" / "cycle-times.yaml"
+bugs_registry_file = root / "specs" / "bugs" / "registry.yaml"
+
+sys.path.insert(0, str(root / "scripts" / "lib"))
+from simple_yaml import parse_simple_yaml
+
+exec_status = parse_simple_yaml(exec_status_file.read_text()) if exec_status_file.exists() else {}
+release_plan = parse_simple_yaml(release_plan_file.read_text()) if release_plan_file.exists() else {}
+cycle_times = parse_simple_yaml(cycle_times_file.read_text()) if cycle_times_file.exists() else {"stories": []}
+bugs_registry = parse_simple_yaml(bugs_registry_file.read_text()) if bugs_registry_file.exists() else {"bugs": []}
+
+# Build cycle-times lookup
+ct_lookup = {}
+for ct in cycle_times.get("stories", []):
+    if isinstance(ct, dict):
+        ct_lookup[ct.get("id", "")] = ct
+
+# Build JUnit XML
+stories = exec_status.get("stories", {})
+total_stories = len(stories)
+incomplete = sum(1 for s in stories.values() if isinstance(s, dict) and s.get("status") != "done")
+
+testsuite = ET.Element("testsuite", {
+    "name": "bigpowers-epic-progress",
+    "tests": str(total_stories),
+    "failures": str(incomplete),
+    "errors": "0",
+    "skipped": "0",
+})
+
+for story_id in sorted(stories.keys()):
+    story = stories[story_id]
+    if not isinstance(story, dict):
+        continue
+
+    epic_id = story.get("epic", "unknown")
+    title = story.get("title", story_id)
+    bcps = story.get("bcps", 0)
+    status = story.get("status", "backlog")
+    risk_max = story.get("risk_max", "none")
+    security_max = story.get("security_max", "none")
+
+    ct_data = ct_lookup.get(story_id, {})
+    cycle_minutes = ct_data.get("cycle_minutes", 0) if isinstance(ct_data, dict) else 0
+    bcp_per_hour = ct_data.get("bcp_per_hour", 0) if isinstance(ct_data, dict) else 0
+
+    time_seconds = cycle_minutes * 60.0 if cycle_minutes else 0.0
+
+    testcase = ET.SubElement(testsuite, "testcase", {
+        "classname": epic_id,
+        "name": f"{story_id}: {title}",
+        "time": str(round(time_seconds, 3)),
+    })
+
+    props = ET.SubElement(testcase, "properties")
+    ET.SubElement(props, "property", {"name": "risk", "value": risk_max})
+    ET.SubElement(props, "property", {"name": "security", "value": security_max})
+    ET.SubElement(props, "property", {"name": "bcps", "value": str(bcps)})
+    ET.SubElement(props, "property", {"name": "status", "value": status})
+    ET.SubElement(props, "property", {"name": "bcp_per_hour", "value": str(bcp_per_hour)})
+    ET.SubElement(props, "property", {"name": "lead_time_minutes", "value": str(cycle_minutes)})
+
+    if status != "done":
+        ET.SubElement(testcase, "failure", {
+            "message": f"Story {story_id} is {status} [risk={risk_max}, security={security_max}]",
+            "type": "StoryIncomplete"
+        })
+
+tree = ET.ElementTree(testsuite)
+ET.indent(tree, space="  ")
+tree.write(str(out / "junit-results.xml"), encoding="utf-8", xml_declaration=True)
+
+# Categories JSON
+epics = exec_status.get("epics", {})
+categories = []
+
+for epic_id in sorted(epics.keys()):
+    epic = epics[epic_id]
+    if isinstance(epic, dict) and epic.get("status") != "done":
+        categories.append({
+            "name": f"Epic: {epic.get('title', epic_id)}",
+            "matchedStatuses": ["failed"],
+            "messageRegex": f".*{epic_id}:.*"
+        })
+
+categories.append({
+    "name": "P0 Risk",
+    "matchedStatuses": ["failed"],
+    "messageRegex": ".*risk.*P0.*"
+})
+categories.append({
+    "name": "Security Review",
+    "matchedStatuses": ["failed"],
+    "messageRegex": ".*security.*(?:medium|high).*"
+})
+
+bug_list = bugs_registry.get("bugs", [])
+bug_count = len(bug_list) if isinstance(bug_list, list) else 0
+open_bugs = sum(1 for b in bug_list if isinstance(b, dict) and b.get("status") not in ("fixed", "closed", None))
+if open_bugs > 0:
+    categories.append({
+        "name": "Open Bugs",
+        "matchedStatuses": ["failed"],
+        "messageRegex": ".*Bug.*"
+    })
+
+(out / "categories.json").write_text(json.dumps(categories, indent=2))
+
+# Executor JSON
+rl = release_plan.get("release", {})
+if not isinstance(rl, dict):
+    rl = {}
+executor = {
+    "name": "bigpowers",
+    "type": "bigpowers",
+    "buildName": rl.get("version", "unknown"),
+    "buildOrder": len(exec_status.get("development_status", {})),
+}
+(out / "executor.json").write_text(json.dumps(executor, indent=2))
+
+epic_count = len([e for e in epics.values() if isinstance(e, dict) and e.get("status") == "done"])
+total_epics = len(epics)
+print(f"generate-allure-report: {total_stories} stories, {epic_count}/{total_epics} epics done, {bug_count} bugs")
+print(f"  -> {out}/junit-results.xml")
+print(f"  -> {out}/categories.json")
+print(f"  -> {out}/executor.json")
+PY

package/scripts/generate-reference-tables.sh

@@ -32,10 +32,11 @@ BLOCK="<!-- AUTO-GENERATED-CATALOG: begin — do not edit manually; run scripts/
 for row in "${ROWS[@]}"; do
   skill="${row%% *}"
   model="${row##* }"
+  skill_rel="${skill#$REPO_ROOT/}"
   # capitalise first letter for display
   model_cap="$(echo "${model:0:1}" | tr '[:lower:]' '[:upper:]')${model:1}"
   BLOCK+="
-| \`$skill\` | **$model_cap** |"
+| \`$skill_rel\` | **$model_cap** |"
 done
 BLOCK+="
 

package/scripts/lib/link_utils.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""link_utils.py — shared Markdown link patterns used by srp-engine and check-skill-links.
+
+Single source of truth for what constitutes a "link" so the rewriter and the
+regression gate always agree on the definition.
+"""
+import re
+
+# Matches standard Markdown links — with or without an optional title attribute.
+#   [text](target)
+#   [text](target "title")
+# Group 1: link text, Group 2: raw target (may include URL fragment)
+LINK_RE = re.compile(
+    r'\[([^\]]*)\]\('       # [text](
+    r'([^)\s"]+)'           # target (no spaces, no quotes)
+    r'(?:\s+"[^"]*")?'      # optional title attribute: "title text"
+    r'\s*\)'                # closing )
+)
+
+# Matches scheme-prefixed (non-relative) URLs that should never be rewritten
+# or resolved as local file paths.
+EXTERNAL_RE = re.compile(r'(?i)^(https?|ftp|file|mailto):')
+
+# Detects machine-absolute paths that must not appear in skill docs.
+# Covers macOS (/Users/), Linux (/home/), and Windows (C:\Users, D:\Users …).
+MACHINE_PATH_RE = re.compile(r'file:///|/Users/|/home/|[A-Z]:\\Users')
+
+# ---------------------------------------------------------------------------
+# Markdown code-block stripping
+# ---------------------------------------------------------------------------
+
+# Fenced code block: ``` or ~~~ with optional language tag, any content, close fence.
+_FENCED_BLOCK_RE = re.compile(r'(?m)^(`{3,}|~{3,})[^\n]*\n.*?\n\1\s*$', re.DOTALL)
+# Inline code: `…` (single backtick, non-empty)
+_INLINE_CODE_RE = re.compile(r'`[^`\n]+`')
+
+
+def strip_code_spans(text: str) -> str:
+    """Return *text* with fenced blocks and inline code replaced by blank space.
+
+    Preserves original character positions so that any offset-based logic
+    remains valid; only the link-matching content is neutralised.
+    """
+    def _blank(m: re.Match) -> str:
+        return ' ' * len(m.group(0))
+
+    text = _FENCED_BLOCK_RE.sub(_blank, text)
+    text = _INLINE_CODE_RE.sub(_blank, text)
+    return text

package/scripts/lib/srp-engine.py

@@ -7,6 +7,83 @@ import glob
 import subprocess
 import yaml
 
+# Ensure scripts/lib is on the path so link_utils resolves 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
+
+def rewrite_links_for_pi(body, name):
+    """Repoint relative links so they resolve from .pi/skills/<name>/.
+
+    Sibling *.md content is inlined into the rendered SKILL.md body, but the
+    links to those files (and to repo-root docs) still point at paths relative
+    to the source dir, so they dangle in the rendered tree. Repoint them at
+    the shipped source tree (skills/, profiles/, repo-root files) so links
+    resolve in repo checkouts and npm installs alike. External, anchor, and
+    absolute links pass through untouched.
+
+    Code fences and inline code are skipped — links inside them are examples,
+    not navigation targets.
+    """
+    out_dir = os.path.join(".pi", "skills", name)
+    # Build a "shadow" copy with code spans blanked out so LINK_RE never
+    # matches inside ``` blocks or inline `code`.
+    shadow = strip_code_spans(body)
+
+    def repl(m):
+        # If this match falls inside a code span the shadow char is a space;
+        # the real body char at that position is not a '[' — so LINK_RE won't
+        # match in the shadow at all.  The sub() runs on the shadow but we
+        # return the replacement for the real body using the captured groups.
+        text, raw_target = m.group(1), m.group(2).strip()
+        if EXTERNAL_RE.match(raw_target) or raw_target.startswith(('#', '/')):
+            return m.group(0)
+        # Split fragment before normpath to avoid mangling '#section/sub'.
+        if '#' in raw_target:
+            path_part, fragment = raw_target.split('#', 1)
+            frag_suffix = '#' + fragment
+        else:
+            path_part, frag_suffix = raw_target, ''
+        resolved = os.path.normpath(os.path.join("skills", name, path_part))
+        if resolved.startswith(".."):
+            return m.group(0)  # escapes repo root; leave untouched
+        new_target = os.path.relpath(resolved, out_dir).replace(os.sep, '/') + frag_suffix
+        return f"[{text}]({new_target})"
+
+    return LINK_RE.sub(repl, shadow).replace(shadow, body) if shadow == body else _apply_repl_on_real(body, shadow, name, out_dir)
+
+
+def _apply_repl_on_real(body, shadow, name, out_dir):
+    """Apply link rewrites to *body* using *shadow* to skip code spans.
+
+    Iterates LINK_RE matches on *shadow* (which has code spans blanked) and
+    rebuilds body with only the matched positions replaced.
+    """
+    result = []
+    last = 0
+    for m in LINK_RE.finditer(shadow):
+        result.append(body[last:m.start()])
+        text, raw_target = m.group(1), m.group(2).strip()
+        if EXTERNAL_RE.match(raw_target) or raw_target.startswith(('#', '/')):
+            result.append(body[m.start():m.end()])
+        else:
+            if '#' in raw_target:
+                path_part, fragment = raw_target.split('#', 1)
+                frag_suffix = '#' + fragment
+            else:
+                path_part, frag_suffix = raw_target, ''
+            resolved = os.path.normpath(os.path.join("skills", name, path_part))
+            if resolved.startswith(".."):
+                result.append(body[m.start():m.end()])
+            else:
+                new_target = os.path.relpath(resolved, out_dir).replace(os.sep, '/') + frag_suffix
+                result.append(f"[{text}]({new_target})")
+        last = m.end()
+    result.append(body[last:])
+    return ''.join(result)
+
 def resolve_repo_root():
     lib_dir = os.path.dirname(os.path.abspath(__file__))
     # scripts/lib/srp-engine.py -> two levels up is REPO_ROOT
@@ -210,7 +287,11 @@ def main():
                 continue
 
             for adapter in adapters:
-                dispatch_to_adapter(skill_data, adapter, repo_root)
+                data = skill_data
+                if adapter == "pi":
+                    data = dict(skill_data)
+                    data["body_pi_skill"] = rewrite_links_for_pi(skill_data['body'], skill_data['name'])
+                dispatch_to_adapter(data, adapter, repo_root)
 
             if okf_mode:
                 render_okf_concept(skill_data, okf_wiki_skills)
@@ -235,6 +316,10 @@ def main():
 
     skill_data = parse_skill(skill_md_path)
 
+    if target == "pi":
+        skill_data = dict(skill_data)
+        skill_data["body_pi_skill"] = rewrite_links_for_pi(skill_data['body'], skill_data['name'])
+
     if dry_run or not target:
         print(json.dumps(skill_data, indent=2))
         return

package/scripts/record-cycle-time.sh

@@ -50,6 +50,7 @@ STORY_KEY="Story"
 # git-hours engine — partition + whole_range_hours (additivity oracle)
 true && source "$(dirname "${BASH_SOURCE[0]}")/lib/git-hours.sh"
 true && source "$(dirname "${BASH_SOURCE[0]}")/lib/record-cycle-time-lib.sh"
+true && source "$(dirname "${BASH_SOURCE[0]}")/lib/python-env.sh"
 
 die() { record_cycle_die "$@"; }
 usage_cycle() { record_cycle_usage; }
@@ -256,6 +257,33 @@ cmd_append() {
   } >> "$file"
 
   echo "record-cycle-time: OKF bundle written for $story → $file (effort=$eff h, lead=$lead_min min, commits=$count)"
+
+  # Also update execution-status.yaml with cycle-time data
+  local exec_yaml="$ROOT/specs/execution-status.yaml"
+  if [ -f "$exec_yaml" ]; then
+    # Compute bcp_per_hour: bcps / effort_hours, handle zero effort
+    local bph
+    bph="$(awk -v b="$bcps" -v e="$eff" 'BEGIN{if(e>0)printf "%.1f", b/e; else print "0.0"}')"
+
+    $PYTHON -c "
+import sys
+sys.path.insert(0, '$ROOT/scripts/lib')
+import yaml
+try:
+    with open('$exec_yaml') as f:
+        data = yaml.safe_load(f) or {}
+except: data = {}
+
+stories = data.setdefault('stories', {})
+entry = stories.setdefault('$story', {})
+entry['effort_hours'] = float('$eff')
+entry['lead_time_minutes'] = int('$lead_min')
+entry['bcp_per_hour'] = float('$bph')
+
+with open('$exec_yaml', 'w') as f:
+    yaml.dump(data, f, default_flow_style=False, sort_keys=False, allow_unicode=True)
+" 2>/dev/null || echo "WARN: could not update execution-status.yaml with cycle-time data" >&2
+  fi
 }
 
 [ $# -ge 1 ] || { usage_cycle; }