ai-kit-python 1.4.2__py3-none-any.whl

aikit/tests/test_web_design.py

@@ -0,0 +1,219 @@
+"""Web Design is an offline optional workflow with preserved project design memory."""
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+from pathlib import Path
+import shutil
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+import adapters
+import context
+import doctor
+import install
+
+SKILLS = install.OPTIONAL_ENTRY_POINTS["web-design"]
+DOCUMENTS = install.OPTIONAL_DOCUMENTS["web-design"]
+RESOURCES = install.OPTIONAL_RESOURCES["web-design"]
+
+
+class WebDesignTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory(prefix="ai-kit-design-")
+        self.addCleanup(self.temp.cleanup)
+        base = Path(self.temp.name).resolve()
+        self.source = base / "reference"
+        self.target = base / "project with spaces"
+        shutil.copytree(install.ROOT, self.source, ignore=shutil.ignore_patterns("__pycache__", ".git"))
+
+    def plan(self, **options):
+        return install.build_plan(self.target, root=self.source, **options)
+
+    def apply(self, **options):
+        plan = self.plan(**options)
+        self.assertFalse(install.needs_review(plan), plan)
+        self.assertTrue(install.apply_plan(plan))
+        return plan
+
+    def test_default_and_all_presets_omit_the_whole_module(self):
+        for preset in (None, *install.PRESETS):
+            with self.subTest(preset=preset):
+                plan = self.plan(preset=preset, agents=["codex", "claude"])
+                self.assertNotIn("web-design", plan["extras"])
+                for name in SKILLS:
+                    self.assertNotIn(f".agents/skills/{name}/SKILL.md", plan["actions"])
+                    self.assertNotIn(f".claude/skills/{name}/SKILL.md", plan["actions"])
+                    self.assertNotIn(f"{name}/SKILL.md".encode(), plan["actions"]["ai-kit/SKILLS.md"]["data"])
+                self.assertTrue(set(RESOURCES + DOCUMENTS).isdisjoint(plan["actions"]))
+        self.apply()
+        self.assertEqual(doctor.link_warnings(self.target), [])
+        self.assertFalse(any("design" in warning for warning in doctor.examine(self.target, root=self.source)["warnings"]))
+
+    def test_apply_is_offline_and_copies_only_selected_native_skills(self):
+        client_files = (".codex/config.toml", ".mcp.json", ".cursor/mcp.json")
+        for name in client_files:
+            path = self.target / name
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(b"Client-owned configuration stays unchanged.\n")
+        with patch("subprocess.Popen", side_effect=AssertionError("No package/browser/client process")), \
+                patch("socket.socket", side_effect=AssertionError("No external network")):
+            self.apply(extras=["web-design"], agents=["codex", "claude", "cursor"])
+        for name in SKILLS:
+            source = self.target / f".agents/skills/{name}/SKILL.md"
+            native = self.target / f".claude/skills/{name}/SKILL.md"
+            self.assertEqual(source.read_bytes(), native.read_bytes())
+            self.assertNotIn(b"disable-model-invocation", native.read_bytes())
+        self.assertTrue(all((self.target / name).is_file() for name in RESOURCES + DOCUMENTS))
+        self.assertFalse((self.target / "ai-kit/.design").exists())
+        for name in client_files:
+            self.assertEqual((self.target / name).read_bytes(), b"Client-owned configuration stays unchanged.\n")
+        self.assertEqual(doctor.link_warnings(self.target), [])
+        self.assertEqual(doctor.examine(self.target, root=self.source)["errors"], [])
+
+    def test_choices_persist_independently_and_reruns_are_stable(self):
+        self.apply(extras=["web-design"], agents=["codex", "claude"])
+        self.assertEqual(self.plan(preset="minimal")["extras"], ["web-design"])
+        self.apply(extras=["context7", "security-audit", "strix"])
+        stable = self.plan()
+        self.assertEqual(stable["extras"], ["context7", "security-audit", "strix", "web-design"])
+        self.assertEqual(stable["actions"], {})
+        settings = json.loads((self.target / "ai-kit/settings.json").read_text(encoding="utf-8"))
+        self.assertIs(settings["web_design"], True)
+
+    def test_existing_design_documents_and_local_edits_survive_source_updates(self):
+        original = {}
+        for name in DOCUMENTS:
+            path = self.target / name
+            path.parent.mkdir(parents=True, exist_ok=True)
+            original[name] = ("Existing project design: " + name + "\r\n").encode()
+            path.write_bytes(original[name])
+        self.apply(extras=["web-design"])
+        entry = ".agents/skills/web-design/SKILL.md"
+        local = self.target / entry
+        local.write_bytes(local.read_bytes() + b"\nLocal project adjustment.\n")
+        local_bytes = local.read_bytes()
+        self.apply()
+        self.assertEqual(local.read_bytes(), local_bytes)
+        for name in DOCUMENTS:
+            source = self.source / "template" / name
+            source.write_bytes(source.read_bytes() + b"\nNew distribution scaffold.\n")
+        source_entry = self.source / "template" / entry
+        source_entry.write_bytes(source_entry.read_bytes() + b"\nNew distribution guidance.\n")
+        plan = self.plan()
+        self.assertIn(entry, plan["conflicts"])
+        self.assertFalse(install.apply_plan(plan))
+        self.assertEqual(local.read_bytes(), local_bytes)
+        for name, data in original.items():
+            self.assertEqual((self.target / name).read_bytes(), data)
+            self.assertNotIn(name, plan["conflicts"])
+        self.assertTrue(any((self.target / "ai-kit/.upstream-cache/candidates").rglob("SKILL.md")))
+
+    def test_project_documents_are_not_accept_local_managed_instructions(self):
+        self.apply(extras=["web-design"])
+        with self.assertRaisesRegex(ValueError, "managed instructions"):
+            self.plan(accept_local=[DOCUMENTS[0]])
+        (self.target / DOCUMENTS[-1]).unlink()
+        report = doctor.examine(self.target, root=self.source)
+        self.assertIn("Owned project document missing: " + DOCUMENTS[-1], report["warnings"])
+        self.apply()
+        self.assertTrue((self.target / DOCUMENTS[-1]).is_file())
+        original = install.is_link
+        with patch.object(install, "is_link", side_effect=lambda p: p == self.target / DOCUMENTS[0] or original(p)):
+            self.assertTrue(any("Unsafe project document" in error
+                                for error in doctor.examine(self.target, root=self.source)["errors"]))
+            with self.assertRaisesRegex(ValueError, "[Ll]ink"):
+                context.select_context(self.target, workflow="web-design")
+
+    def test_disabled_module_retains_files_but_cannot_select_workflow(self):
+        self.apply(extras=["web-design"], agents=["codex", "claude"])
+        paths = list(RESOURCES + DOCUMENTS) + [f".agents/skills/{name}/SKILL.md" for name in SKILLS]
+        before = {name: (self.target / name).read_bytes() for name in paths}
+        settings_path = self.target / "ai-kit/settings.json"
+        settings = json.loads(settings_path.read_text(encoding="utf-8"))
+        settings["web_design"] = False
+        settings_path.write_text(json.dumps(settings), encoding="utf-8")
+        plan = self.apply()
+        self.assertNotIn("web-design", plan["extras"])
+        self.assertEqual(before, {name: (self.target / name).read_bytes() for name in paths})
+        with self.assertRaisesRegex(ValueError, "disabled"):
+            context.select_context(self.target, workflow="web-design")
+        self.assertEqual(doctor.link_warnings(self.target), [])
+        retire = adapters.retirement_plan(self.target, "claude", root=self.source)
+        self.assertTrue(any(item["path"].endswith("web-design/SKILL.md") for item in retire["removals"]))
+        self.assertTrue(adapters.apply_retirement(retire))
+        self.assertTrue((self.target / ".agents/skills/web-design/SKILL.md").is_file())
+
+    def test_invalid_selection_and_blocked_or_linked_parents_refuse_before_writes(self):
+        defaults_path = self.source / "template/ai-kit/settings.json"
+        defaults = json.loads(defaults_path.read_text(encoding="utf-8"))
+        defaults["web_design"] = "true"
+        defaults_path.write_text(json.dumps(defaults), encoding="utf-8")
+        with self.assertRaisesRegex(ValueError, "web_design"):
+            self.plan(extras=["web-design"])
+        defaults.pop("web_design")
+        defaults_path.write_text(json.dumps(defaults), encoding="utf-8")
+        (self.target / "docs").mkdir(parents=True)
+        (self.target / "docs/design").write_bytes(b"Existing file marker.\n")
+        with self.assertRaisesRegex(NotADirectoryError, "directory"):
+            self.plan(extras=["web-design"])
+        self.assertFalse((self.target / "AGENTS.md").exists())
+        self.assertEqual((self.target / "docs/design").read_bytes(), b"Existing file marker.\n")
+        (self.target / "docs/design").unlink()
+        original = install.is_link
+        with patch.object(install, "is_link", side_effect=lambda p: p == self.target / "docs/design" or original(p)):
+            with self.assertRaisesRegex(ValueError, "[Ll]ink"):
+                self.plan(extras=["web-design"])
+
+    def test_plain_html_workflow_is_explicit_scoped_and_read_only(self):
+        self.target.mkdir(parents=True)
+        (self.target / "index.html").write_text("<!doctype html><title>Website</title>", encoding="utf-8")
+        self.apply(extras=["web-design"])
+        before = {p.relative_to(self.target): p.read_bytes() for p in self.target.rglob("*") if p.is_file()}
+        ordinary = context.select_context(self.target)
+        self.assertNotIn("ai-kit/WEB-DESIGN.md", {item["path"] for item in ordinary["selected"]})
+        report = context.select_context(self.target, workflow="web-design", budget=1)
+        selected = {item["path"] for item in report["selected"]}
+        self.assertTrue(set(DOCUMENTS).issubset(selected))
+        self.assertIn("ai-kit/WEB-DESIGN.md", selected)
+        self.assertNotIn("ai-kit/web-design/LARAVEL.md", selected)
+        self.assertNotIn("ai-kit/web-design/TOOLS.md", selected)
+        self.assertTrue(report["over_budget"])
+        self.assertEqual(report["profiles"], [])
+        review = context.select_context(self.target, workflow="ui-review")
+        self.assertIn("ai-kit/web-design/REVIEW.md", {item["path"] for item in review["selected"]})
+        self.assertEqual(before, {p.relative_to(self.target): p.read_bytes() for p in self.target.rglob("*") if p.is_file()})
+
+    def test_declared_laravel_scope_selects_blade_guidance_without_sibling_leakage(self):
+        self.apply(extras=["web-design"])
+        facts = self.target / "ai-kit/project.json"
+        facts.write_text(json.dumps({"schema": 1, "modules": [
+            {"path": "/web/", "profiles": ["LARAVEL", "FRONTEND"]},
+            {"path": "/worker/", "profiles": ["GO"]}]}), encoding="utf-8")
+        report = context.select_context(self.target, path="web", workflow="web-design")
+        selected = {item["path"] for item in report["selected"]}
+        self.assertIn("ai-kit/web-design/LARAVEL.md", selected)
+        self.assertIn(".agents/skills/laravel-blade-ui/SKILL.md", selected)
+        self.assertIn("ai-kit/profiles/OWNER.md", selected)
+        worker = context.select_context(self.target, path="worker", workflow="web-design")
+        self.assertNotIn("ai-kit/web-design/LARAVEL.md", {item["path"] for item in worker["selected"]})
+        with self.assertRaisesRegex(ValueError, "Unknown context workflow"):
+            context.select_context(self.target, workflow="unknown")
+        (self.target / "ai-kit/web-design/TOOLS.md").unlink()
+        with self.assertRaisesRegex(ValueError, "Missing required context"):
+            context.select_context(self.target, workflow="design-extract")
+
+    def test_cli_preview_is_available_without_applying_or_creating_a_target(self):
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output), patch.object(install, "ROOT", self.source):
+            self.assertEqual(install.main([str(self.target), "--with-web-design"]), 0)
+        self.assertIn("web-design", json.loads(output.getvalue())["extras"])
+        self.assertFalse(self.target.exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

aikit/tests/wheel_smoke.py

@@ -0,0 +1,104 @@
+"""Install a built wheel into a clean venv and exercise its bundled resources."""
+from __future__ import annotations
+
+from pathlib import Path
+import os
+import subprocess
+import sys
+import tempfile
+import venv
+import zipfile
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
+import check_distribution
+
+
+def venv_python(root: Path) -> Path:
+    return root / ("Scripts/python.exe" if sys.platform == "win32" else "bin/python")
+
+
+def venv_aikit(root: Path) -> Path:
+    return root / ("Scripts/aikit.exe" if sys.platform == "win32" else "bin/aikit")
+
+
+def main(argv: list[str] | None = None) -> int:
+    arguments = argv if argv is not None else sys.argv[1:]
+    if len(arguments) != 1:
+        raise SystemExit("Usage: wheel_smoke.py WHEEL")
+    wheel = Path(arguments[0]).resolve()
+    if wheel.is_dir():
+        candidates = sorted(wheel.glob("*.whl"))
+        if len(candidates) != 1:
+            raise SystemExit("Expected exactly one wheel in: " + str(wheel))
+        wheel = candidates[0]
+    if not wheel.is_file():
+        raise SystemExit("Wheel not found: " + str(wheel))
+    version = (Path(__file__).resolve().parents[1] / "VERSION").read_text(encoding="utf-8").strip()
+    check_distribution.inspect_distribution(wheel, version)
+    with zipfile.ZipFile(wheel) as package:
+        for name in ("AGENTS.md", "PROJECT_CONTEXT.md", "WIKI.md"):
+            if "aikit/" + name in package.namelist() or "aikit/template/" + name not in package.namelist():
+                raise RuntimeError("Wheel must exclude local maintainer files and retain project templates: " + name)
+    with tempfile.TemporaryDirectory(prefix="ai-kit-wheel-") as folder:
+        root = Path(folder).resolve()
+        env = root / "venv"
+        venv.EnvBuilder(with_pip=True, clear=True).create(env)
+        python = venv_python(env)
+        environment = dict(os.environ)
+        environment.pop("PYTHONPATH", None)
+        def run(command):
+            subprocess.run([str(item) for item in command], cwd=root, env=environment, check=True)
+        run([python, "-m", "pip", "install", "--no-index", "--no-deps", wheel])
+        aikit = venv_aikit(env)
+        run([python, "-c", "import importlib.metadata; assert importlib.metadata.version("
+             + repr(check_distribution.PROJECT_NAME) + ") == " + repr(version)])
+        run([aikit, "--version"])
+        run([aikit, "route", "implement a feature"])
+        for module in ("learning", "adaptive", "benchmark", "memory"):
+            run([python, "-c", "from aikit.scripts import " + module])
+        run([aikit, "benchmark", "--help"])
+        run([aikit, "check"])
+        # Exercise the packaged offline dialogue pipeline, not only dispatcher help.
+        workspace = root / "private memory"
+        for name in ("chatgpt", "openrouter"):
+            source = root / (name + ".json")
+            source.write_text('{"messages":[{"role":"user","content":"Fact stack = Laravel"}]}', encoding="utf-8")
+            run([aikit, "memory", "import", workspace, source, "--name", name, "--apply"])
+        merged = subprocess.run([str(aikit), "memory", "merge", str(workspace), "--left", "chatgpt",
+                                 "--right", "openrouter", "--apply"], cwd=root, env=environment,
+                                capture_output=True, text=True, check=True)
+        import json
+        merge_id = json.loads(merged.stdout)["merge_id"]
+        run([aikit, "memory", "export", workspace, "--merge", merge_id, "--draft", "--apply"])
+        if not (workspace / "exports" / merge_id / "chatgpt-draft.md").is_file():
+            raise RuntimeError("Wheel dialogue export is missing")
+        project = root / "project"
+        run([aikit, "install", project, "--preset", "minimal", "--agent", "codex", "--apply", "--check"])
+        run([aikit, "adapters", "report", "--project", project])
+        run([aikit, "context", "select", project])
+        audit_project = root / "audit project"
+        run([aikit, "install", audit_project, "--with-security-audit", "--with-strix", "--with-context7", "--with-web-design", "--agent", "codex",
+             "--agent", "claude", "--apply", "--check"])
+        from_manifest = audit_project / "ai-kit/vendor/security-audit/UPSTREAM.json"
+        if not from_manifest.is_file() or not (audit_project / ".agents/skills/security-audit/agents/openai.yaml").is_file():
+            raise RuntimeError("Wheel did not install the optional audit package and invocation policy")
+        strix_manifest = audit_project / "ai-kit/vendor/strix/UPSTREAM.json"
+        strix_reference = audit_project / "ai-kit/vendor/strix/penetration-testing-with-strix/SKILL.md"
+        if not strix_manifest.is_file() or not strix_reference.is_file() \
+                or not (audit_project / ".claude/skills/strix/SKILL.md").is_file():
+            raise RuntimeError("Wheel did not install the optional Strix references and native entry point")
+        if not (audit_project / "ai-kit/CONTEXT7.md").is_file() \
+                or not (audit_project / ".claude/skills/context7-docs/SKILL.md").is_file():
+            raise RuntimeError("Wheel did not install the Context7 guide and native documentation skill")
+        for name in ("web-design", "laravel-blade-ui", "ui-review", "design-extract"):
+            if not (audit_project / f".claude/skills/{name}/SKILL.md").is_file():
+                raise RuntimeError("Wheel did not install the Web Design native skill: " + name)
+        if not (audit_project / "docs/design/BRIEF.md").is_file():
+            raise RuntimeError("Wheel did not initialize the Web Design project documents")
+        run([aikit, "context", "select", audit_project, "--workflow", "web-design"])
+        run([aikit, "install", audit_project, "--apply", "--check"])
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())