@jakkrichm/create-nexus-devflow 2.0.0

package/template/.agents/skills/intelligent-routing/SKILL.md

@@ -0,0 +1,176 @@
+---
+name: intelligent-routing
+description: Automatic agent and stage routing for DevFlow 2.0. Use when deciding which active workflow, skill, or specialist should own the next step.
+version: 2.0.0
+---
+
+# Intelligent Routing For DevFlow 2.0
+
+## Purpose
+
+Analyze a user request and route it to the correct DevFlow 2.0 surface without requiring the user to name the exact workflow, skill, or agent.
+
+## Canonical Routing Order
+
+Always route in this order:
+
+1. Mainline stage if the request is lifecycle work
+2. Public companion command if the request is support work
+3. Specialist agent if the user needs focused expert judgment
+4. Internal companion or skill only when the public surface should stay thin
+
+Do not route new work into retired JSON-first commands, dashboard-first flows, or removed aliases.
+
+When routing to support skills, follow `docs/skill-selection-policy.md`.
+
+## Timeline Stages
+
+`/00-Discover -> /10-Define -> /20-Spec -> /30-Plan -> /40-Implement -> /50-Verify -> /60-Report -> /70-Release`
+
+## Public Companion Commands
+
+- `Goal`
+- `Brainstorm`
+- `Research`
+- `Debug`
+- `PRD`
+- `Issue-Triage`
+- `Wiki`
+- `Check-For-Updates`
+- `Help`
+
+## Specialist Agent Routing
+
+Use these agent mappings when expert judgment is the best next step:
+
+| Request Type | Route To |
+|---|---|
+| requirements clarification | `requirements-engineer` |
+| product framing | `prp-core-prd-architect` |
+| planning breakdown | `prp-core-planner` |
+| codebase exploration | `codebase-explorer` |
+| backend implementation or API review | `backend-specialist` |
+| frontend implementation or UI review | `frontend-specialist` |
+| schema and query design | `database-architect` |
+| implementation execution | `prp-core-coder` |
+| tests and coverage | `test-engineer` |
+| code review and risk review | `code-reviewer` |
+| security review | `security-auditor` |
+| performance review | `performance-engineer` |
+| root-cause debugging | `prp-core-debugger` |
+| release packaging and commit scope | `prp-core-git-committer`, `prp-core-git-pr-maker` |
+| broad orchestration across domains | `orchestrator` |
+| overnight maintenance loops and repo cleanup | `ob-loop-engineer` |
+
+## Lifecycle Routing Rules
+
+| User State | Recommended Route |
+|---|---|
+| new request, vague or clear | `/00-Discover`; it selects support inquiry and owns the delivery decision |
+| approved discovery needs one or more delivery boundaries | `/10-Define {discovery_id}` |
+| needs requirements and acceptance criteria | `/20-Spec` |
+| has a stable spec and needs execution plan | `/30-Plan` |
+| needs implementation work | `/40-Implement` |
+| needs testing, review, or validation evidence | `/50-Verify` |
+| needs packaging, commit, PR, or release handling | `/70-Release` |
+| needs the final summary or handoff narrative | `/60-Report` |
+
+## Routing Heuristics
+
+### Use a Timeline stage when:
+
+- the request advances a task through its lifecycle
+- the user needs an artifact in `.workspaces`
+- the next step should change stage ownership
+
+### Use a public companion command when:
+
+- the request supports a stage rather than replacing it
+- the user needs exploration, research, debugging, or help
+- the output is advisory or investigative
+
+### Use an internal clarification skill when:
+
+- the current stage is blocked by ambiguity, not by missing execution effort
+- a small amount of user interaction could change scope, acceptance criteria, or planning decisions
+- the public surface should stay the same and the questioning method is only supporting the active stage
+
+If `grill-with-docs` is available in the current environment, prefer it as an optional internal support skill for:
+
+- `/10-Define` when scope or terminology is unstable
+- `/20-Spec` when acceptance criteria or rules are ambiguous
+- `/30-Plan` when architecture or verification choices are still reversible but unclear
+
+Do not use deep questioning by default in every stage. Collect only the information that affects the current Timeline-stage decision.
+
+### Use an internal clarification skill when:
+
+- the current stage is blocked by ambiguity, not by missing execution effort
+- a small amount of user interaction could change scope, acceptance criteria, or planning decisions
+- the public surface should stay the same and the questioning method is only supporting the active stage
+
+If `grill-with-docs` is available in the current environment, prefer it as an optional internal support skill for:
+
+- `/10-Define` when scope or terminology is unstable
+- `/20-Spec` when acceptance criteria or rules are ambiguous
+- `/30-Plan` when architecture or verification choices are still reversible but unclear
+
+Do not use deep questioning by default in every stage. Collect only the information that affects the current stage decision.
+
+### Use a specialist agent when:
+
+- the user explicitly asks for one
+- a narrow expert lens is more useful than a workflow shell
+- the active stage already exists and only specialist judgment is missing
+
+### Use a support skill when:
+
+- a mainline stage or public companion already owns the work
+- the skill resolves a bounded uncertainty inside that owner
+- the skill is more specific than the general companion surface
+- the skill output can be captured in the owning stage artifact, `CONTEXT.md`, an ADR, or a focused doc
+
+Support skill limits:
+
+- choose one primary skill per pass
+- add at most two secondary skills when each has a distinct purpose
+- prefer the most specific skill when descriptions overlap
+- route back to the owning stage when a skill finds a lifecycle-level contradiction
+
+Key conflict defaults:
+
+| Conflict | Route |
+|---|---|
+| `Brainstorm` vs `grilling` | `Brainstorm` for option generation; `grilling` for stress-testing a candidate idea |
+| `grilling` vs `grill-with-docs` | `grill-with-docs` when a codebase or durable docs matter |
+| `grill-with-docs` vs `domain-modeling` | `grill-with-docs` interviews; `domain-modeling` records confirmed glossary terms or ADRs |
+| `to-prd` vs `PRD` | `PRD` owns the public surface; `to-prd` is an internal synthesis method |
+| `to-issues` vs `/30-Plan` | `/30-Plan` owns work breakdown; `to-issues` packages slices when issue tracker output is needed |
+| `implement` vs `/40-Implement` | `/40-Implement` owns implementation |
+| `review` vs `/50-Verify` | `/50-Verify` owns verification; `review` is one lane |
+
+## Examples
+
+| User Request | Route |
+|---|---|
+| "I have an idea but not the shape yet" | `/00-Discover`, likely `Brainstorm`, then return to Discover |
+| "Turn this stable new goal into requirements" | `/00-Discover`, then `/10-Define {discovery_id}` before `/20-Spec {running_id}` |
+| "Fix this newly reported broken auth flow" | `/00-Discover`, likely `Debug`, then return to Discover before Define |
+| "Review this implementation for risks" | `/50-Verify` or `Agent code-reviewer ...` |
+| "Install or upgrade Nexus-DevFlow on this machine" | `Check-For-Updates` |
+| "Help me figure out which command to use" | `Help` |
+
+## Guardrails
+
+- Do not recommend removed numeric aliases such as old task/code/verify commands.
+- Do not mention legacy external control files as part of the routing model.
+- Do not invent agent names that are not present in the current repo.
+- If the request spans multiple domains and the owner is unclear, route to `orchestrator`.
+- If clarification is needed, ask only for information that can change the active stage decision.
+- If clarification is needed, ask only for information that can change the active stage decision.
+
+## Output Pattern
+
+When applying this skill, answer in one short line before proceeding:
+
+`Applying DevFlow 2.0 routing: <chosen route> because <reason>.`

package/template/.agents/skills/issue-triage/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: issue-triage
+description: Issue-Triage workflow
+---
+
+---
+description: Issue Triage Addon - Analyze GitHub issues, detect duplicates or spam, and route actionable work into DevFlow workflows.
+---
+
+# Phase 57: Issue Triage Addon
+
+## Target: $ARGUMENTS
+
+Use this workflow to evaluate GitHub issues, bug reports, feature requests, support requests, duplicates, or noisy reports before creating or resuming work.
+Use `triage` as the support skill for classification, verification, and agent-ready briefs. Use `to-issues` only when a stable spec or PRD must be packaged into vertical slices.
+
+## Prompt Sources
+
+Adapted from:
+
+- `github/issue_analyzer.md`
+- `github/issue_triager.md`
+- `github/duplicate_detector.md`
+- `github/spam_detector.md`
+- `github/pr_ai_triage.md`
+
+## Process
+
+### 1. Read Issue Context
+
+Collect:
+
+- issue title and body
+- comments and maintainer notes
+- labels and linked PRs
+- reproduction steps
+- affected versions or environment
+- related files, logs, screenshots, or references
+
+### 2. Triage
+
+Classify the issue:
+
+- bug
+- feature request
+- documentation request
+- question or support
+- duplicate
+- spam or noise
+- needs more information
+
+Assess:
+
+- severity
+- user impact
+- reproducibility
+- affected area
+- confidence
+
+Separate:
+
+- what is already evidenced
+- what is inferred
+- what still needs proof
+
+### 3. Create Issue Triage Report
+
+- **MANDATORY:** Before generating the final report, inspect `.agent/resources/schemas/triage.template.md` for layout, required sections, and format.
+- Before reporting completion, run:
+
+Review `{report_path}` against `triage.template.md`, keep the required headings, and remove placeholder text before completion.
+
+- Replace any placeholder or template text with concrete issue summary, classification, impact, routing decision, and next command.
+- Save the final report to:
+
+```text
+devflow/issues/{date}-triage-{issue_number}.md
+```
+
+### 4. Route
+
+Use:
+
+- `Debug` for confirmed bugs needing root cause work
+- `Research` or `Spec-Research` for external dependency uncertainty
+- `PRD` for product-level feature requests that need problem framing
+- `/10-Define` for actionable work that still needs scope decisions
+- `/20-Spec` for work that is already stable enough to become a delivery contract
+- `Help` when the issue is not actionable yet
+
+## Output Triage Recommendation
+
+Return:
+
+- classification
+- duplicate or spam assessment
+- confidence level
+- recommended route into DevFlow 2.0
+- where the report was written
+
+## Relationship To DevFlow 2.0
+
+- Classification: Companion command
+- Mainline status: Intake support command, not a numbered stage
+- Typical entry points: issue intake before scope or implementation begins
+- Typical handoff targets: `Debug`, `PRD`, `/10-Define`, `Research`, `Help`
+
+## Sources
+
+- `AGENTS.md`
+- `.agent/resources/schemas/triage.template.md`
+- Related commands: `Debug`, `PRD`, `/10-Define`, `Research`, `Help`
+- Support skills: `triage`, `to-issues`, `domain-modeling`
+
+

package/template/.agents/skills/lint-and-validate/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: lint-and-validate
+description: Automatic quality control, linting, and static analysis procedures. Use after every code modification to ensure syntax correctness and project standards. Triggers onKeywords: lint, format, check, validate, types, static analysis.
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+# Lint and Validate Skill
+
+> **MANDATORY:** Run appropriate validation tools after EVERY code change. Do not finish a task until the code is error-free.
+
+### Procedures by Ecosystem
+
+#### Node.js / TypeScript
+1. **Lint/Fix:** `npm run lint` or `npx eslint "path" --fix`
+2. **Types:** `npx tsc --noEmit`
+3. **Security:** `npm audit --audit-level=high`
+
+#### Python
+1. **Linter (Ruff):** `ruff check "path" --fix` (Fast & Modern)
+2. **Security (Bandit):** `bandit -r "path" -ll`
+3. **Types (MyPy):** `mypy "path"`
+
+## The Quality Loop
+1. **Write/Edit Code**
+2. **Run Audit:** `npm run lint && npx tsc --noEmit`
+3. **Analyze Report:** Check the "FINAL AUDIT REPORT" section.
+4. **Fix & Repeat:** Submitting code with "FINAL AUDIT" failures is NOT allowed.
+
+## Error Handling
+- If `lint` fails: Fix the style or syntax issues immediately.
+- If `tsc` fails: Correct type mismatches before proceeding.
+- If no tool is configured: Check the project root for `.eslintrc`, `tsconfig.json`, `pyproject.toml` and suggest creating one.
+
+---
+**Strict Rule:** No code should be committed or reported as "done" without passing these checks.
+
+---
+
+## Scripts
+
+| Script | Purpose | Command |
+|--------|---------|---------|
+| `scripts/lint_runner.py` | Unified lint check | `python scripts/lint_runner.py <project_path>` |
+| `scripts/type_coverage.py` | Type coverage analysis | `python scripts/type_coverage.py <project_path>` |
+

package/template/.agents/skills/lint-and-validate/scripts/lint_runner.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Lint Runner - Unified linting and type checking
+Runs appropriate linters based on project type.
+
+Usage:
+    python lint_runner.py <project_path>
+
+Supports:
+    - Node.js: npm run lint, npx tsc --noEmit
+    - Python: ruff check, mypy
+"""
+
+import subprocess
+import sys
+import json
+import platform
+import shutil
+from pathlib import Path
+from datetime import datetime
+
+# Fix Windows console encoding
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+except:
+    pass
+
+
+def detect_project_type(project_path: Path) -> dict:
+    """Detect project type and available linters."""
+    result = {
+        "type": "unknown",
+        "linters": []
+    }
+    
+    # Node.js project
+    package_json = project_path / "package.json"
+    if package_json.exists():
+        result["type"] = "node"
+        try:
+            pkg = json.loads(package_json.read_text(encoding='utf-8'))
+            scripts = pkg.get("scripts", {})
+            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
+            
+            # Check for lint script
+            if "lint" in scripts:
+                result["linters"].append({"name": "npm lint", "cmd": ["npm", "run", "lint"]})
+            elif "eslint" in deps:
+                result["linters"].append({"name": "eslint", "cmd": ["npx", "eslint", "."]})
+            
+            # Check for TypeScript
+            if "typescript" in deps or (project_path / "tsconfig.json").exists():
+                result["linters"].append({"name": "tsc", "cmd": ["npx", "tsc", "--noEmit"]})
+                
+        except:
+            pass
+    
+    # Python project
+    if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
+        result["type"] = "python"
+        
+        # Check for ruff
+        result["linters"].append({"name": "ruff", "cmd": ["ruff", "check", "."]})
+        
+        # Check for mypy
+        if (project_path / "mypy.ini").exists() or (project_path / "pyproject.toml").exists():
+            result["linters"].append({"name": "mypy", "cmd": ["mypy", "."]})
+    
+    return result
+
+
+def run_linter(linter: dict, cwd: Path) -> dict:
+    """Run a single linter and return results."""
+    result = {
+        "name": linter["name"],
+        "passed": False,
+        "output": "",
+        "error": ""
+    }
+    
+    try:
+        cmd = linter["cmd"]
+        
+        # Windows compatibility for npm/npx
+        if platform.system() == "Windows":
+            if cmd[0] in ["npm", "npx"]:
+                # Force .cmd extension on Windows
+                if not cmd[0].lower().endswith(".cmd"):
+                    cmd[0] = f"{cmd[0]}.cmd"
+        
+        proc = subprocess.run(
+            cmd,
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            timeout=120,
+            shell=platform.system() == "Windows" # Shell=True often helps with path resolution on Windows
+        )
+        
+        result["output"] = proc.stdout[:2000] if proc.stdout else ""
+        result["error"] = proc.stderr[:500] if proc.stderr else ""
+        result["passed"] = proc.returncode == 0
+        
+    except FileNotFoundError:
+        result["error"] = f"Command not found: {linter['cmd'][0]}"
+    except subprocess.TimeoutExpired:
+        result["error"] = "Timeout after 120s"
+    except Exception as e:
+        result["error"] = str(e)
+    
+    return result
+
+
+def main():
+    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
+    
+    print(f"\n{'='*60}")
+    print(f"[LINT RUNNER] Unified Linting")
+    print(f"{'='*60}")
+    print(f"Project: {project_path}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # Detect project type
+    project_info = detect_project_type(project_path)
+    print(f"Type: {project_info['type']}")
+    print(f"Linters: {len(project_info['linters'])}")
+    print("-"*60)
+    
+    if not project_info["linters"]:
+        print("No linters found for this project type.")
+        output = {
+            "script": "lint_runner",
+            "project": str(project_path),
+            "type": project_info["type"],
+            "checks": [],
+            "passed": True,
+            "message": "No linters configured"
+        }
+        print(json.dumps(output, indent=2))
+        sys.exit(0)
+    
+    # Run each linter
+    results = []
+    all_passed = True
+    
+    for linter in project_info["linters"]:
+        print(f"\nRunning: {linter['name']}...")
+        result = run_linter(linter, project_path)
+        results.append(result)
+        
+        if result["passed"]:
+            print(f"  [PASS] {linter['name']}")
+        else:
+            print(f"  [FAIL] {linter['name']}")
+            if result["error"]:
+                print(f"  Error: {result['error'][:200]}")
+            all_passed = False
+    
+    # Summary
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    
+    for r in results:
+        icon = "[PASS]" if r["passed"] else "[FAIL]"
+        print(f"{icon} {r['name']}")
+    
+    output = {
+        "script": "lint_runner",
+        "project": str(project_path),
+        "type": project_info["type"],
+        "checks": results,
+        "passed": all_passed
+    }
+    
+    print("\n" + json.dumps(output, indent=2))
+    
+    sys.exit(0 if all_passed else 1)
+
+
+if __name__ == "__main__":
+    main()

package/template/.agents/skills/lint-and-validate/scripts/type_coverage.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+Type Coverage Checker - Measures TypeScript/Python type coverage.
+Identifies untyped functions, any usage, and type safety issues.
+"""
+import sys
+import re
+import subprocess
+from pathlib import Path
+
+# Fix Windows console encoding for Unicode output
+try:
+    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+except AttributeError:
+    pass  # Python < 3.7
+
+def check_typescript_coverage(project_path: Path) -> dict:
+    """Check TypeScript type coverage."""
+    issues = []
+    passed = []
+    stats = {'any_count': 0, 'untyped_functions': 0, 'total_functions': 0}
+    
+    ts_files = list(project_path.rglob("*.ts")) + list(project_path.rglob("*.tsx"))
+    ts_files = [f for f in ts_files if 'node_modules' not in str(f) and '.d.ts' not in str(f)]
+    
+    if not ts_files:
+        return {'type': 'typescript', 'files': 0, 'passed': [], 'issues': ["[!] No TypeScript files found"], 'stats': stats}
+    
+    for file_path in ts_files[:30]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            
+            # Count 'any' usage
+            any_matches = re.findall(r':\s*any\b', content)
+            stats['any_count'] += len(any_matches)
+            
+            # Find functions without return types
+            # function name(params) { - no return type
+            untyped = re.findall(r'function\s+\w+\s*\([^)]*\)\s*{', content)
+            # Arrow functions without types: const fn = (x) => or (x) =>
+            untyped += re.findall(r'=\s*\([^:)]*\)\s*=>', content)
+            stats['untyped_functions'] += len(untyped)
+            
+            # Count typed functions
+            typed = re.findall(r'function\s+\w+\s*\([^)]*\)\s*:\s*\w+', content)
+            typed += re.findall(r':\s*\([^)]*\)\s*=>\s*\w+', content)
+            stats['total_functions'] += len(typed) + len(untyped)
+            
+        except Exception:
+            continue
+    
+    # Analyze results
+    if stats['any_count'] == 0:
+        passed.append("[OK] No 'any' types found")
+    elif stats['any_count'] <= 5:
+        issues.append(f"[!] {stats['any_count']} 'any' types found (acceptable)")
+    else:
+        issues.append(f"[X] {stats['any_count']} 'any' types found (too many)")
+    
+    if stats['total_functions'] > 0:
+        typed_ratio = (stats['total_functions'] - stats['untyped_functions']) / stats['total_functions'] * 100
+        if typed_ratio >= 80:
+            passed.append(f"[OK] Type coverage: {typed_ratio:.0f}%")
+        elif typed_ratio >= 50:
+            issues.append(f"[!] Type coverage: {typed_ratio:.0f}% (improve)")
+        else:
+            issues.append(f"[X] Type coverage: {typed_ratio:.0f}% (too low)")
+    
+    passed.append(f"[OK] Analyzed {len(ts_files)} TypeScript files")
+    
+    return {'type': 'typescript', 'files': len(ts_files), 'passed': passed, 'issues': issues, 'stats': stats}
+
+def check_python_coverage(project_path: Path) -> dict:
+    """Check Python type hints coverage."""
+    issues = []
+    passed = []
+    stats = {'untyped_functions': 0, 'typed_functions': 0, 'any_count': 0}
+    
+    py_files = list(project_path.rglob("*.py"))
+    py_files = [f for f in py_files if not any(x in str(f) for x in ['venv', '__pycache__', '.git', 'node_modules'])]
+    
+    if not py_files:
+        return {'type': 'python', 'files': 0, 'passed': [], 'issues': ["[!] No Python files found"], 'stats': stats}
+    
+    for file_path in py_files[:30]:  # Limit
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            
+            # Count Any usage
+            any_matches = re.findall(r':\s*Any\b', content)
+            stats['any_count'] += len(any_matches)
+            
+            # Find functions with type hints
+            typed_funcs = re.findall(r'def\s+\w+\s*\([^)]*:[^)]+\)', content)
+            typed_funcs += re.findall(r'def\s+\w+\s*\([^)]*\)\s*->', content)
+            stats['typed_functions'] += len(typed_funcs)
+            
+            # Find functions without type hints
+            all_funcs = re.findall(r'def\s+\w+\s*\(', content)
+            stats['untyped_functions'] += len(all_funcs) - len(typed_funcs)
+            
+        except Exception:
+            continue
+    
+    total = stats['typed_functions'] + stats['untyped_functions']
+    
+    if total > 0:
+        typed_ratio = stats['typed_functions'] / total * 100
+        if typed_ratio >= 70:
+            passed.append(f"[OK] Type hints coverage: {typed_ratio:.0f}%")
+        elif typed_ratio >= 40:
+            issues.append(f"[!] Type hints coverage: {typed_ratio:.0f}%")
+        else:
+            issues.append(f"[X] Type hints coverage: {typed_ratio:.0f}% (add type hints)")
+    
+    if stats['any_count'] == 0:
+        passed.append("[OK] No 'Any' types found")
+    elif stats['any_count'] <= 3:
+        issues.append(f"[!] {stats['any_count']} 'Any' types found")
+    else:
+        issues.append(f"[X] {stats['any_count']} 'Any' types found")
+    
+    passed.append(f"[OK] Analyzed {len(py_files)} Python files")
+    
+    return {'type': 'python', 'files': len(py_files), 'passed': passed, 'issues': issues, 'stats': stats}
+
+def main():
+    target = sys.argv[1] if len(sys.argv) > 1 else "."
+    project_path = Path(target)
+    
+    print("\n" + "=" * 60)
+    print("  TYPE COVERAGE CHECKER")
+    print("=" * 60 + "\n")
+    
+    results = []
+    
+    # Check TypeScript
+    ts_result = check_typescript_coverage(project_path)
+    if ts_result['files'] > 0:
+        results.append(ts_result)
+    
+    # Check Python
+    py_result = check_python_coverage(project_path)
+    if py_result['files'] > 0:
+        results.append(py_result)
+    
+    if not results:
+        print("[!] No TypeScript or Python files found.")
+        sys.exit(0)
+    
+    # Print results
+    critical_issues = 0
+    for result in results:
+        print(f"\n[{result['type'].upper()}]")
+        print("-" * 40)
+        for item in result['passed']:
+            print(f"  {item}")
+        for item in result['issues']:
+            print(f"  {item}")
+            if item.startswith("[X]"):
+                critical_issues += 1
+    
+    print("\n" + "=" * 60)
+    if critical_issues == 0:
+        print("[OK] TYPE COVERAGE: ACCEPTABLE")
+        sys.exit(0)
+    else:
+        print(f"[X] TYPE COVERAGE: {critical_issues} critical issues")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()