test_artifacts_meta.py

"""Tests for artifacts_meta module."""

import json
import sys
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory

sys.path.insert(0, str(Path(__file__).parent.parent / "skills" / "cypilot" / "scripts"))

from cypilot.utils.artifacts_meta import (
    Artifact,
    ArtifactsMeta,
    AutodetectRule,
    CodebaseEntry,
    IgnoreBlock,
    Kit,
    SystemNode,
    create_backup,
    generate_default_registry,
    load_artifacts_meta,
)


class TestKit(unittest.TestCase):
    def test_kit_from_dict(self):
        data = {"format": "Cypilot", "path": "templates"}
        kit = Kit.from_dict("test-kit", data)
        self.assertEqual(kit.kit_id, "test-kit")
        self.assertEqual(kit.format, "Cypilot")
        self.assertEqual(kit.path, "templates")

    def test_kit_is_cypilot_format(self):
        kit = Kit("id", "Cypilot", "path")
        self.assertTrue(kit.is_cypilot_format())
        kit2 = Kit("id", "OTHER", "path")
        self.assertFalse(kit2.is_cypilot_format())

    def test_kit_get_template_path(self):
        kit = Kit("id", "Cypilot", "kits/sdlc")
        self.assertEqual(kit.get_template_path("PRD"), "kits/sdlc/artifacts/PRD/template.md")
        self.assertEqual(kit.get_template_path("UNKNOWN"), "kits/sdlc/artifacts/UNKNOWN/template.md")


class TestArtifact(unittest.TestCase):
    def test_artifact_from_dict(self):
        data = {"path": "docs/PRD.md", "kind": "PRD", "traceability": "FULL", "name": "Product Requirements"}
        artifact = Artifact.from_dict(data)
        self.assertEqual(artifact.path, "docs/PRD.md")
        self.assertEqual(artifact.kind, "PRD")
        self.assertEqual(artifact.traceability, "FULL")
        self.assertEqual(artifact.name, "Product Requirements")

    def test_artifact_type_backward_compat(self):
        """Cover line 64: backward compat property 'type'."""
        artifact = Artifact(path="a.md", kind="PRD", traceability="DOCS-ONLY")
        self.assertEqual(artifact.type, "PRD")

    def test_artifact_from_dict_legacy_type_key(self):
        """Cover backward compat for 'type' key instead of 'kind'."""
        data = {"path": "docs/PRD.md", "type": "PRD"}
        artifact = Artifact.from_dict(data)
        self.assertEqual(artifact.kind, "PRD")


class TestCodebaseEntry(unittest.TestCase):
    def test_codebase_entry_from_dict(self):
        data = {"path": "src/", "extensions": [".py", ".js"], "name": "Source"}
        entry = CodebaseEntry.from_dict(data)
        self.assertEqual(entry.path, "src/")
        self.assertEqual(entry.extensions, [".py", ".js"])
        self.assertEqual(entry.name, "Source")

    def test_codebase_entry_extensions_not_list(self):
        """Cover line 91: extensions not a list."""
        data = {"path": "src/", "extensions": "not-a-list"}
        entry = CodebaseEntry.from_dict(data)
        self.assertEqual(entry.extensions, [])


class TestSystemNode(unittest.TestCase):
    def test_system_node_from_dict_basic(self):
        data = {
            "name": "MySystem",
            "kit": "cypilot-sdlc",
            "artifacts": [{"path": "PRD.md", "kind": "PRD"}],
            "codebase": [{"path": "src/", "extensions": [".py"]}],
        }
        node = SystemNode.from_dict(data)
        self.assertEqual(node.name, "MySystem")
        self.assertEqual(node.kit, "cypilot-sdlc")
        self.assertEqual(len(node.artifacts), 1)
        self.assertEqual(len(node.codebase), 1)

    def test_system_node_with_children(self):
        """Cover lines 135-136: parsing children."""
        data = {
            "name": "Parent",
            "kit": "cypilot",
            "children": [
                {"name": "Child1", "kit": "cypilot"},
                {"name": "Child2", "kit": "cypilot"},
            ],
        }
        node = SystemNode.from_dict(data)
        self.assertEqual(len(node.children), 2)
        self.assertEqual(node.children[0].name, "Child1")
        self.assertEqual(node.children[0].parent, node)


class TestArtifactsMeta(unittest.TestCase):
    def test_from_dict_basic(self):
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {"cypilot": {"format": "Cypilot", "path": "templates"}},
            "systems": [{"name": "Test", "kit": "cypilot", "artifacts": [{"path": "PRD.md", "kind": "PRD"}]}],
        }
        meta = ArtifactsMeta.from_dict(data)
        self.assertEqual(meta.version, "1.0")
        self.assertEqual(meta.project_root, "..")
        self.assertEqual(len(meta.kits), 1)
        self.assertEqual(len(meta.systems), 1)

    def test_get_artifact_by_path(self):
        """Cover lines 241-242: get_artifact_by_path method."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {"cypilot": {"format": "Cypilot", "path": "templates"}},
            "systems": [{"name": "Test", "kit": "cypilot", "artifacts": [{"path": "architecture/PRD.md", "kind": "PRD"}]}],
        }
        meta = ArtifactsMeta.from_dict(data)
        result = meta.get_artifact_by_path("architecture/PRD.md")
        self.assertIsNotNone(result)
        artifact, system = result
        self.assertEqual(artifact.kind, "PRD")
        self.assertEqual(system.name, "Test")

    def test_get_artifact_by_path_not_found(self):
        data = {"version": "1.0", "project_root": "..", "kits": {}, "systems": []}
        meta = ArtifactsMeta.from_dict(data)
        result = meta.get_artifact_by_path("nonexistent.md")
        self.assertIsNone(result)

    def test_get_artifact_by_path_normalize_dot_slash(self):
        """Cover line 189: normalize paths starting with './'."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [{"name": "Test", "kit": "", "artifacts": [{"path": "./PRD.md", "kind": "PRD"}]}],
        }
        meta = ArtifactsMeta.from_dict(data)
        result = meta.get_artifact_by_path("PRD.md")
        self.assertIsNotNone(result)

    def test_iter_all_artifacts(self):
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [{"name": "Test", "kit": "", "artifacts": [{"path": "a.md", "kind": "A"}, {"path": "b.md", "kind": "B"}]}],
        }
        meta = ArtifactsMeta.from_dict(data)
        artifacts = list(meta.iter_all_artifacts())
        self.assertEqual(len(artifacts), 2)

    def test_root_ignore_filters_index_and_codebase(self):
        data = {
            "version": "1.1",
            "project_root": "..",
            "kits": {},
            "ignore": [{"reason": "hide", "patterns": ["secret/*", "src/ignored/*"]}],
            "systems": [
                {
                    "name": "Test",
                    "kit": "",
                    "artifacts": [
                        {"path": "secret/a.md", "kind": "A"},
                        {"path": "public/b.md", "kind": "B"},
                    ],
                    "codebase": [
                        {"path": "src/ignored", "extensions": [".py"]},
                        {"path": "src/ok", "extensions": [".py"]},
                    ],
                }
            ],
        }
        meta = ArtifactsMeta.from_dict(data)
        # Ignored artifact is not indexed
        self.assertIsNone(meta.get_artifact_by_path("secret/a.md"))
        self.assertIsNotNone(meta.get_artifact_by_path("public/b.md"))
        # Ignored codebase entry is not iterated
        codebase_paths = [cb.path for cb, _ in meta.iter_all_codebase()]
        self.assertNotIn("src/ignored", codebase_paths)
        self.assertIn("src/ok", codebase_paths)

    def test_autodetect_system_root_without_system_placeholder(self):
        """system_root may omit {system}; still uses node.slug for other placeholders."""
        with TemporaryDirectory() as tmpdir:
            root = Path(tmpdir)
            # Create: <root>/subsystems/docs/PRD.md
            (root / "subsystems" / "docs").mkdir(parents=True)
            (root / "subsystems" / "docs" / "PRD.md").write_text("x", encoding="utf-8")

            data = {
                "version": "1.1",
                "project_root": "..",
                "kits": {"k": {"format": "Cypilot", "path": "kits/sdlc"}},
                "systems": [
                    {
                        "name": "App",
                        "slug": "app",
                        "kit": "k",
                        "autodetect": [
                            {
                                "system_root": "{project_root}/subsystems",
                                "artifacts_root": "{system_root}/docs",
                                "artifacts": {"PRD": {"pattern": "PRD.md", "traceability": "FULL"}},
                                "codebase": [{"path": "tests/{system}", "extensions": [".py"]}],
                            }
                        ],
                    }
                ],
            }
            meta = ArtifactsMeta.from_dict(data)
            errs = meta.expand_autodetect(adapter_dir=root, project_root=root, is_kind_registered=lambda kit_id, kind: True)
            self.assertEqual(errs, [])
            # Autodetected artifact should exist in meta index
            self.assertIsNotNone(meta.get_artifact_by_path("subsystems/docs/PRD.md"))
            # Codebase path should include tests/app
            cb_paths = [cb.path for cb, _ in meta.iter_all_codebase()]
            self.assertIn("tests/app", cb_paths)

    def test_autodetect_fail_on_unmatched_markdown(self):
        with TemporaryDirectory() as tmpdir:
            root = Path(tmpdir)
            (root / "subsystems" / "docs").mkdir(parents=True)
            (root / "subsystems" / "docs" / "PRD.md").write_text("x", encoding="utf-8")
            (root / "subsystems" / "docs" / "extra.md").write_text("x", encoding="utf-8")

            data = {
                "version": "1.1",
                "project_root": "..",
                "kits": {"k": {"format": "Cypilot", "path": "kits/sdlc"}},
                "systems": [
                    {
                        "name": "App",
                        "slug": "app",
                        "kit": "k",
                        "autodetect": [
                            {
                                "system_root": "{project_root}/subsystems",
                                "artifacts_root": "{system_root}/docs",
                                "artifacts": {"PRD": {"pattern": "PRD.md", "traceability": "FULL"}},
                                "validation": {"fail_on_unmatched_markdown": True},
                            }
                        ],
                    }
                ],
            }
            meta = ArtifactsMeta.from_dict(data)
            errs = meta.expand_autodetect(adapter_dir=root, project_root=root, is_kind_registered=lambda kit_id, kind: True)
            self.assertTrue(any("Unmatched markdown" in str(e) for e in errs))

    def test_autodetect_dynamic_child_systems_from_system_root_dollar_system(self):
        with TemporaryDirectory() as tmpdir:
            root = Path(tmpdir)
            # Create two module systems under modules/<name>/architecture/PRD.md
            for mod in ["LLM Gateway", "api-server"]:
                (root / "modules" / mod / "architecture").mkdir(parents=True)
                (root / "modules" / mod / "architecture" / "PRD.md").write_text("x", encoding="utf-8")

            data = {
                "version": "1.1",
                "project_root": "..",
                "kits": {"k": {"format": "Cypilot", "path": "kits/sdlc"}},
                "systems": [
                    {
                        "name": "Fabric",
                        "slug": "fabric",
                        "kit": "k",
                        "autodetect": [
                            {
                                "system_root": "{project_root}/modules/$system",
                                "artifacts_root": "{system_root}/architecture",
                                "artifacts": {"PRD": {"pattern": "PRD.md", "traceability": "FULL"}},
                            }
                        ],
                    }
                ],
            }

            meta = ArtifactsMeta.from_dict(data)
            errs = meta.expand_autodetect(adapter_dir=root, project_root=root, is_kind_registered=lambda kit_id, kind: True)
            self.assertEqual(errs, [])

            # Child systems should have been created and prefixes should include parent
            prefixes = meta.get_all_system_prefixes()
            self.assertIn("fabric-llm-gateway", prefixes)
            self.assertIn("fabric-api-server", prefixes)

            # Discovered PRDs should be attributed to the child systems
            prd1 = meta.get_artifact_by_path("modules/LLM Gateway/architecture/PRD.md")
            self.assertIsNotNone(prd1)
            _a1, sys1 = prd1
            self.assertEqual(sys1.get_hierarchy_prefix(), "fabric-llm-gateway")

            prd2 = meta.get_artifact_by_path("modules/api-server/architecture/PRD.md")
            self.assertIsNotNone(prd2)
            _a2, sys2 = prd2
            self.assertEqual(sys2.get_hierarchy_prefix(), "fabric-api-server")

    def test_index_system_with_nested_children(self):
        """Cover lines 182: recursing into children during indexing."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [
                {
                    "name": "Parent",
                    "kit": "",
                    "artifacts": [{"path": "parent.md", "kind": "P"}],
                    "children": [
                        {
                            "name": "Child",
                            "kit": "",
                            "artifacts": [{"path": "child.md", "kind": "C"}],
                        }
                    ],
                }
            ],
        }
        meta = ArtifactsMeta.from_dict(data)
        # Both parent and child artifacts should be indexed
        parent_result = meta.get_artifact_by_path("parent.md")
        child_result = meta.get_artifact_by_path("child.md")
        self.assertIsNotNone(parent_result)
        self.assertIsNotNone(child_result)

    def test_iter_all_system_names(self):
        """Cover iter_all_system_names method with nested systems."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [
                {
                    "name": "myapp",
                    "kit": "",
                    "children": [
                        {"name": "account-server", "kit": ""},
                        {"name": "billing", "kit": "", "children": [{"name": "invoicing", "kit": ""}]},
                    ],
                },
                {"name": "other-system", "kit": ""},
            ],
        }
        meta = ArtifactsMeta.from_dict(data)
        def _all_names(systems):
            for s in systems:
                if s.name:
                    yield s.name
                yield from _all_names(s.children)
        names = list(_all_names(meta.systems))
        self.assertIn("myapp", names)
        self.assertIn("account-server", names)
        self.assertIn("billing", names)
        self.assertIn("invoicing", names)
        self.assertIn("other-system", names)
        self.assertEqual(len(names), 5)

    def test_get_all_system_names(self):
        """Cover get_all_system_names method returns lowercase set."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [
                {"name": "MyApp", "kit": ""},
                {"name": "Account-Server", "kit": ""},
            ],
        }
        meta = ArtifactsMeta.from_dict(data)
        def _all_names(systems):
            for s in systems:
                if s.name:
                    yield s.name
                yield from _all_names(s.children)
        names = {str(n).lower() for n in _all_names(meta.systems)}
        self.assertIsInstance(names, set)
        self.assertIn("myapp", names)
        self.assertIn("account-server", names)
        # Original case should NOT be in the set
        self.assertNotIn("MyApp", names)
        self.assertNotIn("Account-Server", names)


class TestLoadArtifactsMeta(unittest.TestCase):
    def test_load_artifacts_meta_success(self):
        """Cover lines 275-284: load_artifacts_meta success path."""
        with TemporaryDirectory() as tmpdir:
            ad = Path(tmpdir)
            data = {"version": "1.0", "project_root": "..", "kits": {}, "systems": []}
            (ad / "artifacts.json").write_text(json.dumps(data), encoding="utf-8")
            meta, err = load_artifacts_meta(ad)
            self.assertIsNotNone(meta)
            self.assertIsNone(err)

    def test_load_artifacts_meta_invalid_json(self):
        with TemporaryDirectory() as tmpdir:
            ad = Path(tmpdir)
            (ad / "artifacts.json").write_text("{invalid", encoding="utf-8")
            meta, err = load_artifacts_meta(ad)
            self.assertIsNone(meta)
            self.assertIsNotNone(err)

    def test_load_artifacts_meta_generic_exception(self):
        """Cover generic exception handling in load_artifacts_meta."""
        with TemporaryDirectory() as tmpdir:
            ad = Path(tmpdir)
            (ad / "artifacts.json").write_text('{"version": "1.0"}', encoding="utf-8")
            # This will fail because systems/artifacts are missing
            # Actually the from_dict handles missing gracefully, so let's force an error
            orig = ArtifactsMeta.from_dict

            def boom(data):
                raise ValueError("boom")

            try:
                ArtifactsMeta.from_dict = staticmethod(boom)
                meta, err = load_artifacts_meta(ad)
                self.assertIsNone(meta)
                self.assertIn("Failed to load", err)
            finally:
                ArtifactsMeta.from_dict = orig


class TestCreateBackup(unittest.TestCase):
    def test_create_backup_file(self):
        """Cover lines 296-313: create_backup for a file."""
        with TemporaryDirectory() as tmpdir:
            path = Path(tmpdir) / "test.json"
            path.write_text('{"key": "value"}', encoding="utf-8")
            backup = create_backup(path)
            self.assertIsNotNone(backup)
            self.assertTrue(backup.exists())
            self.assertIn(".backup", backup.name)
            self.assertEqual(backup.read_text(), '{"key": "value"}')

    def test_create_backup_directory(self):
        """Cover create_backup for a directory."""
        with TemporaryDirectory() as tmpdir:
            path = Path(tmpdir) / "mydir"
            path.mkdir()
            (path / "file.txt").write_text("content", encoding="utf-8")
            backup = create_backup(path)
            self.assertIsNotNone(backup)
            self.assertTrue(backup.is_dir())
            self.assertTrue((backup / "file.txt").exists())

    def test_create_backup_nonexistent_returns_none(self):
        with TemporaryDirectory() as tmpdir:
            path = Path(tmpdir) / "nonexistent"
            backup = create_backup(path)
            self.assertIsNone(backup)

    def test_create_backup_exception_returns_none(self):
        """Cover exception handling in create_backup."""
        with TemporaryDirectory() as tmpdir:
            path = Path(tmpdir) / "test.json"
            path.write_text("x", encoding="utf-8")

            import shutil
            orig = shutil.copy2

            def boom(*args, **kwargs):
                raise OSError("boom")

            try:
                shutil.copy2 = boom
                backup = create_backup(path)
                self.assertIsNone(backup)
            finally:
                shutil.copy2 = orig


class TestGenerateDefaultRegistry(unittest.TestCase):
    def test_generate_default_registry(self):
        result = generate_default_registry("MyProject")
        self.assertEqual(len(result["systems"]), 1)
        self.assertEqual(result["systems"][0]["name"], "MyProject")
        self.assertEqual(result["systems"][0]["kit"], "sdlc")

    def test_generate_default_registry_minimal(self):
        """Smoke test: generate_default_registry with minimal input."""
        data = {"version": "1.0", "project_root": "..", "kits": {}, "systems": []}
        meta = ArtifactsMeta.from_dict(data)
        self.assertEqual(meta.version, "1.0")
        self.assertEqual(meta.systems, [])


class TestSystemNodeHierarchy(unittest.TestCase):
    """Test SystemNode hierarchy methods."""

    def test_get_hierarchy_prefix(self):
        """Cover get_hierarchy_prefix method."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [
                {
                    "name": "Platform",
                    "slug": "platform",
                    "kit": "cypilot-sdlc",
                    "children": [
                        {
                            "name": "Core",
                            "slug": "core",
                            "kit": "cypilot-sdlc",
                            "children": [
                                {
                                    "name": "Auth",
                                    "slug": "auth",
                                    "kit": "cypilot-sdlc",
                                }
                            ],
                        }
                    ],
                }
            ],
        }
        meta = ArtifactsMeta.from_dict(data)
        # Find the auth node via direct traversal
        auth_node = meta.systems[0].children[0].children[0]
        self.assertEqual(auth_node.slug, "auth")
        self.assertEqual(auth_node.get_hierarchy_prefix(), "platform-core-auth")


class TestArtifactsMetaIterators(unittest.TestCase):
    """Test ArtifactsMeta iterator methods with nested children."""

    def test_iter_all_codebase_with_children(self):
        """Cover iter_all_codebase with nested system children."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [
                {
                    "name": "Parent",
                    "slug": "parent",
                    "kit": "cypilot-sdlc",
                    "codebase": [{"name": "Parent Code", "path": "src/parent"}],
                    "children": [
                        {
                            "name": "Child",
                            "slug": "child",
                            "kit": "cypilot-sdlc",
                            "codebase": [{"name": "Child Code", "path": "src/child"}],
                        }
                    ],
                }
            ],
        }
        meta = ArtifactsMeta.from_dict(data)
        codebase_entries = list(meta.iter_all_codebase())
        self.assertEqual(len(codebase_entries), 2)
        paths = [cb.path for cb, _ in codebase_entries]
        self.assertIn("src/parent", paths)
        self.assertIn("src/child", paths)

    def test_get_system_by_slug(self):
        """Cover system node traversal via direct access."""
        data = {
            "version": "1.0",
            "project_root": "..",
            "kits": {},
            "systems": [
                {
                    "name": "MyApp",
                    "slug": "myapp",
                    "kit": "cypilot-sdlc",
                    "children": [{"name": "Module", "slug": "module", "kit": "cypilot-sdlc"}],
                }
            ],
        }
        meta = ArtifactsMeta.from_dict(data)
        node = meta.systems[0].children[0]
        self.assertEqual(node.slug, "module")
        self.assertEqual(node.name, "Module")

class TestAutodetectRuleFromDict(unittest.TestCase):
    """Tests for AutodetectRule.from_dict edge cases."""

    def test_non_dict_aliases_and_validation_defaults(self):
        rule = AutodetectRule.from_dict({"aliases": "bad", "validation": 123})
        assert rule.aliases == {}
        assert rule.validation == {}

    def test_children_parsed(self):
        rule = AutodetectRule.from_dict({"children": [{"system_root": "sub"}]})
        assert len(rule.children) == 1
        assert rule.children[0].system_root == "sub"


class TestExtractSystemSlugCandidates(unittest.TestCase):
    """Tests for extract_system_slug_candidates."""

    def setUp(self):
        from cypilot.utils.artifacts_meta import extract_system_slug_candidates
        self.extract = extract_system_slug_candidates

    def test_non_cpt_id_returns_empty(self):
        assert self.extract("xyz-myapp-fr-login", "", {"fr"}) == []

    def test_parent_prefix_mismatch_returns_empty(self):
        assert self.extract("cpt-other-myapp-fr-login", "ex", {"fr"}) == []

    def test_no_kind_token_returns_empty(self):
        assert self.extract("cpt-myapp-something-else", "", {"fr"}) == []

    def test_multiple_distinct_kind_tokens_returns_empty(self):
        # ID contains both -fr- and -nfr- → ambiguous
        assert self.extract("cpt-myapp-fr-nfr-slug", "", {"fr", "nfr"}) == []

    def test_kind_at_position_zero_returns_empty(self):
        # remainder starts with kind token → empty system slug
        assert self.extract("cpt-fr-slug", "", {"fr"}) == []

    def test_normal_extraction(self):
        assert self.extract("cpt-myapp-fr-login", "", {"fr"}) == ["myapp"]

    def test_with_parent_prefix(self):
        assert self.extract("cpt-ex-myapp-fr-login", "ex", {"fr"}) == ["myapp"]

    def test_single_kind_multiple_occurrences(self):
        # Same kind token appears twice but only one distinct kind → first match
        result = self.extract("cpt-myapp-fr-some-fr-other", "", {"fr"})
        assert result == ["myapp"]


class TestResolvePipeline(unittest.TestCase):
    def _make_meta(self, artifacts):
        """Build an ArtifactsMeta with given artifacts in a single system."""
        arts = [Artifact(path=f"docs/{k}.md", kind=k, traceability="FULL") for k in artifacts]
        sys_node = SystemNode(name="app", slug="app", kit="sdlc", artifacts=arts, codebase=[], children=[])
        return ArtifactsMeta(version=1, project_root=".", kits={}, systems=[sys_node])

    def test_empty_system_recommends_prd(self):
        meta = self._make_meta([])
        result = meta.resolve_pipeline("app")
        self.assertEqual(result["recommendation"], "PRD")
        self.assertEqual(result["present"], [])
        self.assertEqual(result["missing"], ["PRD", "DESIGN", "ADR", "DECOMPOSITION", "FEATURE"])

    def test_prd_present_recommends_design(self):
        meta = self._make_meta(["PRD"])
        result = meta.resolve_pipeline("app")
        self.assertIn("PRD", result["present"])
        self.assertEqual(result["recommendation"], "DESIGN")

    def test_prd_design_present_recommends_adr(self):
        meta = self._make_meta(["PRD", "DESIGN"])
        result = meta.resolve_pipeline("app")
        self.assertEqual(result["recommendation"], "ADR")

    def test_all_present_recommends_code(self):
        meta = self._make_meta(["PRD", "DESIGN", "ADR", "DECOMPOSITION", "FEATURE"])
        result = meta.resolve_pipeline("app")
        self.assertEqual(result["recommendation"], "CODE")
        self.assertEqual(result["missing"], [])

    def test_gap_blocks_recommendation(self):
        # Only DESIGN present (no PRD) → PRD recommended first
        meta = self._make_meta(["DESIGN"])
        result = meta.resolve_pipeline("app")
        self.assertEqual(result["recommendation"], "PRD")

    def test_unknown_system_returns_all_missing(self):
        meta = self._make_meta(["PRD"])
        result = meta.resolve_pipeline("nonexistent")
        self.assertEqual(result["recommendation"], "PRD")
        self.assertEqual(result["present"], [])


class TestIterAllSystemPrefixes(unittest.TestCase):
    def test_single_system(self):
        sys_node = SystemNode(name="App", slug="app", kit="sdlc", artifacts=[], codebase=[], children=[])
        meta = ArtifactsMeta(version=1, project_root=".", kits={}, systems=[sys_node])
        prefixes = list(meta.iter_all_system_prefixes())
        self.assertEqual(prefixes, ["app"])

    def test_nested_systems(self):
        child = SystemNode(name="Sub", slug="sub", kit="sdlc", artifacts=[], codebase=[], children=[])
        parent = SystemNode(name="App", slug="app", kit="sdlc", artifacts=[], codebase=[], children=[child])
        child.parent = parent
        meta = ArtifactsMeta(version=1, project_root=".", kits={}, systems=[parent])
        prefixes = set(meta.iter_all_system_prefixes())
        self.assertIn("app", prefixes)
        self.assertIn("app-sub", prefixes)

    def test_get_all_system_prefixes_lowercased(self):
        sys_node = SystemNode(name="App", slug="MyApp", kit="sdlc", artifacts=[], codebase=[], children=[])
        meta = ArtifactsMeta(version=1, project_root=".", kits={}, systems=[sys_node])
        prefixes = meta.get_all_system_prefixes()
        self.assertIn("myapp", prefixes)


class TestLoadArtifactsMetaMissing(unittest.TestCase):
    def test_missing_registry_returns_error(self):
        with TemporaryDirectory() as d:
            adapter_dir = Path(d)
            result, err = load_artifacts_meta(adapter_dir)
            self.assertIsNone(result)
            self.assertIn("Missing artifacts registry", err)


class TestKitFromDictEdgeCases(unittest.TestCase):
    def test_invalid_artifact_kind_skipped(self):
        data = {
            "format": "Cypilot",
            "path": "templates",
            "artifacts": {
                "": {"template": "t.md", "examples": "e/"},
                "PRD": {"template": "prd.md", "examples": "examples/"},
            },
        }
        kit = Kit.from_dict("test", data)
        self.assertNotIn("", kit.artifacts)
        self.assertIn("PRD", kit.artifacts)

    def test_non_dict_artifact_spec_skipped(self):
        data = {
            "format": "Cypilot",
            "path": "templates",
            "artifacts": {
                "PRD": "not-a-dict",
                "DESIGN": {"template": "d.md", "examples": "ex/"},
            },
        }
        kit = Kit.from_dict("test", data)
        self.assertNotIn("PRD", kit.artifacts)
        self.assertIn("DESIGN", kit.artifacts)


class TestCheckChildSlugConsistency(unittest.TestCase):
    """Targeted tests for _check_child_slug_consistency error branches."""

    def _make_child(self, slug: str, name: str = "Child") -> SystemNode:
        return SystemNode(
            name=name, slug=slug, kit="sdlc",
            artifacts=[], codebase=[], children=[],
        )

    def _call(self, child, all_def_ids, has_ids, kind_tokens, parent_prefix=""):
        from cypilot.utils.artifacts_meta import _check_child_slug_consistency
        errors: list = []
        _check_child_slug_consistency(child, all_def_ids, has_ids, kind_tokens, parent_prefix, errors)
        return errors

    def test_no_ids_no_error(self):
        """has_ids=False with no IDs → no errors, slug unchanged."""
        child = self._make_child("myapp")
        errors = self._call(child, [], has_ids=False, kind_tokens={"feat"})
        self.assertEqual(errors, [])
        self.assertEqual(child.slug, "myapp")

    def test_consistent_single_system_no_error(self):
        """All IDs agree on a single slug → no error, slug unchanged (dedup key stability)."""
        child = self._make_child("folder-name")
        ids = ["cpt-myapp-feat-login", "cpt-myapp-feat-register"]
        errors = self._call(child, ids, has_ids=True, kind_tokens={"feat"})
        self.assertEqual(errors, [])
        self.assertEqual(child.slug, "folder-name")
        self.assertEqual(child.id_slug, "myapp")
        self.assertEqual(child.get_hierarchy_prefix(), "myapp")

    def test_consistent_single_system_uses_inferred_id_slug_in_meta_prefixes(self):
        """Registered system prefixes should follow inferred ID slugs, not folder slugs."""
        parent = self._make_child("platform", name="Platform")
        child = self._make_child("folder-name")
        child.parent = parent
        ids = ["cpt-platform-myapp-feat-login", "cpt-platform-myapp-feat-register"]
        errors = self._call(child, ids, has_ids=True, kind_tokens={"feat"}, parent_prefix="platform")
        meta = ArtifactsMeta(version="1", project_root=".", kits={}, systems=[parent])
        parent.children.append(child)
        self.assertEqual(errors, [])
        self.assertEqual(child.slug, "folder-name")
        self.assertEqual(child.id_slug, "myapp")
        self.assertEqual(child.get_hierarchy_prefix(), "platform-myapp")
        self.assertEqual(meta.get_all_system_prefixes(), {"platform", "platform-myapp"})

    def test_ids_missing_parent_prefix(self):
        """IDs unambiguously resolve to a system that lacks the parent prefix."""
        child = self._make_child("myapp")
        ids = ["cpt-myapp-feat-login"]
        errors = self._call(child, ids, has_ids=True, kind_tokens={"feat"}, parent_prefix="platform")
        self.assertEqual(len(errors), 1)
        self.assertIn("missing parent prefix", errors[0])
        self.assertIn("platform", errors[0])

    def test_inconsistent_systems_in_ids(self):
        """IDs reference different system prefixes → inconsistent-systems error."""
        child = self._make_child("folder")
        ids = ["cpt-alpha-feat-login", "cpt-beta-feat-register"]
        errors = self._call(child, ids, has_ids=True, kind_tokens={"feat"})
        self.assertEqual(len(errors), 1)
        self.assertIn("Inconsistent systems", errors[0])

    def test_cannot_determine_system_ambiguous_ids(self):
        """IDs that carry no unambiguous kind-token marker → cannot-determine error."""
        child = self._make_child("folder")
        ids = ["cpt-something-unknownkind-x"]
        errors = self._call(child, ids, has_ids=True, kind_tokens={"feat"})
        self.assertEqual(len(errors), 1)
        self.assertIn("Cannot determine system", errors[0])


if __name__ == "__main__":
    unittest.main()