@ikon85/agent-workflow-kit 0.10.0

package/scripts/test_dist_kit_smoke.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""dist-kit smoke — proves the BUILT kit's `validate-graph` imports + runs
+(Welle 52 / Slice 7 / #1936, PLAN Step 15).
+
+Why: `bundle.mjs`'s HELPER_FILES allowlist is the only thing that ships
+program_graph.py / program_graph_parse.py / program_graph_validate.py /
+node_kind.py / board_fields.py / program_sync.py into dist-kit/scripts/ — all
+six are imported UNCONDITIONALLY at board-sync.py's module top (not lazily
+inside a subcommand handler), so a forgotten entry does not fail at build time,
+it fails the FIRST time a consumer runs the shipped CLI (ImportError). This
+test catches that class of regression by actually invoking `validate-graph`
+against the built dist-kit/, not the scripts/ SSOT copy the rest of the suite
+imports.
+
+Fully offline: a throwaway consumer board profile (BOARD_SYNC_PROFILE env var)
+stands in for a project layer, and a fake `gh` shim on PATH answers the two
+read-only `gh` calls `validate-graph` makes (the PRD body + the empty
+sub-issues/children query) — no network, no real gh auth, no live board.
+
+Run: python3 scripts/test_dist_kit_smoke.py
+"""
+import json
+import os
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+DIST = REPO / "dist-kit"
+
+# A minimal but structurally complete consumer profile (see board_config.py's
+# _REQUIRED_PATHS) — distinct ids from Testreporter's own, so a leak would be
+# obvious. `fields.phase` is included (with the same shape #1936 gives the
+# real Testreporter profile) so the fixture also exercises the Phase-aware
+# path in validate-graph, not just its defensive None-fallback.
+FIXTURE_PROFILE = {
+    "repo": "acme/widgets",
+    "project": {"number": 7, "owner": "acme", "nodeId": "PVT_FIXTURE"},
+    "fields": {
+        "status": {"id": "PVTSSF_FIXTURE", "options": {"Spec": "opt-spec"}},
+        "wave": "PVTF_FIXTURE_WAVE",
+        "cluster": "PVTF_FIXTURE_CLUSTER",
+        "specPath": "PVTF_FIXTURE_SPEC",
+        "planPath": "PVTF_FIXTURE_PLAN",
+        "phase": {"id": "PVTSSF_FIXTURE_PHASE",
+                  "options": {"P1": "opt-p1", "P2": "opt-p2", "P3": "opt-p3"}},
+    },
+    "labels": {"readyForAgent": "ready-for-agent", "typePrefix": "type:",
+               "clusterType": "type:cluster", "waveStub": "wave-stub"},
+    "branchPrefixes": ["feat", "fix"],
+    "prMarkers": {"partOf": "Part of", "retroMarker": "**Retro:**",
+                  "retroValues": ["ran", "skipped"]},
+    "headings": {"vorBau": "Clarify Before Build"},
+}
+
+# A minimal green Program-PRD body — one wave, two slices, full scope coverage,
+# no cycles/backward-refs/gate warnings — the same shape as test_program_graph.py's
+# GREEN_PRD fixture, duplicated here (not imported) so this smoke stays
+# self-contained and independent of the SSOT test module's import side effects.
+GREEN_PRD = (
+    "<!-- prd: program -->\n"
+    "**plan_revision:** r1\n\n"
+    "## Scope\n"
+    "- **S1:** Programm-Graph-Fundament\n"
+    "- **S2:** Execute-Ready-Erweiterung\n\n"
+    "## Wellenplan\n"
+    "<!-- wellenplan:start -->\n"
+    "| Welle | Name | Phase | Slices | Gate | covers |\n"
+    "|---|---|---|---|---|---|\n"
+    "| 1 | Fundament | P1 | 1a, 1b | — | S1,S2 |\n"
+    "<!-- wellenplan:end -->\n\n"
+    "## Phasen-Gates\n"
+    "- [ ] P1: Fundament steht\n\n"
+    "## Slices\n"
+    "#### 1a — Graph-Modul\n"
+    "<!-- wave: 1 -->\n"
+    "<!-- phase: P1 -->\n"
+    "<!-- area: scripts -->\n"
+    "<!-- gate: — -->\n"
+    "<!-- blocked_by: none -->\n\n"
+    "#### 1b — Execute-Ready\n"
+    "<!-- wave: 1 -->\n"
+    "<!-- phase: P1 -->\n"
+    "<!-- area: scripts -->\n"
+    "<!-- gate: — -->\n"
+    "<!-- blocked_by: 1a -->\n"
+)
+
+# A fake `gh` binary: answers the sub-issues/children GraphQL query (empty —
+# no published stubs yet) and the PRD-body `issue view` read from a file, so
+# `validate-graph` runs end to end without any real `gh` call.
+FAKE_GH = """#!/usr/bin/env python3
+import os, sys
+args = sys.argv[1:]
+if "subIssues" in " ".join(args):
+    sys.stdout.write('{"data":{"repository":{"issue":{"subIssues":{"nodes":[]}}}}}')
+else:
+    with open(os.environ["DIST_KIT_SMOKE_BODY"], encoding="utf-8") as fh:
+        sys.stdout.write(fh.read())
+"""
+
+
+def _build_dist_kit():
+    """Run the real build (subprocess — the maintainer's actual publish step).
+    Returns (CompletedProcess, skip_reason); skip_reason is set only when node
+    itself is unavailable in this environment (mirrors test_skill_publish_audit.py)."""
+    build = REPO / "scripts/build-kit.mjs"
+    try:
+        r = subprocess.run(["node", str(build)], cwd=REPO,
+                            capture_output=True, text=True, timeout=120)
+    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+        return None, str(e)
+    return r, None
+
+
+class DistKitValidateGraphSmoke(unittest.TestCase):
+    """Builds dist-kit/ then runs `board-sync.py validate-graph` from the
+    SHIPPED location — proves the whole program_graph* / node_kind / board_fields
+    / program_sync import chain resolves in the actual publish artefact, and
+    that the command produces the correct counted report on a known fixture."""
+
+    def setUp(self):
+        r, skip_reason = _build_dist_kit()
+        if skip_reason:
+            self.skipTest(f"node/build unavailable: {skip_reason}")
+        self.assertEqual(r.returncode, 0, r.stderr)
+        self.board_sync_py = DIST / "scripts/board-sync.py"
+        self.assertTrue(self.board_sync_py.exists(), "dist-kit/scripts/board-sync.py missing")
+
+        self.tmp = Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp, ignore_errors=True)
+
+        profile_md = ("<!-- board-sync:profile -->\n```json\n"
+                      + json.dumps(FIXTURE_PROFILE) + "\n```\n")
+        profile_path = self.tmp / "board-sync.md"
+        profile_path.write_text(profile_md, encoding="utf-8")
+
+        body_path = self.tmp / "prd-body.md"
+        body_path.write_text(GREEN_PRD, encoding="utf-8")
+
+        fake_gh_dir = self.tmp / "bin"
+        fake_gh_dir.mkdir()
+        gh_path = fake_gh_dir / "gh"
+        gh_path.write_text(FAKE_GH, encoding="utf-8")
+        gh_path.chmod(gh_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+        self.env = {
+            **os.environ,
+            "PATH": f"{fake_gh_dir}{os.pathsep}{os.environ.get('PATH', '')}",
+            "BOARD_SYNC_PROFILE": str(profile_path),
+            "DIST_KIT_SMOKE_BODY": str(body_path),
+        }
+
+    def test_validate_graph_runs_against_the_built_kit(self):
+        result = subprocess.run(
+            [sys.executable, str(self.board_sync_py), "validate-graph", "--issue", "42"],
+            capture_output=True, text=True, timeout=30, env=self.env,
+        )
+        self.assertEqual(result.returncode, 0,
+                          f"stdout={result.stdout!r} stderr={result.stderr!r}")
+        self.assertIn("Scope-Abdeckung 2 von 2", result.stdout)
+        self.assertIn("Rollup-Kette ✓", result.stdout)
+        self.assertIn("zyklenfrei ✓", result.stdout)
+        self.assertIn("Kapazität ✓", result.stdout)
+        self.assertIn("Phasen-Optionen ✓", result.stdout)
+
+    def test_no_german_status_vocabulary_ships(self):
+        """kit#26 / #1947 acceptance, verbatim: a fresh consumer install must
+        grep clean for testreporter's German board-status names. The status
+        vocabulary lives ONLY in a board's own profile (fields.status.roles) —
+        shipped scripts, skills, and doc templates speak role language. This
+        greps the whole BUILT artefact, so any future spot the word-list
+        census or the command lint can't see (a bare status name carries no
+        German function word and no board-sync.py call) still fails here."""
+        import re
+        pat = re.compile(r"\bIn Arbeit\b|\bIdee\b")
+        hits = []
+        for path in sorted(DIST.rglob("*")):
+            if not path.is_file():
+                continue
+            try:
+                text = path.read_text(encoding="utf-8")
+            except (UnicodeDecodeError, PermissionError):
+                continue
+            for n, line in enumerate(text.splitlines(), 1):
+                if pat.search(line):
+                    hits.append(f"{path.relative_to(DIST)}:{n}: {line.strip()[:120]}")
+        self.assertEqual(hits, [],
+                         "German board-status vocabulary in the shipped kit — speak role "
+                         "language (fields.status.roles / --status-role) instead:\n"
+                         + "\n".join(hits))
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/scripts/test_kit_docs_language_census.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""dist-kit doc language census (#1953) — a coarse net over EVERY shipped
+`.md` file (docs/templates, README, SKILL.md bodies alike), not just
+`publish: true` skill bodies (that zero-tolerance census already exists in
+`test_skill_language_census.py`). This guard is a percentage smoke test: a
+kit doc is red once ≥10% of its lines carry German prose, so an
+English-speaking consumer never again silently gets a majority-German
+template the way `docs/agents/wave-anchor-template.md` shipped before this
+slice (23/100 lines German — the census #1953 was written to catch).
+
+Reuses `test_skill_language_census.py`'s wordlist + line-classification
+helpers (`_line_hits`, `strip_frontmatter`, the bilingual
+`<user-story-example lang="de">` block skip) rather than a parallel
+heuristic — same STRONG/WEAK wordlist, same allowlist exemptions (contract
+literals, `Welle <N>` title format, the inline `language-census: ok`
+marker).
+
+Two test classes:
+  - `RatioFixtures` — pure-function unit tests, no build. Proves the ratio
+    computation goes RED on an artificially-German fixture and GREEN on an
+    all-English one, independent of the real dist-kit build.
+  - `DistKitDocsCensus` — builds the REAL dist-kit (subprocess, like
+    `test_dist_kit_smoke.py`) and asserts every shipped `.md` file is under
+    the threshold.
+
+Run: python3 scripts/test_kit_docs_language_census.py
+"""
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+from test_skill_language_census import (
+    BILINGUAL_BLOCK_END,
+    BILINGUAL_BLOCK_START,
+    _line_hits,
+    strip_frontmatter,
+)
+
+REPO = Path(__file__).resolve().parent.parent
+DIST = REPO / "dist-kit"
+
+GERMAN_LINE_THRESHOLD_PCT = 10.0
+
+
+def german_line_ratio(text: str) -> tuple[int, int]:
+    """(german_hit_lines, total_lines) for a doc body — frontmatter stripped,
+    bilingual `<user-story-example lang="de">...</user-story-example>` blocks
+    skipped (same exemptions as the publish:true skill census)."""
+    body = strip_frontmatter(text)
+    lines = body.splitlines()
+    total = len(lines)
+    hits = 0
+    in_bilingual_de_block = False
+    for line in lines:
+        if BILINGUAL_BLOCK_START.search(line):
+            in_bilingual_de_block = True
+        if in_bilingual_de_block:
+            if BILINGUAL_BLOCK_END.search(line):
+                in_bilingual_de_block = False
+            continue
+        if _line_hits(line):
+            hits += 1
+    return hits, total
+
+
+def is_below_threshold(text: str) -> tuple[bool, float]:
+    """(clean, pct) — clean is False once pct >= GERMAN_LINE_THRESHOLD_PCT."""
+    hits, total = german_line_ratio(text)
+    if total == 0:
+        return True, 0.0
+    pct = hits / total * 100
+    return pct < GERMAN_LINE_THRESHOLD_PCT, pct
+
+
+class RatioFixtures(unittest.TestCase):
+    """Pure-function proof: the census heuristic actually catches German
+    prose (RED) and does not false-positive on clean English (GREEN) —
+    independent of whether dist-kit can be built in this environment."""
+
+    def test_mostly_german_doc_is_red(self):
+        # Mirrors the pre-translation wave-anchor-template.md shape: a title
+        # line + a handful of English structural lines + a majority of dense
+        # German prose paragraphs — comfortably over the 10% line threshold.
+        german_doc = "\n".join(
+            ["# Title", "", "## Section", ""]
+            + ["Diese Zeile beschreibt eine Änderung und ist auf Deutsch geschrieben."] * 3
+            + ["Der Anker wird für die Wellen-Planung genutzt und muss gepflegt werden."] * 3
+            + [""] * 14  # padding so German lines are a clear >10% share, not 100%
+        )
+        clean, pct = is_below_threshold(german_doc)
+        self.assertFalse(clean, f"expected RED (>= {GERMAN_LINE_THRESHOLD_PCT}%), got {pct:.1f}%")
+        self.assertGreaterEqual(pct, GERMAN_LINE_THRESHOLD_PCT)
+
+    def test_all_english_doc_is_green(self):
+        english_doc = "\n".join(
+            ["# Title", "", "## Section", "",
+             "This line describes a change and is written in English.",
+             "The anchor is used for wave planning and must be maintained.",
+             ""]
+        )
+        clean, pct = is_below_threshold(english_doc)
+        self.assertTrue(clean, f"expected GREEN (< {GERMAN_LINE_THRESHOLD_PCT}%), got {pct:.1f}%")
+
+    def test_frontmatter_excluded_from_ratio(self):
+        # A German `description:` inside frontmatter (legitimate — quotes a
+        # German trigger phrase) must not count toward the body ratio.
+        text = (
+            "---\n"
+            "name: x\n"
+            'description: Use when "lass uns das Board durchgehen und die Wellen planen".\n'
+            "---\n\n"
+            "This body is English only, nothing else in here at all.\n"
+        )
+        clean, pct = is_below_threshold(text)
+        self.assertTrue(clean, f"frontmatter leaked into ratio: {pct:.1f}%")
+
+    def test_exempt_marker_line_does_not_count_as_a_hit(self):
+        text = "\n".join(
+            ["# Title", "Dies ist deutsch und bleibt es.  <!-- language-census: ok -->"]
+            + ["English line."] * 10
+        )
+        clean, pct = is_below_threshold(text)
+        self.assertTrue(clean, f"exempt marker line still counted: {pct:.1f}%")
+
+
+def _build_dist_kit():
+    """Run the real build (subprocess), mirroring test_dist_kit_smoke.py.
+    Returns (CompletedProcess, skip_reason); skip_reason set only when node
+    itself is unavailable in this environment."""
+    build = REPO / "scripts/build-kit.mjs"
+    try:
+        r = subprocess.run(["node", str(build)], cwd=REPO,
+                            capture_output=True, text=True, timeout=120)
+    except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+        return None, str(e)
+    return r, None
+
+
+class DistKitDocsCensus(unittest.TestCase):
+    """Smoke test over the actually-shipped dist-kit/**/*.md — the ONLY
+    thing a consumer ever reads, so this is what must stay clean."""
+
+    @classmethod
+    def setUpClass(cls):
+        r, skip_reason = _build_dist_kit()
+        if skip_reason:
+            raise unittest.SkipTest(f"node/build unavailable: {skip_reason}")
+        if r.returncode != 0:
+            raise AssertionError(f"build-kit.mjs failed: {r.stderr}")
+        if not DIST.is_dir():
+            raise AssertionError("dist-kit/ missing after build")
+
+    def test_every_shipped_doc_is_under_the_german_line_threshold(self):
+        violations = []
+        checked = 0
+        for path in sorted(DIST.rglob("*.md")):
+            if not path.is_file():
+                continue
+            checked += 1
+            text = path.read_text(encoding="utf-8", errors="ignore")
+            clean, pct = is_below_threshold(text)
+            if not clean:
+                violations.append((str(path.relative_to(DIST)), pct))
+
+        self.assertGreater(checked, 0, "no dist-kit/**/*.md found — build produced nothing?")
+        msg = "\n".join(f"  {p}: {pct:.1f}% German lines" for p, pct in violations)
+        self.assertEqual(
+            violations, [],
+            f"Census: {checked - len(violations)} of {checked} shipped docs under "
+            f"{GERMAN_LINE_THRESHOLD_PCT}% German lines.\n\n"
+            "Translate the residual German prose (or, for a genuine intentional "
+            "literal, mark the line `<!-- language-census: ok -->`):\n" + msg,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)

package/scripts/test_skill_code_review_seed.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""code-review skill + its setup-workflow project-layer seed (Welle 49).
+
+Companion to test_skill_setup_workflow_seeds.py (not touched here — a sibling
+slice edits it concurrently). Pins the two machine-checkable parts specific to
+this skill:
+
+1. The seed template setup-workflow ships (`code-review.md`) is structurally
+   valid for the skill that reads it — same "structured-but-empty crust"
+   contract as the existing spec-self-critique / spec-completeness seeds.
+2. The sentinel-based idempotency rule applies to it the same way (reference
+   implementation duplicated locally so this file has no import-order
+   dependency on the sibling-owned test module).
+
+Run: python3 scripts/test_skill_code_review_seed.py
+"""
+import re
+import unittest
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent
+SETUP_WORKFLOW = REPO / ".claude/skills/setup-workflow"
+CODE_REVIEW = REPO / ".claude/skills/code-review"
+
+SENTINEL_RE = re.compile(
+    r"^<!--\s*setup-workflow:\s*state=(stub|filled|not-applicable)"
+    r"(?:;\s*mode=(github-projects-v2|none))?\s*-->\s*$"
+)
+
+
+class SeedTemplateValid(unittest.TestCase):
+    def test_code_review_seed_has_both_headings(self):
+        """The two structured-but-empty headings the `code-review` skill's
+        Standards axis expects to find once this file is filled."""
+        t = (SETUP_WORKFLOW / "code-review.md").read_text(encoding="utf-8")
+        self.assertIn("## Standards sources in this repo", t)
+        self.assertIn("## Adjacent review tooling", t)
+
+    def test_code_review_seed_is_generic(self):
+        """No project-coupled tokens in a template shipped to every consumer."""
+        t = (SETUP_WORKFLOW / "code-review.md").read_text(encoding="utf-8")
+        for token in ("Testreporter", "iKon85", "/home/"):
+            self.assertNotIn(token, t)
+        self.assertNotRegex(t, r"#\d{3,5}\b")
+        self.assertNotRegex(t, r"\bHR\d+\b")
+
+    def test_setup_workflow_skill_registers_the_seed(self):
+        """SKILL.md wires the target path + seed link into its Targets table
+        and process, so a reader (or the manifest-completeness lint's sibling
+        checks) can trace the seed from the skill body."""
+        skill = (SETUP_WORKFLOW / "SKILL.md").read_text(encoding="utf-8")
+        self.assertIn("docs/agents/code-review.md", skill)
+        self.assertIn("[code-review.md](./code-review.md)", skill)
+
+    def test_code_review_skill_names_its_project_layer_and_fallback(self):
+        """The skill states the project-layer path + the /setup-workflow
+        fallback (self-containment-lint's LookupContract pattern)."""
+        body = (CODE_REVIEW / "SKILL.md").read_text(encoding="utf-8")
+        self.assertIn("docs/agents/code-review.md", body)
+        self.assertIn("/setup-workflow", body)
+
+
+class FreshFillProducesValidSentinel(unittest.TestCase):
+    """Simulate the write step: prepend the documented sentinel to the seed
+    body and assert the result is a well-formed project-layer file."""
+
+    def test_prepended_sentinel_parses(self):
+        body = (SETUP_WORKFLOW / "code-review.md").read_text(encoding="utf-8")
+        written = "<!-- setup-workflow: state=filled -->\n" + body
+        self.assertRegex(written.splitlines()[0], SENTINEL_RE)
+
+
+class ManifestEntryValid(unittest.TestCase):
+    def test_code_review_is_own_generic_dual_surface_publish_true(self):
+        import json
+
+        manifest = json.loads(
+            (REPO / ".claude/skills/skill-manifest.json").read_text(encoding="utf-8")
+        )
+        entry = manifest["skills"].get("code-review")
+        self.assertIsNotNone(entry, "code-review missing from skill-manifest.json")
+        self.assertEqual(entry["class"], "generic")
+        self.assertIs(entry["publish"], True)
+        self.assertEqual(entry["provenance"], "own")
+        self.assertEqual(set(entry["surfaces"]), {"claude", "codex"})
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)