dixi-spec-kit 1.5.0__py3-none-any.whl

dixi_spec_kit/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.5.0"

dixi_spec_kit/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

dixi_spec_kit/cli.py

@@ -0,0 +1,190 @@
+import argparse
+from importlib.resources import files
+import json
+from pathlib import Path
+import sys
+
+from . import __version__
+from .core import METADATA, PROFILES, check_project, doctor, initialize, message, placeholders, pr_size
+from .filesystem import Issue, read_json, root_directory
+from .upgrade import STATUSES, plan as upgrade_plan
+from .workflows import OPERATIONS, workflow_result
+
+
+class Parser(argparse.ArgumentParser):
+    def error(self, message):
+        raise Issue("invalid_arguments", 2)
+
+
+def parser_for(catalog):
+    class Formatter(argparse.HelpFormatter):
+        def _format_usage(self, usage, actions, groups, prefix):
+            return super()._format_usage(usage, actions, groups, prefix or catalog["usage"])
+
+    parser = Parser(prog="dixi", description=catalog["description"], add_help=False, formatter_class=Formatter)
+    parser._positionals.title = catalog["arguments"]
+    parser._optionals.title = catalog["options"]
+    parser.add_argument("--help", "-h", action="help", help=catalog["help"])
+    parser.add_argument("--version", action="version", version=f"dixi {__version__}", help=catalog["version"])
+    parser.add_argument("--lang", choices=("es", "en"), default=None, help=catalog["lang"])
+    parser.add_argument("--json", action="store_true", help=catalog["json"])
+    commands = parser.add_subparsers(dest="command", required=True, title=catalog["commands"])
+    for command in ("init", "doctor", "check", "workflow", "upgrade", "placeholders", "pr-size"):
+        child = commands.add_parser(command, help=catalog[command], description=catalog[command],
+                                    add_help=False, formatter_class=Formatter)
+        child._positionals.title = catalog["arguments"]
+        child._optionals.title = catalog["options"]
+        child.add_argument("--help", "-h", action="help", help=catalog["help"])
+        if command == "init":
+            child.add_argument("directory", help=catalog["directory"])
+            child.add_argument("--agent", choices=("none", "claude", "codex"), default="none", help=catalog["agent"])
+            child.add_argument("--profile", choices=PROFILES, default="minimal", help=catalog["profile_option"])
+            child.add_argument("--regulated", action="store_true", help=catalog["regulated_option"])
+            child.add_argument("--controls", action="store_true", help=catalog["controls_option"])
+        elif command == "placeholders":
+            child.add_argument("--strict", action="store_true", help=catalog["placeholders_strict"])
+        elif command == "pr-size":
+            child.add_argument("--base", default="main", help=catalog["pr_size_base"])
+            child.add_argument("--max", type=int, default=1500, dest="limit", help=catalog["pr_size_max"])
+        elif command == "upgrade":
+            child.add_argument("--dry-run", action="store_true", help=catalog["upgrade_dry_run"])
+            child.add_argument("--profile", choices=PROFILES, default=None, help=catalog["profile_option"])
+            child.add_argument("--regulated", action="store_true", default=None, help=catalog["regulated_option"])
+            child.add_argument("--controls", action="store_true", default=None, help=catalog["controls_option"])
+        elif command == "workflow":
+            actions = child.add_subparsers(dest="workflow_action", required=True, title=catalog["commands"])
+            for action in ("list", "show", "prepare"):
+                operation = actions.add_parser(action, help=catalog[f"workflow_{action}"], add_help=False,
+                                               description=catalog[f"workflow_{action}"], formatter_class=Formatter)
+                operation._positionals.title = catalog["arguments"]
+                operation._optionals.title = catalog["options"]
+                operation.add_argument("--help", "-h", action="help", help=catalog["help"])
+                if action != "list":
+                    operation.add_argument("operation", choices=OPERATIONS, help=catalog["workflow_operation"])
+                if action == "prepare":
+                    operation.add_argument("--target", required=True, help=catalog["workflow_target"])
+                    operation.add_argument("--request", required=True, help=catalog["workflow_request"])
+    return parser
+
+
+def project_language():
+    try:
+        with root_directory(Path.cwd()) as root:
+            language = read_json(root, METADATA).get("language")
+    except (Issue, OSError, AttributeError):
+        return None
+    return language if language in ("es", "en") else None
+
+
+def subcommand(argv):
+    skip = False
+    for arg in argv:
+        if skip:
+            skip = False
+        elif arg == "--lang":
+            skip = True
+        elif not arg.startswith("-"):
+            return arg
+    return None
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    language = None
+    for index, arg in enumerate(argv):
+        if arg == "--lang" and index + 1 < len(argv) and argv[index + 1] in ("es", "en"):
+            language = argv[index + 1]
+        elif arg in ("--lang=es", "--lang=en"):
+            language = arg.split("=", 1)[1]
+    if language is None and subcommand(argv) != "init":
+        language = project_language()
+    language = language or "en"
+    catalog = json.loads(files("dixi_spec_kit").joinpath("locales", f"{language}.json").read_text(encoding="utf-8"))
+    code = 0
+    workflow = None
+    upgrade = None
+    extra = {}
+    try:
+        args = parser_for(catalog).parse_args(argv)
+        args.lang = args.lang or language
+        if args.command == "init":
+            messages = initialize(args.directory, args.lang, args.agent, args.profile, args.regulated, args.controls)
+        elif args.command == "doctor":
+            messages = doctor(Path.cwd(), args.lang)
+        elif args.command == "workflow":
+            workflow = workflow_result(args, Path.cwd())
+            messages = [message("workflow_scope")]
+        elif args.command == "upgrade":
+            if not args.dry_run:
+                raise Issue("upgrade_requires_dry_run", 2)
+            upgrade = upgrade_plan(Path.cwd(), args.profile, args.regulated, args.controls)
+            messages = [message("upgrade_planned", source=upgrade["from"], target=upgrade["to"]),
+                        message("upgrade_no_changes")]
+        elif args.command == "placeholders":
+            counts = placeholders(Path.cwd())
+            total = sum(counts.values())
+            extra = {"placeholders": counts, "total": total}
+            messages = [message("placeholders_found", total=total, files=len(counts))]
+            code = 1 if args.strict and total else 0
+        elif args.command == "pr-size":
+            size = pr_size(Path.cwd(), args.base, args.limit)
+            extra = {"pr_size": size}
+            messages = [message("pr_size_result", **size)]
+            if size["counted"] > size["max"]:
+                code = 1
+                messages.append(message("pr_size_exceeded", counted=size["counted"], max=size["max"]))
+        else:
+            code, messages = check_project(Path.cwd())
+    except Issue as error:
+        code, messages = error.code, [message(error.key, **error.params)]
+    except OSError:
+        code, messages = 5, [message("io_error")]
+    for entry in messages:
+        entry["message"] = catalog[entry["key"]].format(**entry["params"])
+    result = {"status": "completed" if code == 0 else "failed", "code": code, "messages": messages}
+    if workflow is not None:
+        result["workflow"] = workflow
+    if upgrade is not None:
+        result["upgrade"] = upgrade
+    result.update(extra)
+    if "--json" in argv:
+        print(json.dumps(result, ensure_ascii=False))
+    else:
+        for entry in messages:
+            print(entry["message"], file=sys.stderr if code else sys.stdout)
+        if workflow is not None:
+            print(format_workflow(workflow, catalog))
+        if upgrade is not None:
+            print(format_upgrade(upgrade, catalog))
+        for name, count in extra.get("placeholders", {}).items():
+            print(f"  {count:4d}  {name}")
+    return code
+
+
+def format_upgrade(upgrade, catalog):
+    lines = []
+    for status in STATUSES:
+        names = upgrade["files"][status]
+        lines.append(f"\n{catalog['upgrade_heading_' + status]} ({len(names)}):")
+        if status != "unchanged":
+            lines += [f"- {name}" for name in names]
+    return "\n".join(lines)
+
+
+def format_workflow(workflow, catalog):
+    if "operations" in workflow:
+        return "\n".join(f"{op['id']} — {op['title']}\n  {op['purpose']}" for op in workflow["operations"])
+    packet = workflow.get("packet")
+    recipe = packet["recipe"] if packet else workflow["recipe"]
+    lines = [f"\n{recipe['id']} — {recipe['title']}", recipe["purpose"]]
+    if packet:
+        lines += [catalog["workflow_prepared"].format(target=packet["target"]["id"], mode=packet["mode"],
+                                                      language=packet["project_language"]),
+                  catalog["workflow_request"] + ": " + json.dumps(packet["request"], ensure_ascii=False)]
+    for key in ("target_kinds", "inputs", "steps", "outputs", "gates", "checks", "guards", "next_operations"):
+        lines += ["\n" + catalog[f"workflow_heading_{key}"] + ":"]
+        lines += [f"- {item}" for item in recipe[key]] or [catalog["workflow_no_next"]]
+    if packet:
+        lines += ["\n" + catalog["workflow_heading_sources"] + ":"]
+        lines += [f"- {s['path']} · SHA-256 {s['sha256']} · {s['bytes']} B" for s in packet["sources"]]
+    return "\n".join(lines)

dixi_spec_kit/core.py

@@ -0,0 +1,399 @@
+import hashlib
+from importlib.resources import files
+import json
+import os
+from pathlib import Path, PurePosixPath
+import posixpath
+import re
+import subprocess
+import sys
+from urllib.parse import unquote, urlsplit
+
+from . import __version__
+from .filesystem import (Issue, decode_json, directory, read_file, read_json,
+                         root_directory, safe_path, supported, write_file)
+
+
+PARENTS = {"goal": set(), "domain": {"goal"}, "module": {"domain"},
+           "feature": {"module"}, "contract": {"feature", "module"},
+           "test": {"feature", "contract"}}
+METADATA = ".dixi/project.json"
+AGENTS = ("none", "claude", "codex")
+PROFILES = ("minimal", "site", "app", "platform")
+MAX_MANAGED = 1000
+CODEX_POLICY = b"policy:\n  allow_implicit_invocation: false\n"
+CLAUDE_REQUIRED = ("discover", "specify", "clarify", "plan", "tasks", "build", "verify", "review", "analyze", "status")
+CLAUDE_COMMANDS = CLAUDE_REQUIRED + ("domain", "architecture", "contract", "threat-model", "handoff", "change",
+                                     "data", "quality", "ai", "release", "promote", "operate", "finops",
+                                     "compliance", "duediligence", "interview", "risk-review")
+SUBAGENTS = ("architect", "tester", "developer", "reviewer")
+CONTROLS = ("protect_tests", "guard_secrets", "guard_attestation", "mode_gate", "verify_on_stop")
+TEST_PATH = re.compile(r"(^|/)(tests?|__tests__|spec)/|(^|/)test_[^/]*$|_test\.[^/]+$|\.(test|spec)\.[^/]+$|\.feature$")
+EXCLUDED_PATH = re.compile(r"(\.md$|^docs/|(^|/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|poetry\.lock|uv\.lock|"
+                           r"Cargo\.lock|go\.sum|Gemfile\.lock|composer\.lock)$|\.min\.(js|css)$|(^|/)generated/)")
+TRACE = ".dixi/traceability.json"
+INLINE_LINK = re.compile(r"!?\[[^\[\]\n]{0,999}\]\(([^)\n]{1,4096})\)")
+KIT_VERSION = re.compile(r"(0|[1-9][0-9]{0,3})\.(0|[1-9][0-9]{0,3})\.(0|[1-9][0-9]{0,3})(?:\.dev[0-9]{1,4}|rc[0-9]{1,4})?")
+REFERENCE_LINK = re.compile(r"^ {0,3}\[[^\[\]\n]{1,999}\]:[ \t]*(<[^>\n]{1,4096}>|[^\s<>]{1,4096})(?=[ \t]|$)", re.MULTILINE)
+
+
+def templates(language):
+    data = files("dixi_spec_kit").joinpath("resources", f"project.{language}.json").read_bytes()
+    payload = decode_json(data, "resources")
+    if not isinstance(payload, dict) or not 1 <= len(payload) <= 500:
+        raise Issue("invalid_resources", 5)
+    if any(not safe_path(k) or not isinstance(v, str) for k, v in payload.items()):
+        raise Issue("invalid_resources", 5)
+    return payload
+
+
+def profile_manifest():
+    data = decode_json(files("dixi_spec_kit").joinpath("resources", "profiles.json").read_bytes(), "resources")
+    entries = data.get("files") if isinstance(data, dict) else None
+    if (not isinstance(entries, dict) or data.get("version") != 1
+            or any(not safe_path(k) or not isinstance(v, str) or not re.fullmatch(r"[ynr]{3}", v)
+                   for k, v in entries.items())):
+        raise Issue("invalid_resources", 5)
+    return entries
+
+
+def profile_files(language, profile, regulated):
+    if profile == "minimal":
+        return {}
+    column = PROFILES.index(profile) - 1
+    folder = files("dixi_spec_kit").joinpath("resources", "templates", language)
+    payload = {}
+    for name, codes in profile_manifest().items():
+        if codes[column] == "y" or (regulated and codes[column] == "r"):
+            payload[name] = folder.joinpath(*name.split("/")).read_bytes()
+    return payload
+
+
+def check_profile(profile, regulated):
+    if profile not in PROFILES or type(regulated) is not bool:
+        raise Issue("invalid_arguments", 2)
+    if regulated and profile == "minimal":
+        raise Issue("regulated_requires_profile", 2)
+
+
+def recorded_profile(metadata):
+    return metadata.get("profile", "minimal"), metadata.get("regulated", False)
+
+
+def codex_files(language):
+    folder = files("dixi_spec_kit").joinpath("resources", "codex", language)
+    payload = {}
+    for name in CLAUDE_COMMANDS:
+        payload[f".agents/skills/dixi-{name}/SKILL.md"] = folder.joinpath(f"dixi-{name}.md").read_bytes()
+        payload[f".agents/skills/dixi-{name}/agents/openai.yaml"] = CODEX_POLICY
+    return payload
+
+
+def required_adapter_files(agent):
+    if agent == "claude":
+        return {"CLAUDE.md"} | {f".claude/commands/dixi.{name}.md" for name in CLAUDE_REQUIRED}
+    if agent == "codex":
+        return {f".agents/skills/dixi-{name}/{suffix}" for name in CLAUDE_REQUIRED
+                for suffix in ("SKILL.md", "agents/openai.yaml")}
+    return set()
+
+
+def adapter_files(agent, language):
+    if agent == "none":
+        return {}
+    if agent == "codex":
+        return codex_files(language)
+    folder = files("dixi_spec_kit").joinpath("resources", "claude", language)
+    payload = {"CLAUDE.md": folder.joinpath("CLAUDE.md").read_bytes()}
+    for name in CLAUDE_COMMANDS:
+        payload[f".claude/commands/dixi.{name}.md"] = folder.joinpath(f"dixi.{name}.md").read_bytes()
+    for name in SUBAGENTS:
+        payload[f".claude/agents/dixi-{name}.md"] = folder.joinpath("agents", f"dixi-{name}.md").read_bytes()
+    try:
+        for data in payload.values():
+            data.decode("utf-8")
+    except UnicodeError:
+        raise Issue("invalid_resources", 5) from None
+    return payload
+
+
+def hook_command(agent, script):
+    if agent == "claude":
+        return f'python3 "$CLAUDE_PROJECT_DIR/.dixi/hooks/{script}.py"'
+    return f'python3 "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.dixi/hooks/{script}.py"'
+
+
+def hook_group(agent, scripts, matcher=None, timeout=None):
+    handlers = []
+    for script in scripts:
+        handler = {"type": "command", "command": hook_command(agent, script)}
+        if timeout:
+            handler["timeout"] = timeout
+        handlers.append(handler)
+    return ({"matcher": matcher} if matcher else {}) | {"hooks": handlers}
+
+
+def control_files(agent):
+    if agent not in ("claude", "codex"):
+        return {}
+    folder = files("dixi_spec_kit").joinpath("resources", "hooks")
+    payload = {f".dixi/hooks/{name}.py": folder.joinpath(f"{name}.py").read_bytes() for name in CONTROLS}
+    shell = ("mode_gate", "guard_secrets", "guard_attestation", "protect_tests")
+    stop = [hook_group(agent, ["verify_on_stop"], timeout=300)]
+    if agent == "claude":
+        events = {"PreToolUse": [hook_group(agent, shell, "Bash"), hook_group(agent, ["guard_secrets"], "Read|Grep"),
+                                 hook_group(agent, ["protect_tests"], "Edit|Write|MultiEdit|NotebookEdit")],
+                  "Stop": stop, "SubagentStop": stop}
+        name = ".claude/settings.json"
+    else:
+        events = {"PreToolUse": [hook_group(agent, shell, "^Bash$"), hook_group(agent, ["protect_tests"], "^apply_patch$")],
+                  "Stop": stop, "SubagentStop": stop}
+        name = ".codex/hooks.json"
+    payload[name] = (json.dumps({"hooks": events}, indent=2) + "\n").encode()
+    return payload
+
+
+def message(key, **params):
+    return {"key": key, "params": params}
+
+
+def initialize(destination, language, agent="none", profile="minimal", regulated=False, controls=False):
+    check_profile(profile, regulated)
+    if controls and agent == "none":
+        raise Issue("controls_require_agent", 2)
+    text = str(destination)
+    path = Path(os.getcwd()) if text and text.rstrip("/") == "." else Path(text)
+    if not text or ".." in path.parts or not path.name:
+        raise Issue("unsafe_destination", 3)
+    payload = {name: text.encode("utf-8") for name, text in templates(language).items()}
+    payload.update(profile_files(language, profile, regulated))
+    payload.update(adapter_files(agent, language))
+    if controls:
+        payload.update(control_files(agent))
+    metadata = {"schema_version": 1, "kit_version": __version__, "language": language,
+                "agent": agent, "policy": "portable", "profile": profile, "regulated": regulated,
+                "controls": bool(controls),
+                "managed_files": {name: hashlib.sha256(data).hexdigest() for name, data in payload.items()}}
+    try:
+        with root_directory(path.parent) as parent:
+            try:
+                os.mkdir(path.name, mode=0o700, dir_fd=parent)
+            except FileExistsError:
+                pass
+            with directory(parent, [path.name]) as root:
+                if os.listdir(root):
+                    raise Issue("destination_conflict", 3)
+                write_file(root, ".dixi-init.lock", b"")
+                for name, data in payload.items():
+                    write_file(root, name, data)
+                write_file(root, METADATA, (json.dumps(metadata, ensure_ascii=False, indent=2) + "\n").encode())
+                os.unlink(".dixi-init.lock", dir_fd=root)
+    except Issue as error:
+        if error.key == "unsafe_path":
+            error.key, error.code = "unsafe_destination", 3
+        raise
+    except FileExistsError:
+        raise Issue("destination_conflict", 3) from None
+    return [message("initialized", path=str(path)), message("structure_only")]
+
+
+def project_metadata(root):
+    try:
+        data = read_json(root, METADATA)
+    except Issue as error:
+        if error.key == "missing_file":
+            raise Issue("missing_project", 2) from None
+        raise
+    if not isinstance(data, dict) or type(data.get("schema_version")) is not int:
+        raise Issue("invalid_metadata")
+    if data["schema_version"] != 1:
+        raise Issue("unsupported_schema", 4)
+    if (not isinstance(data.get("kit_version"), str) or data.get("language") not in ("es", "en")
+            or data.get("agent") not in AGENTS or data.get("policy") != "portable"):
+        raise Issue("invalid_metadata")
+    version = KIT_VERSION.fullmatch(data["kit_version"])
+    if not version:
+        raise Issue("invalid_metadata")
+    if version.group(1) != __version__.split(".")[0]:
+        raise Issue("unsupported_schema", 4)
+    inventory = data.get("managed_files")
+    if not isinstance(inventory, dict) or not 1 <= len(inventory) <= MAX_MANAGED:
+        raise Issue("invalid_metadata")
+    for name, digest in inventory.items():
+        if not safe_path(name) or not isinstance(digest, str) or not re.fullmatch(r"[0-9a-f]{64}", digest):
+            raise Issue("invalid_metadata")
+    profile, regulated = recorded_profile(data)
+    if profile not in PROFILES or type(regulated) is not bool or (regulated and profile == "minimal"):
+        raise Issue("invalid_metadata")
+    controls = data.get("controls", False)
+    if type(controls) is not bool or (controls and data["agent"] == "none"):
+        raise Issue("invalid_metadata")
+    required = set(templates(data["language"])) | required_adapter_files(data["agent"])
+    if not required <= set(inventory):
+        raise Issue("invalid_metadata")
+    return data
+
+
+def traceability(root):
+    data = read_json(root, TRACE)
+    if (not isinstance(data, dict) or type(data.get("schema_version")) is not int
+            or data["schema_version"] != 1 or not isinstance(data.get("items"), list)
+            or len(data["items"]) > 500):
+        raise Issue("invalid_trace")
+    items = data["items"]
+    by_id = {}
+    for item in items:
+        if (not isinstance(item, dict) or not isinstance(item.get("id"), str)
+                or not re.fullmatch(r"[A-Za-z][A-Za-z0-9._-]{0,127}", item["id"])
+                or not isinstance(item.get("kind"), str) or item["kind"] not in PARENTS
+                or not safe_path(item.get("path")) or not isinstance(item.get("parents"), list)
+                or len(item["parents"]) > 500 or any(not isinstance(p, str) for p in item["parents"])):
+            raise Issue("invalid_trace")
+        if item["id"] in by_id or len(item["parents"]) != len(set(item["parents"])):
+            raise Issue("invalid_trace")
+        by_id[item["id"]] = item
+    issues = []
+    for item in items:
+        allowed = PARENTS[item["kind"]]
+        if bool(item["parents"]) != bool(allowed) or any(
+                p not in by_id or by_id[p]["kind"] not in allowed for p in item["parents"]):
+            issues.append(message("invalid_parent", path=item["id"]))
+    return items, issues
+
+
+def markdown_links(root, name, data, removable=frozenset()):
+    try:
+        text = data.decode("utf-8")
+    except UnicodeError:
+        raise Issue("invalid_file", path=name) from None
+    issues = []
+    targets = INLINE_LINK.findall(text) + REFERENCE_LINK.findall(text)
+    if len(targets) > 500:
+        raise Issue("invalid_file", path=name)
+    for target in targets:
+        target = target.strip()
+        if not target:
+            continue
+        target = target[1:target.index(">")] if target.startswith("<") and ">" in target else target.split()[0]
+        try:
+            link = urlsplit(target)
+            if link.scheme in {"http", "https", "mailto"}:
+                continue
+            if link.scheme or link.netloc or link.path.startswith("/"):
+                raise Issue("unsafe_path")
+            if not link.path:
+                continue
+            relative = posixpath.normpath(posixpath.join(str(PurePosixPath(name).parent), unquote(link.path)))
+            try:
+                read_file(root, relative)
+            except Issue as error:
+                if error.key != "missing_file" or relative not in removable:
+                    raise
+        except (Issue, ValueError):
+            issues.append(message("invalid_link", path=name))
+    return issues
+
+
+def check_project(path):
+    issues = []
+    with root_directory(path) as root:
+        metadata = project_metadata(root)
+        names = set(metadata["managed_files"])
+        optional = set(profile_manifest()) & names
+        try:
+            items, graph_issues = traceability(root)
+            issues.extend(graph_issues)
+            names.update(item["path"] for item in items)
+        except Issue as error:
+            issues.append(message(error.key, **error.params))
+        for name in sorted(names):
+            try:
+                data = read_file(root, name)
+                if name.endswith(".md"):
+                    issues.extend(markdown_links(root, name, data, optional))
+            except Issue as error:
+                if error.key == "missing_file" and name in optional:
+                    continue
+                issues.append(message(error.key, **error.params))
+    return (1 if issues else 0), issues + [message("structure_only")]
+
+
+def doctor(path, language):
+    if not supported():
+        raise Issue("unsupported_platform", 4)
+    templates(language)
+    results = [message("runtime", version=sys.version.split()[0]), message("resources_ok")]
+    with root_directory(path) as root:
+        try:
+            metadata = project_metadata(root)
+            profile, regulated = recorded_profile(metadata)
+            results.append(message("profile", profile=profile, regulated=regulated))
+            results.append(message("controls", controls=metadata.get("controls", False)))
+            if metadata["agent"] == "claude":
+                installed = sum(f".claude/commands/dixi.{name}.md" in metadata["managed_files"]
+                                for name in CLAUDE_COMMANDS)
+                results.append(message("agent_claude", language=metadata["language"],
+                                       commands=installed, available=len(CLAUDE_COMMANDS)))
+                if installed < len(CLAUDE_COMMANDS):
+                    results.append(message("upgrade_hint"))
+            elif metadata["agent"] == "codex":
+                installed = sum(f".agents/skills/dixi-{name}/SKILL.md" in metadata["managed_files"]
+                                for name in CLAUDE_COMMANDS)
+                results.append(message("agent_codex", language=metadata["language"],
+                                       skills=installed, available=len(CLAUDE_COMMANDS)))
+                if installed < len(CLAUDE_COMMANDS):
+                    results.append(message("upgrade_hint"))
+            else:
+                results.append(message("agent_none", language=metadata["language"]))
+        except Issue as error:
+            if error.code != 2:
+                raise
+            results.append(message("no_project_optional"))
+    return results
+
+
+def strip_code(text):
+    text = re.sub(r"(?ms)^ {0,3}(```|~~~).*?^ {0,3}\1[^\n]*$", "", text)
+    return re.sub(r"`[^`\n]*`", "", text)
+
+
+def placeholders(path):
+    counts = {}
+    with root_directory(path) as root:
+        metadata = project_metadata(root)
+        for name in sorted(metadata["managed_files"]):
+            if not name.endswith(".md"):
+                continue
+            try:
+                text = read_file(root, name).decode("utf-8", errors="replace")
+            except Issue as error:
+                if error.key == "missing_file":
+                    continue
+                raise
+            count = len(re.findall(r"\{\{pending:", strip_code(text)))
+            if count:
+                counts[name] = count
+    return counts
+
+
+def pr_size(path, base, limit):
+    def git(*args):
+        try:
+            result = subprocess.run(["git", *args], cwd=path, capture_output=True, text=True, timeout=60)
+        except (OSError, subprocess.SubprocessError):
+            raise Issue("pr_size_git", 2, base=base) from None
+        if result.returncode != 0:
+            raise Issue("pr_size_git", 2, base=base)
+        return result.stdout
+
+    git("rev-parse", "--verify", "--quiet", f"{base}^{{commit}}")
+    size = {"base": base, "counted": 0, "tests": 0, "excluded": 0, "max": limit}
+    for line in git("diff", "--numstat", "--no-renames", f"{base}...HEAD").splitlines():
+        parts = line.split("\t", 2)
+        if len(parts) != 3:
+            continue
+        lines = sum(int(value) for value in parts[:2] if value.isdigit())
+        name = parts[2]
+        key = "tests" if TEST_PATH.search(name) else "excluded" if EXCLUDED_PATH.search(name) else "counted"
+        size[key] += lines
+    return size