@ikon85/agent-workflow-kit 0.43.0 → 0.44.0

package/scripts/test_profile_globs.py

@@ -1,280 +0,0 @@
-#!/usr/bin/env python3
-"""One repository-relative glob dialect backs every consumer-profile glob."""
-
-import importlib.util
-import json
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parent.parent
-DIALECT_MODULE = REPO / "scripts/profile_globs.py"
-ADVISORIES_CORE = REPO / "scripts/workflow-advisories/core.py"
-LIFECYCLE_CORE = REPO / "scripts/worktree-lifecycle/core.py"
-
-
-def load(name, path):
-    spec = importlib.util.spec_from_file_location(name, path)
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def load_lifecycle_core():
-    module_dir = str(LIFECYCLE_CORE.parent)
-    if module_dir not in sys.path:
-        sys.path.insert(0, module_dir)
-    return load("profile_globs_lifecycle_core", LIFECYCLE_CORE)
-
-
-dialect = load("profile_globs_under_test", DIALECT_MODULE)
-
-
-class MatcherContract(unittest.TestCase):
-    """The documented dialect, exercised on the axes the contract names."""
-
-    def test_star_stays_inside_one_segment(self):
-        self.assertTrue(dialect.path_glob_matches("build.log", "*.log"))
-        self.assertFalse(dialect.path_glob_matches("logs/build.log", "*.log"))
-        self.assertTrue(dialect.path_glob_matches("logs/build.log", "logs/*.log"))
-        self.assertFalse(dialect.path_glob_matches("logs/a/build.log", "logs/*.log"))
-
-    def test_question_mark_matches_one_character_inside_one_segment(self):
-        self.assertTrue(dialect.path_glob_matches("a1.tmp", "a?.tmp"))
-        self.assertFalse(dialect.path_glob_matches("a/1.tmp", "a?1.tmp"))
-
-    def test_character_classes_stay_per_segment(self):
-        self.assertTrue(dialect.path_glob_matches("cache/7.tmp", "cache/[0-9].tmp"))
-        self.assertFalse(dialect.path_glob_matches("cache/x.tmp", "cache/[0-9].tmp"))
-        self.assertTrue(dialect.path_glob_matches("cache/x.tmp", "cache/[!0-9].tmp"))
-
-    def test_leading_globstar_covers_the_repository_root_and_nested_paths(self):
-        self.assertTrue(dialect.path_glob_matches("__pycache__/a.pyc", "**/__pycache__/**"))
-        self.assertTrue(dialect.path_glob_matches("src/__pycache__/a.pyc", "**/__pycache__/**"))
-        self.assertTrue(dialect.path_glob_matches("notes.md", "**/notes.md"))
-        self.assertTrue(dialect.path_glob_matches("a/b/notes.md", "**/notes.md"))
-
-    def test_directory_roots_match_every_depth_below_them(self):
-        self.assertTrue(dialect.path_glob_matches("dist-kit/a", "dist-kit/**"))
-        self.assertTrue(dialect.path_glob_matches("dist-kit/a/b", "dist-kit/**"))
-        self.assertTrue(dialect.path_glob_matches("dist-kit", "dist-kit/**"))
-        self.assertFalse(dialect.path_glob_matches("dist-kit/a/b", "dist-kit/*"))
-        self.assertFalse(dialect.path_glob_matches("dist-kitten/a", "dist-kit/**"))
-
-    def test_matching_is_case_sensitive_on_every_host(self):
-        self.assertTrue(dialect.path_glob_matches("PLAN.md", "PLAN.md"))
-        self.assertFalse(dialect.path_glob_matches("plan.md", "PLAN.md"))
-        self.assertFalse(dialect.path_glob_matches("Logs/a.log", "logs/*.log"))
-
-    def test_whole_path_must_match(self):
-        self.assertFalse(dialect.path_glob_matches("src/index.mjs", "src"))
-        self.assertFalse(dialect.path_glob_matches("src", "src/index.mjs"))
-
-
-class SharedMatcherContract(unittest.TestCase):
-    """Both shipped cores resolve to the one shared matcher, not a copy."""
-
-    def test_both_cores_share_one_matcher_object(self):
-        advisories = load("profile_globs_advisories_core", ADVISORIES_CORE)
-        lifecycle = load_lifecycle_core()
-        self.assertIs(advisories.path_glob_matches, lifecycle.path_glob_matches)
-
-    def test_the_shared_matcher_comes_from_the_shipped_dialect_module(self):
-        advisories = load("profile_globs_advisories_core", ADVISORIES_CORE)
-        shared = advisories.load_profile_globs()
-        self.assertEqual(Path(shared.__file__).resolve(), DIALECT_MODULE.resolve())
-        self.assertIs(advisories.path_glob_matches, shared.path_glob_matches)
-
-    def test_both_cores_name_the_same_shared_module(self):
-        advisories = load("profile_globs_advisories_core", ADVISORIES_CORE)
-        lifecycle = load_lifecycle_core()
-        self.assertEqual(
-            advisories.PROFILE_GLOBS_MODULE, lifecycle.PROFILE_GLOBS_MODULE,
-        )
-
-    def test_neither_core_keeps_a_second_matcher(self):
-        for core in (ADVISORIES_CORE, LIFECYCLE_CORE):
-            body = core.read_text(encoding="utf-8")
-            self.assertNotIn("fnmatch.fnmatch(", body)
-            self.assertNotIn("def path_glob_matches", body)
-
-
-class AdvisorySurfaceContract(unittest.TestCase):
-    """Advisory globs select the same paths the lifecycle globs would."""
-
-    def decision_for(self, globs, changed):
-        core = load("profile_globs_advisories_surface", ADVISORIES_CORE)
-        profile = {
-            "stopChecks": {
-                "surfaces": [{"globs": globs, "command": ["python3", "-c", "pass"]}],
-                "timeoutSeconds": 3,
-                "outputBudget": 300,
-            },
-        }
-        with tempfile.TemporaryDirectory() as root:
-            return core.stop_check_decision(
-                profile, {"changed_files": changed}, Path(root),
-            )
-
-    def test_single_segment_glob_no_longer_crosses_a_directory(self):
-        self.assertIsNone(self.decision_for(["*.py"], ["pkg/mod.py"]).context)
-        self.assertIsNotNone(self.decision_for(["*.py"], ["mod.py"]).context)
-
-    def test_globstar_covers_root_and_nested_paths(self):
-        self.assertIsNotNone(self.decision_for(["**/*.py"], ["pkg/mod.py"]).context)
-        self.assertIsNotNone(self.decision_for(["**/*.py"], ["mod.py"]).context)
-
-    def test_directory_root_glob_covers_every_depth(self):
-        self.assertIsNotNone(self.decision_for(["src/**"], ["src/a/b.mjs"]).context)
-        self.assertIsNone(self.decision_for(["src/*"], ["src/a/b.mjs"]).context)
-
-    def test_advisory_matching_is_case_sensitive(self):
-        self.assertIsNone(self.decision_for(["src/**"], ["SRC/a.mjs"]).context)
-
-
-class MigrationClassifier(unittest.TestCase):
-    """Legacy patterns whose match set changes are named, never rewritten."""
-
-    def test_literal_pattern_is_stable(self):
-        self.assertEqual(dialect.classify_pattern("PLAN.md").effects, ())
-
-    def test_single_segment_wildcard_narrows(self):
-        migration = dialect.classify_pattern("*.log")
-        self.assertIn(dialect.NARROWS, migration.effects)
-        self.assertIn("/", migration.witnesses[dialect.NARROWS])
-
-    def test_nested_wildcard_without_globstar_narrows(self):
-        self.assertIn(
-            dialect.NARROWS, dialect.classify_pattern("dist-kit/*").effects,
-        )
-
-    def test_leading_globstar_widens_at_the_repository_root(self):
-        migration = dialect.classify_pattern("**/__pycache__/**")
-        self.assertIn(dialect.WIDENS, migration.effects)
-        self.assertEqual(migration.witnesses[dialect.WIDENS], "__pycache__")
-
-    def test_directory_root_globstar_widens_onto_the_directory_itself(self):
-        migration = dialect.classify_pattern("dist-kit/**")
-        self.assertIn(dialect.WIDENS, migration.effects)
-        self.assertEqual(migration.witnesses[dialect.WIDENS], "dist-kit")
-
-    def test_bare_globstar_is_stable(self):
-        self.assertEqual(dialect.classify_pattern("**").effects, ())
-
-    def test_character_class_pattern_is_stable(self):
-        self.assertEqual(dialect.classify_pattern("cache/[0-9].tmp").effects, ())
-
-    def test_case_effect_only_applies_to_the_case_normalizing_legacy(self):
-        insensitive = dialect.classify_pattern("PLAN.md", case_insensitive_legacy=True)
-        self.assertIn(dialect.CASE_NARROWS, insensitive.effects)
-        self.assertEqual(dialect.classify_pattern("PLAN.md").effects, ())
-
-
-class ProfileScan(unittest.TestCase):
-    """Every shipped consumer-profile glob key is reachable from one scan."""
-
-    document = {
-        "worktreeLifecycle": {"scratchPatterns": ["PLAN.md", "*.log"]},
-        "wrapup": {"landingGeneratedArtifactPatterns": ["dist-kit/**"]},
-        "workflowAdvisories": {
-            "baseline": {"sourceGlobs": ["src/**"]},
-            "preRefactor": {"surfaces": [{"globs": ["frontend/*"]}]},
-            "stopChecks": {"surfaces": [{"globs": ["backend/**"]}]},
-        },
-    }
-
-    def locations(self):
-        return [finding.location for finding in dialect.scan_profile(self.document)]
-
-    def test_scan_reaches_every_shipped_glob_key(self):
-        self.assertEqual(self.locations(), [
-            "worktreeLifecycle.scratchPatterns[0]",
-            "worktreeLifecycle.scratchPatterns[1]",
-            "wrapup.landingGeneratedArtifactPatterns[0]",
-            "workflowAdvisories.baseline.sourceGlobs[0]",
-            "workflowAdvisories.preRefactor.surfaces[0].globs[0]",
-            "workflowAdvisories.stopChecks.surfaces[0].globs[0]",
-        ])
-
-    def test_cleanup_keys_are_marked_as_deletion_authority(self):
-        authority = {
-            finding.location: finding.deletion_authority
-            for finding in dialect.scan_profile(self.document)
-        }
-        self.assertTrue(authority["worktreeLifecycle.scratchPatterns[0]"])
-        self.assertTrue(authority["wrapup.landingGeneratedArtifactPatterns[0]"])
-        self.assertFalse(authority["workflowAdvisories.baseline.sourceGlobs[0]"])
-
-    def test_advisory_globs_carry_the_case_normalizing_legacy(self):
-        legacy = {
-            finding.location: finding.migration.effects
-            for finding in dialect.scan_profile(self.document)
-        }
-        self.assertIn(
-            dialect.CASE_NARROWS,
-            legacy["workflowAdvisories.baseline.sourceGlobs[0]"],
-        )
-        self.assertNotIn(
-            dialect.CASE_NARROWS,
-            legacy["worktreeLifecycle.scratchPatterns[0]"],
-        )
-
-    def test_malformed_sections_are_skipped_without_raising(self):
-        self.assertEqual(dialect.scan_profile({"worktreeLifecycle": []}), ())
-        self.assertEqual(dialect.scan_profile("not a profile"), ())
-
-
-class MigrationReport(unittest.TestCase):
-    """The review command reports; it never edits the consumer profile."""
-
-    def run_check(self, document, *args):
-        with tempfile.TemporaryDirectory() as root:
-            path = Path(root) / "workflow-capabilities.json"
-            body = json.dumps(document, indent=2) + "\n"
-            path.write_text(body, encoding="utf-8")
-            result = subprocess.run(
-                [sys.executable, str(DIALECT_MODULE), str(path), *args],
-                capture_output=True, text=True,
-            )
-            self.assertEqual(path.read_text(encoding="utf-8"), body)
-            return result
-
-    def test_stable_profile_exits_zero(self):
-        result = self.run_check({
-            "worktreeLifecycle": {"scratchPatterns": ["PLAN.md"]},
-        })
-        self.assertEqual(result.returncode, 0, result.stderr)
-
-    def test_changed_pattern_exits_one_and_names_witness_and_authority(self):
-        result = self.run_check({
-            "wrapup": {"landingGeneratedArtifactPatterns": ["**/__pycache__/**"]},
-        })
-        self.assertEqual(result.returncode, 1, result.stderr)
-        self.assertIn("wrapup.landingGeneratedArtifactPatterns[0]", result.stdout)
-        self.assertIn(dialect.WIDENS, result.stdout)
-        self.assertIn("__pycache__", result.stdout)
-        self.assertIn("deletion authority", result.stdout)
-
-    def test_json_output_is_machine_readable(self):
-        result = self.run_check(
-            {"worktreeLifecycle": {"scratchPatterns": ["*.log"]}}, "--json",
-        )
-        report = json.loads(result.stdout)
-        self.assertEqual(report["reviewed"], 1)
-        self.assertEqual(report["changed"], 1)
-        self.assertEqual(report["findings"][0]["effects"], [dialect.NARROWS])
-
-    def test_unreadable_profile_exits_two(self):
-        result = subprocess.run(
-            [sys.executable, str(DIALECT_MODULE), "does/not/exist.json"],
-            capture_output=True, text=True,
-        )
-        self.assertEqual(result.returncode, 2)
-        self.assertNotEqual(result.stderr.strip(), "")
-
-
-if __name__ == "__main__":
-    unittest.main()

package/scripts/test_program_planning_contract.py

@@ -1,133 +0,0 @@
-"""Contract tests for the user-visible Program planning route."""
-
-from pathlib import Path
-import unittest
-
-
-ROOT = Path(__file__).resolve().parents[1]
-
-
-class ProgramPlanningContractTest(unittest.TestCase):
-    def skill(self, name: str) -> str:
-        return (ROOT / ".claude" / "skills" / name / "SKILL.md").read_text()
-
-    def file(self, path: str) -> str:
-        return (ROOT / path).read_text()
-
-    def test_to_issues_is_the_public_planning_facade(self):
-        text = self.skill("to-issues")
-        self.assertIn("single public Planning facade", text)
-        self.assertIn("planning-mode=feature", text)
-        self.assertIn("planning-mode=program", text)
-        self.assertIn("Missing or contradictory identity", text)
-        self.assertIn("Size, prose, and model judgment never select the mode", text)
-
-    def test_program_identity_delegates_to_the_internal_graph_engine(self):
-        issues = self.skill("to-issues")
-        waves = self.skill("to-waves")
-        self.assertIn("delegate to the internal", issues)
-        self.assertIn("`to-waves` graph engine", issues)
-        self.assertIn("complete Program preview", issues)
-        self.assertIn("Internal Program graph engine", waves)
-        self.assertIn("compatibility entrypoint", waves)
-        self.assertIn("carries both", waves)
-        self.assertIn("never infer Program mode", waves)
-
-    def test_feature_identity_keeps_the_existing_decomposition_path(self):
-        text = self.skill("to-issues")
-        self.assertIn("Feature identity", text)
-        self.assertIn("PROMOTE", text)
-        self.assertIn("ATOMIC", text)
-
-    def test_normal_routes_name_only_the_planning_facade(self):
-        route_files = (
-            ".claude/skills/ask-matt/SKILL.md",
-            ".claude/skills/scale-check/SKILL.md",
-            ".claude/skills/setup-workflow/workflow-overview.md",
-            ".claude/skills/board-to-waves/SKILL.md",
-            "CLAUDE.md",
-            "README.md",
-            "docs/workflow.html",
-            "docs/methodology.html",
-            "docs/methodology.svg",
-        )
-        for path in route_files:
-            with self.subTest(path=path):
-                text = self.file(path)
-                self.assertIn("to-issues", text)
-                self.assertNotIn("→ `to-waves`", text)
-                self.assertNotIn("→ to-waves", text)
-
-    def test_dual_surface_planning_skills_are_coherent(self):
-        skill_snippets = (
-            ("to-issues", "single public Planning facade"),
-            ("to-waves", "Internal Program graph engine"),
-            ("ask-matt", "the user never chooses that engine"),
-            ("scale-check", "explicit Program identity selects the internal graph path"),
-            ("setup-workflow", "explicit Program identity"),
-            ("board-to-waves", "not directly to a hidden engine"),
-        )
-        for skill, snippet in skill_snippets:
-            with self.subTest(skill=skill):
-                claude = self.file(f".claude/skills/{skill}/SKILL.md")
-                codex = self.file(f".agents/skills/{skill}/SKILL.md")
-                self.assertIn(snippet, claude)
-                self.assertIn(snippet, codex)
-
-        support_files = ("workflow-overview.md", "board-sync.md")
-        for name in support_files:
-            with self.subTest(support=name):
-                claude = self.file(f".claude/skills/setup-workflow/{name}")
-                codex = self.file(f".agents/skills/setup-workflow/{name}")
-                self.assertEqual(claude, codex)
-
-    def test_to_waves_finishes_with_every_wave_execute_ready_by_default(self):
-        text = self.skill("to-waves")
-        self.assertIn("## 7. Program completion contract", text)
-        self.assertIn("every published wave", text)
-        self.assertIn("execute-ready-check.py", text)
-        self.assertIn("X von Y Wellen ausführungsreif", text)
-
-    def test_program_preview_is_the_single_default_user_gate(self):
-        text = self.skill("to-waves")
-        self.assertIn("single user approval", text)
-        self.assertIn("do not ask for another per-wave approval", text)
-
-    def test_unresolved_work_is_modeled_as_an_explicit_gate_not_generic_late_binding(self):
-        text = self.skill("to-waves")
-        self.assertIn("Decision Gate", text)
-        self.assertIn("Verify Spike", text)
-        self.assertIn("Design-Grill", text)
-        self.assertIn("Late Binding is not the default", text)
-
-    def test_to_issues_supports_program_batch_and_keeps_human_actions_out_of_afk(self):
-        text = self.skill("to-issues")
-        self.assertIn("Program batch handoff", text)
-        self.assertIn("A mandatory human or external setup action is never AFK", text)
-
-    def test_atomic_program_wave_preserves_its_program_identity(self):
-        text = self.skill("to-issues")
-        self.assertIn("Program-batch atomic exception", text)
-        self.assertIn("preserve its existing Wave and Phase", text)
-
-    def test_atomic_program_wave_never_leaves_a_preliminary_child(self):
-        waves = self.skill("to-waves")
-        issues = self.skill("to-issues")
-        self.assertIn("do not create a preliminary child", waves)
-        self.assertIn("legacy or interrupted preliminary child", issues)
-        self.assertIn("superseded by atomic wave leaf", issues)
-        self.assertIn("Atomic supersession", waves)
-        self.assertIn("matching source marker remains discoverable after unlink", issues)
-
-    def test_program_completion_treats_audit_findings_as_blocking(self):
-        text = self.skill("to-waves")
-        self.assertIn("Program completion gate", text)
-        self.assertIn("do not count that wave as matured", text)
-
-    def test_public_program_route_promises_execute_ready_waves(self):
-        text = self.skill("scale-check")
-        self.assertIn("all waves execute-ready by default", text)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/scripts/test_release_authorization_contract.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""Release-authorization contract (#257).
-
-The confirmed Semver authorizes the whole release, through tag and publish.
-One human gate at version choice, not two — the second gate stalled every
-release at `awaiting-tag` until someone returned, which is how 0.34.2 was
-skipped and buried under 0.34.3 (#243).
-
-What this pins:
-
-- Both `kit-release` surfaces carry the carried-through authorization, and
-  neither demands a separate confirmation before tagging.
-- The safety framing survives the change: irreversibility and the pre-tag
-  gates stay named, so autonomy never reads as "tag whatever".
-- `CLAUDE.md`, `AGENTS.md` and ADR-0004 agree with the skill.
-
-Run: python3 scripts/test_release_authorization_contract.py
-"""
-from __future__ import annotations
-
-import unittest
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parents[1]
-SURFACES = (".claude/skills/kit-release/SKILL.md", ".agents/skills/kit-release/SKILL.md")
-ADR = "docs/adr/0004-release-intent-is-a-version-tag.md"
-DOCTRINE_FILES = ("CLAUDE.md", "AGENTS.md")
-# Wording that would reinstate the second gate anywhere in the release surface.
-SECOND_GATE = (
-    "separate explicit confirmation",
-    "separately confirmed publication intent",
-    "obtain a separate",
-    "After that confirmation",
-)
-
-
-def read(relative: str) -> str:
-    return (ROOT / relative).read_text(encoding="utf-8")
-
-
-def normalized(relative: str) -> str:
-    return " ".join(read(relative).split())
-
-
-class SkillSurfaceContract(unittest.TestCase):
-    def test_both_surfaces_carry_the_authorization_through_to_the_tag(self):
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                prose = normalized(surface)
-                self.assertIn("confirmed Semver authorizes", prose)
-                self.assertIn("tag and publish", prose)
-                self.assertIn("without asking again", prose)
-
-    def test_no_surface_reinstates_a_second_confirmation_gate(self):
-        for surface in SURFACES:
-            for phrase in SECOND_GATE:
-                with self.subTest(surface=surface, phrase=phrase):
-                    self.assertNotIn(phrase, normalized(surface))
-
-    def test_autonomy_never_drops_the_safety_framing(self):
-        """Tagging stays irreversible and gated — the gates just move earlier."""
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                prose = normalized(surface)
-                self.assertIn("irreversible", prose)
-                self.assertIn("cannot be reused", prose)
-                for gate in ("release:guard", "kit:staleness", "npm pack"):
-                    self.assertIn(gate, prose)
-
-    def test_the_tag_remains_the_sole_publication_intent(self):
-        for surface in SURFACES:
-            with self.subTest(surface=surface):
-                prose = normalized(surface)
-                self.assertIn("Merging integrates", prose)
-                self.assertIn("annotated", prose)
-
-    def test_both_surfaces_stay_mirrored_below_the_frontmatter(self):
-        bodies = [read(surface).split("\n---\n", 1)[1] for surface in SURFACES]
-        self.assertEqual(bodies[0], bodies[1])
-
-
-class ProjectDoctrineContract(unittest.TestCase):
-    def test_root_convention_files_agree_with_the_skill(self):
-        for name in DOCTRINE_FILES:
-            with self.subTest(document=name):
-                prose = normalized(name)
-                self.assertIn("confirmed Semver authorizes", prose)
-                for phrase in SECOND_GATE:
-                    self.assertNotIn(phrase, prose)
-
-    def test_the_adr_records_an_amendment_instead_of_a_silent_rewrite(self):
-        prose = normalized(ADR)
-        self.assertIn("Amended", prose)
-        self.assertIn("2026-07-25", prose)
-        self.assertIn("confirmed Semver authorizes", prose)
-        # The original decision must remain readable, not be overwritten.
-        self.assertIn("version tag", prose)
-
-
-if __name__ == "__main__":
-    unittest.main()