agent-wiki-cli 0.3.28__py3-none-any.whl

llm_wiki_cli/commands/generate_prompt_cmd.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from ..config import DEFAULT_WIKI_DIR, validate_path
+from ..services.paths import shell_quote
+from ..services.secure_file import write_private_text
+
+_DEFAULT_PROMPT_FILE = ".git/llm-wiki-prompt.txt"
+
+
+def _build_prompt(wiki_dir: str, src_dir: str) -> str:
+    quoted_wiki_dir = shell_quote(wiki_dir)
+    quoted_wiki_dir_slash = shell_quote(f"{wiki_dir}/")
+    quoted_src_dir = shell_quote(src_dir)
+    return f"""\
+You are a Wiki synchronizer for this project.
+The project's wiki lives at `{wiki_dir}/`.
+
+## Context
+
+Run these commands to understand what changed:
+
+```bash
+# Changed files — compact inventory of what was modified in the last commit
+llm-wiki extract --src-dir {quoted_src_dir} --changed --summary
+
+# Full diff of the last commit
+git diff HEAD~1..HEAD
+
+# Current wiki health — shows what's already broken vs. what you need to fix
+llm-wiki lint --wiki-dir {quoted_wiki_dir} --src-dir {quoted_src_dir}
+```
+
+For full detail (methods, params, docstrings) on a specific file:
+```bash
+llm-wiki extract --src-dir {quoted_src_dir} --paths path/to/file.py
+```
+
+## Success Criteria
+
+Your work is done when **all** of the following are true:
+
+1. **`llm-wiki lint` exits 0** — no broken links, no orphan pages, no undocumented \
+classes, no stale entities, no missing modules, no broken workflow links, \
+no undocumented infrastructure files.
+2. **Only affected pages changed** — modify wiki pages that correspond to code \
+touched in the diff. Do not edit unrelated pages or reformat existing content.
+3. **`{wiki_dir}/log.md` has a new entry** — one concise line describing what changed, \
+appended at the bottom.
+4. **`CHANGELOG.md` updated** (if applicable) — add an entry under `## [Unreleased]` \
+for user-facing changes. Skip for pure refactors, test-only, or doc-only commits. \
+*(Not verified by lint.)*
+
+## Verify & Commit
+
+After making your changes, run:
+
+```bash
+llm-wiki lint --wiki-dir {quoted_wiki_dir} --src-dir {quoted_src_dir}
+```
+
+If lint reports issues, fix them and re-run until it exits 0. Then commit:
+
+```bash
+git add {quoted_wiki_dir_slash} CHANGELOG.md
+LLM_WIKI_AUTO_COMMIT=1 git commit -m "docs(wiki): auto-update [bot]"
+```
+"""
+
+
+def run(args) -> None:
+    wiki_dir: str = getattr(args, "wiki_dir", DEFAULT_WIKI_DIR)
+    src_dir: str = getattr(args, "src_dir", ".")
+    validate_path(wiki_dir, "--wiki-dir")
+    validate_path(src_dir, "--src-dir")
+    output: str = getattr(args, "output", _DEFAULT_PROMPT_FILE)
+    print_only: bool = getattr(args, "print_prompt", False)
+
+    prompt = _build_prompt(wiki_dir, src_dir)
+
+    if print_only:
+        print(prompt)
+        return
+
+    out_path = write_private_text(output, prompt)
+
+    print(f"Wiki sync prompt written to: {out_path}")
+    print()
+    print("Paste the contents into your IDE agent chat to trigger a wiki sync.")
+    print(f"  cat {shell_quote(out_path)}")

llm_wiki_cli/commands/hook_cmd.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import os
+import stat
+import sys
+from pathlib import Path
+
+from ..config import CLI_AGENTS, DEFAULT_WIKI_DIR, IDE_AGENTS, get_agent_config_path, read_config, validate_path
+from ..services.paths import shell_quote
+
+# Agents that support headless CLI execution (can be used in post-commit hook)
+_CLI_AGENTS = set(CLI_AGENTS)
+# Agents that are IDE-only and cannot run headlessly
+_UI_ONLY_AGENTS = IDE_AGENTS
+HOOK_SIGNATURE = "LLM Wiki"
+
+
+def _read_agent_config(wiki_dir: str) -> str | None:
+    """Read the agent name persisted by `llm-wiki init`."""
+    config_path = get_agent_config_path(wiki_dir)
+    if config_path.exists():
+        config = read_config(wiki_dir)
+        return config.get("agent")
+    return None
+
+
+def _build_post_commit(agent: str, wiki_dir: str) -> str:
+    quoted_agent = shell_quote(agent)
+    quoted_wiki_dir = shell_quote(wiki_dir)
+    return f"""#!/bin/sh
+
+# LLM Wiki Auto-Sync Post-Commit Hook
+# Triggers the wiki update in the background so it doesn't block the developer
+
+# Skip if this commit was made by the pre-push auto-bump
+if [ -n "$LLM_WIKI_AUTO_COMMIT" ]; then
+    exit 0
+fi
+
+echo "Triggering LLM Wiki subagent sync in the background..."
+
+# Configurable via environment variables (no need to re-install hook)
+LLM_WIKI_TIMEOUT="${{LLM_WIKI_TIMEOUT:-300}}"
+LLM_WIKI_MAX_DIFF="${{LLM_WIKI_MAX_DIFF:-1000}}"
+LLM_WIKI_MAX_PROMPT_BYTES="${{LLM_WIKI_MAX_PROMPT_BYTES:-2000000}}"
+
+# Find the virtual environment if it exists, or run globally
+if [ -f ".venv/bin/llm-wiki" ]; then
+    CLI=".venv/bin/llm-wiki"
+else
+    CLI="llm-wiki"
+fi
+
+nohup "$CLI" trigger-agent --agent {quoted_agent} --wiki-dir {quoted_wiki_dir} --timeout "$LLM_WIKI_TIMEOUT" --max-diff-lines "$LLM_WIKI_MAX_DIFF" --max-prompt-bytes "$LLM_WIKI_MAX_PROMPT_BYTES" > .git/llm-wiki-sync.log 2>&1 &
+"""
+
+
+def _build_ide_post_commit(wiki_dir: str) -> str:
+    quoted_wiki_dir = shell_quote(wiki_dir)
+    return f"""#!/bin/sh
+
+# LLM Wiki -- IDE Agent Prompt Helper (Post-Commit Hook)
+# Generates a ready-to-paste sync prompt for IDE agents (Copilot, Cursor, etc.)
+# The agent cannot run headlessly, so this hook prepares the work for you.
+
+# Skip if this commit was made by the pre-push auto-bump
+if [ -n "$LLM_WIKI_AUTO_COMMIT" ]; then
+    exit 0
+fi
+
+if [ -f ".venv/bin/llm-wiki" ]; then
+    CLI=".venv/bin/llm-wiki"
+else
+    CLI="llm-wiki"
+fi
+
+"$CLI" generate-prompt --wiki-dir {quoted_wiki_dir} --output .git/llm-wiki-prompt.txt
+
+echo ""
+echo "+--------------------------------------------------------------+"
+echo "|  LLM Wiki: paste the sync prompt into your IDE agent chat.  |"
+echo "|  File: .git/llm-wiki-prompt.txt                             |"
+echo "+--------------------------------------------------------------+"
+
+# Auto-open in VS Code only when explicitly enabled
+if [ "${{LLM_WIKI_OPEN_PROMPT:-0}}" = "1" ] && [ "$TERM_PROGRAM" = "vscode" ]; then
+    code .git/llm-wiki-prompt.txt 2>/dev/null || true
+fi
+"""
+
+
+
+
+def _install_hook(hooks_dir: Path, name: str, content: str, *, force: bool = False) -> None:
+    """Write a hook file and make it executable."""
+    hook_path = hooks_dir / name
+    if hook_path.exists():
+        existing = hook_path.read_text(encoding="utf-8", errors="replace")
+        if HOOK_SIGNATURE not in existing and not force:
+            print(
+                f"Error: {hook_path} already exists and does not look like an LLM Wiki hook.\n"
+                "Use --force to replace it intentionally.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+    with open(hook_path, "w", encoding="utf-8") as f:
+        f.write(content)
+    st = os.stat(hook_path)
+    os.chmod(hook_path, st.st_mode | stat.S_IEXEC)
+    print(f"  Installed: {hook_path}")
+
+
+def run(args):
+    git_dir = Path(".git")
+    if not git_dir.exists():
+        print("Error: No .git directory found. Are you in the root of a git repository?")
+        sys.exit(1)
+
+    hooks_dir = git_dir / "hooks"
+    hooks_dir.mkdir(exist_ok=True)
+
+    wiki_dir = getattr(args, "wiki_dir", DEFAULT_WIKI_DIR)
+    validate_path(wiki_dir, "--wiki-dir")
+
+    # Resolve agent: CLI override > config file > fallback
+    agent = getattr(args, "agent", None)
+    if not agent:
+        agent = _read_agent_config(wiki_dir)
+        if not agent:
+            print(
+                f"Warning: No agent config found at .git/.llm-wiki-agent.\n"
+                f"Run `llm-wiki init --agent <agent>` first, or pass --agent to this command.\n"
+                f"Defaulting to 'claude'."
+            )
+            agent = "claude"
+
+    # IDE-only agent: install the prompt-generation hook instead of the headless sync hook
+    if agent in _UI_ONLY_AGENTS:
+        _install_hook(
+            hooks_dir, "post-commit", _build_ide_post_commit(wiki_dir),
+            force=getattr(args, "force", False),
+        )
+        print(f"  Agent: {agent} (IDE mode -- prompt-generation hook)")
+        print(
+            f"\nIDE sync hook installed. After each commit, a prompt file will be generated at\n"
+            f"  .git/llm-wiki-prompt.txt\n"
+            f"Paste its contents into your {agent} chat to sync the wiki.\n"
+            f"You can also generate it manually at any time:\n"
+            f"  llm-wiki generate-prompt"
+        )
+        print("\nHook installation complete.")
+        return
+
+    # CLI agent: install headless auto-sync hook with agent baked in
+    _install_hook(
+        hooks_dir, "post-commit", _build_post_commit(agent, wiki_dir),
+        force=getattr(args, "force", False),
+    )
+    print(f"  Agent: {agent}")
+
+    print("\nHook installation complete.")

llm_wiki_cli/commands/init_cmd.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from pathlib import Path
+
+from ..config import CLI_AGENTS, DEFAULT_WIKI_DIR, get_agent_config_path, validate_path, write_config
+from ..services.io import read_md, write_md
+from ..services.schema import (
+    CONSTRAINT_START as _CONSTRAINT_START,
+    SCHEMA_FILENAMES,
+    build_schema_content as _build_schema_content,
+)
+
+
+# Agents that have a real CLI executable (used by trigger-agent / install-hook)
+_CLI_AGENTS = CLI_AGENTS
+
+
+def run(args):
+    wiki_dir = getattr(args, "wiki_dir", DEFAULT_WIKI_DIR)
+    validate_path(wiki_dir, "--wiki-dir")
+    print(f"Initializing LLM Wiki with {args.agent} schema...")
+
+    # Warn if the agent has a CLI executable that isn't installed
+    executable = _CLI_AGENTS.get(args.agent)
+    if executable and not shutil.which(executable):
+        print(
+            f"\nWarning: '{executable}' is not installed or not on PATH.\n"
+            f"The schema file will be created, but background auto-sync\n"
+            f"(`llm-wiki trigger-agent --agent {args.agent}`) will not work\n"
+            f"until '{executable}' is installed.\n"
+        )
+
+    
+    # 1. Create directory structure
+    base_dir = Path(wiki_dir)
+    directories = [
+        base_dir,
+        base_dir / "entities",
+        base_dir / "modules",
+        base_dir / "workflows",
+        base_dir / "infrastructure",
+    ]
+    
+    try:
+        for d in directories:
+            d.mkdir(parents=True, exist_ok=True)
+            # Create empty .gitkeep so git tracks empty dirs
+            (d / ".gitkeep").touch()
+    except OSError as exc:
+        print(f"Error creating wiki directories: {exc}")
+        sys.exit(1)
+        
+    print(f"Created wiki directories in {base_dir}/")
+    
+    # 2. Create core files if they don't exist
+    index_path = base_dir / "index.md"
+    if not index_path.exists():
+        write_md(index_path, "# LLM Wiki Index\n\nCatalog of project modules and entities.\n\n## Entities\n\n## Modules\n\n## Workflows\n\n## Infrastructure\n")
+            
+    log_path = base_dir / "log.md"
+    if not log_path.exists():
+        write_md(log_path, "# Architectural Log\n\nAppend-only chronological log.\n\n")
+
+    # 3. Create or Append to Agent Schema
+    quality_hints = not getattr(args, "no_quality_hints", False)
+    filename = SCHEMA_FILENAMES.get(args.agent)
+    if filename:
+        schema_path = Path(filename)
+        # ensure parent exists (e.g. for .github/)
+        schema_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        content_to_add = _build_schema_content(args.agent, wiki_dir, quality_hints=quality_hints)
+        
+        if schema_path.exists():
+            existing_content = read_md(schema_path)
+                
+            if _CONSTRAINT_START not in existing_content:
+                write_md(schema_path, existing_content + "\n\n" + content_to_add)
+                print(f"Appended agent constraints to existing file: {schema_path}")
+            else:
+                print(f"Agent constraints already exist in {schema_path}, skipping append.")
+        else:
+            write_md(schema_path, content_to_add)
+            print(f"Created agent schema file: {schema_path}")
+    
+    # 4. Persist the chosen agent so install-hook can read it
+    write_config(base_dir, {"agent": args.agent, "quality_hints": quality_hints})
+
+    print("LLM Wiki initialized successfully.")

llm_wiki_cli/commands/lint_cmd.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+import os
+import re
+import sys
+from pathlib import Path
+
+from .extract_cmd import get_call_graph, get_docker_inventory, get_inventory_result, print_inventory_failures
+from .bootstrap_cmd import build_module_page_map, build_entity_page_map
+from ..config import validate_path
+from ..services.io import read_md
+
+# basic regex for [text](url)
+LINK_RE = re.compile(r'\[.+?\]\((.+?)\)')
+
+
+def _local_link_path(link: str) -> str | None:
+    """Return the file portion of a local markdown link, or None if ignored."""
+    if link.startswith(("http://", "https://", "mailto:", "#")):
+        return None
+    base, _sep, _anchor = link.partition("#")
+    if not base:
+        return None
+    return base
+
+
+def _is_legacy_page(path: Path, wiki_dir: Path) -> bool:
+    """Return True for archived migration pages that lint should ignore."""
+    try:
+        return path.relative_to(wiki_dir).parts[:1] == ("legacy",)
+    except ValueError:
+        try:
+            return path.resolve().relative_to(wiki_dir.resolve()).parts[:1] == ("legacy",)
+        except ValueError:
+            return False
+
+
+def _collect_documented_entities(wiki_dir: Path) -> set[str]:
+    """Return the set of entity names that have wiki pages."""
+    entities_dir = wiki_dir / "entities"
+    if not entities_dir.exists():
+        return set()
+    return {p.stem for p in entities_dir.glob("*.md")}
+
+
+def _collect_code_classes(inventory_or_src_dir) -> set[str]:
+    """Return the set of entity page names found by AST scanning.
+
+    Uses collision-aware naming so that duplicate class names across
+    different modules are qualified (e.g. ``parser_Parser``).
+    """
+    inventory = (
+        inventory_or_src_dir
+        if isinstance(inventory_or_src_dir, dict)
+        else get_inventory_result(inventory_or_src_dir).inventory
+    )
+    entity_map = build_entity_page_map(inventory)
+    return set(entity_map.values())
+
+
+def _collect_documented_modules(wiki_dir: Path) -> set[str]:
+    """Return the set of module names that have wiki pages."""
+    modules_dir = wiki_dir / "modules"
+    if not modules_dir.exists():
+        return set()
+    return {p.stem for p in modules_dir.glob("*.md")}
+
+
+def _collect_code_modules(inventory_or_src_dir) -> set[str]:
+    """Return the set of module page names with tracked components.
+
+    Uses collision-aware naming so that duplicate file stems across
+    different directories are qualified (e.g. ``pkg_a_cli``).
+    """
+    inventory = (
+        inventory_or_src_dir
+        if isinstance(inventory_or_src_dir, dict)
+        else get_inventory_result(inventory_or_src_dir).inventory
+    )
+    mod_map = build_module_page_map(inventory)
+    return set(mod_map.values())
+
+
+def _collect_documented_workflows(wiki_dir: Path) -> set[str]:
+    """Return the set of workflow names that have wiki pages."""
+    workflows_dir = wiki_dir / "workflows"
+    if not workflows_dir.exists():
+        return set()
+    return {p.stem for p in workflows_dir.glob("*.md")}
+
+
+def _collect_documented_infrastructure(wiki_dir: Path) -> set[str]:
+    """Return the set of infrastructure page names that have wiki pages."""
+    infra_dir = wiki_dir / "infrastructure"
+    if not infra_dir.exists():
+        return set()
+    return {p.stem for p in infra_dir.glob("*.md")}
+
+
+def _collect_docker_files(docker_inventory_or_src_dir) -> set[str]:
+    """Return the set of Docker/Compose file page-names found in source."""
+    docker_inv = (
+        docker_inventory_or_src_dir
+        if isinstance(docker_inventory_or_src_dir, dict)
+        else get_docker_inventory(docker_inventory_or_src_dir)
+    )
+    return {f.replace("\\", "/").replace("/", "_").replace(".", "_") for f in docker_inv}
+
+
+def run(args):
+    wiki_dir = Path(args.wiki_dir)
+    src_dir = getattr(args, "src_dir", ".")
+    validate_path(str(wiki_dir), "--wiki-dir")
+    validate_path(src_dir, "--src-dir")
+    issues = 0
+
+    print(f"Linting Wiki at: {wiki_dir}")
+
+    if not wiki_dir.exists():
+        print(f"Error: Directory {wiki_dir} does not exist.")
+        sys.exit(1)
+
+    inventory_result = get_inventory_result(src_dir, deep=True)
+    if inventory_result.failed:
+        print_inventory_failures(inventory_result)
+        sys.exit(1)
+    deep_inventory = inventory_result.inventory
+    docker_inventory = get_docker_inventory(src_dir)
+
+    pages = [
+        page for page in wiki_dir.rglob("*.md")
+        if not _is_legacy_page(page, wiki_dir)
+    ]
+
+    # ── 1. Broken Links ──────────────────────────────────────────────
+    broken_links = 0
+    for page in pages:
+        content = read_md(page)
+        links = LINK_RE.findall(content)
+
+        for link in links:
+            local_path = _local_link_path(link)
+            if local_path is None:
+                continue
+            target = (page.parent / local_path).resolve()
+            if not target.exists():
+                print(f"  ❌ Broken link in {page.relative_to(wiki_dir)} -> {link}")
+                broken_links += 1
+
+    issues += broken_links
+    if broken_links:
+        print(f"  Found {broken_links} broken link(s).\n")
+    else:
+        print("  ✅ No broken links.\n")
+
+    # ── 2. Orphan Pages (not referenced in index.md) ─────────────────
+    orphan_count = 0
+    index_path = wiki_dir / "index.md"
+    referenced_files: list[Path] = []
+    if index_path.exists():
+        index_content = read_md(index_path)
+        index_links = LINK_RE.findall(index_content)
+
+        for link in index_links:
+            local_path = _local_link_path(link)
+            if local_path is not None:
+                target = (index_path.parent / local_path).resolve()
+                referenced_files.append(target)
+
+        for page in pages:
+            if page.name in ["index.md", "log.md"]:
+                continue
+            if page.resolve() not in referenced_files:
+                print(f"  ⚠️  Orphan page (not in index.md): {page.relative_to(wiki_dir)}")
+                orphan_count += 1
+
+    issues += orphan_count
+    if orphan_count:
+        print(f"  Found {orphan_count} orphan page(s).\n")
+    else:
+        print("  ✅ No orphan pages.\n")
+
+    # ── 3. AST ↔ Wiki Cross-Reference (entities) ─────────────────────
+    documented_entities = _collect_documented_entities(wiki_dir)
+    code_classes = _collect_code_classes(deep_inventory)
+
+    undocumented = code_classes - documented_entities
+    stale = documented_entities - code_classes
+
+    if undocumented:
+        for name in sorted(undocumented):
+            print(f"  ⚠️  Undocumented class (in code, not in wiki): {name}")
+        issues += len(undocumented)
+        print(f"  Found {len(undocumented)} undocumented class(es).\n")
+    else:
+        print("  ✅ All classes documented.\n")
+
+    if stale:
+        for name in sorted(stale):
+            print(f"  ⚠️  Stale entity (in wiki, not in code): {name}")
+        issues += len(stale)
+        print(f"  Found {len(stale)} stale entity page(s).\n")
+    else:
+        print("  ✅ No stale entity pages.\n")
+
+    # ── 4. AST ↔ Wiki Cross-Reference (modules) ──────────────────────
+    documented_modules = _collect_documented_modules(wiki_dir)
+    code_modules = _collect_code_modules(deep_inventory)
+
+    undoc_mods = code_modules - documented_modules
+    stale_mods = documented_modules - code_modules
+
+    if undoc_mods:
+        for name in sorted(undoc_mods):
+            print(f"  ⚠️  Undocumented module (in code, not in wiki): {name}")
+        issues += len(undoc_mods)
+        print(f"  Found {len(undoc_mods)} undocumented module(s).\n")
+    else:
+        print("  ✅ All modules documented.\n")
+
+    if stale_mods:
+        for name in sorted(stale_mods):
+            print(f"  ⚠️  Stale module (in wiki, not in code): {name}")
+        issues += len(stale_mods)
+        print(f"  Found {len(stale_mods)} stale module page(s).\n")
+    else:
+        print("  ✅ No stale module pages.\n")
+
+    # ── 5. Workflow checks ────────────────────────────────────────────
+    documented_workflows = _collect_documented_workflows(wiki_dir)
+
+    # 5a. Check workflow pages reference existing modules
+    workflows_dir = wiki_dir / "workflows"
+    stale_wf = 0
+    if workflows_dir.exists():
+        for wf_page in workflows_dir.glob("*.md"):
+            content = read_md(wf_page)
+            links = LINK_RE.findall(content)
+            for link in links:
+                local_path = _local_link_path(link)
+                if local_path is None:
+                    continue
+                target = (wf_page.parent / local_path).resolve()
+                if not target.exists():
+                    print(f"  ⚠️  Broken link in workflow {wf_page.stem} -> {link}")
+                    stale_wf += 1
+
+    issues += stale_wf
+    if stale_wf:
+        print(f"  Found {stale_wf} broken workflow link(s).\n")
+    else:
+        print("  ✅ No broken workflow links.\n")
+
+    # 5b. Detect missing workflows (call chains with 3+ modules but no page)
+    detected_workflows = set(get_call_graph(deep_inventory).keys())
+
+    missing_wf = detected_workflows - documented_workflows
+    if missing_wf:
+        for name in sorted(missing_wf):
+            print(f"  ⚠️  Missing workflow (detected in code, no wiki page): {name}")
+        issues += len(missing_wf)
+        print(f"  Found {len(missing_wf)} missing workflow(s).\n")
+    else:
+        print("  ✅ All detected workflows documented.\n")
+
+    # ── 6. Infrastructure checks (Docker/Compose) ────────────────────
+    documented_infra = _collect_documented_infrastructure(wiki_dir)
+    code_docker = _collect_docker_files(docker_inventory)
+
+    undoc_infra = code_docker - documented_infra
+    stale_infra = documented_infra - code_docker
+
+    if undoc_infra:
+        for name in sorted(undoc_infra):
+            print(f"  ⚠️  Undocumented Docker file (in source, not in wiki): {name}")
+        issues += len(undoc_infra)
+        print(f"  Found {len(undoc_infra)} undocumented Docker file(s).\n")
+    else:
+        print("  ✅ All Docker/Compose files documented.\n")
+
+    if stale_infra:
+        for name in sorted(stale_infra):
+            print(f"  ⚠️  Stale infrastructure page (in wiki, source file removed): {name}")
+        issues += len(stale_infra)
+        print(f"  Found {len(stale_infra)} stale infrastructure page(s).\n")
+    else:
+        print("  ✅ No stale infrastructure pages.\n")
+
+    # ── Summary ───────────────────────────────────────────────────────
+    if issues == 0:
+        print("✅ Lint passed: wiki is fully consistent.")
+    else:
+        print(f"❌ Lint found {issues} issue(s).")
+        sys.exit(1)