@infandev/agent-kit 1.0.0

package/.agent/scripts/verify_all.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""
+Full Verification Suite - Antigravity Kit
+==========================================
+
+Runs COMPLETE validation including all checks + performance + E2E.
+Use this before deployment or major releases.
+
+Usage:
+    python scripts/verify_all.py . --url <URL>
+
+Includes ALL checks:
+    ✅ Security Scan (OWASP, secrets, dependencies)
+    ✅ Lint & Type Coverage
+    ✅ Schema Validation
+    ✅ Test Suite (unit + integration)
+    ✅ UX Audit (psychology, accessibility)
+    ✅ SEO Check
+    ✅ Lighthouse (Core Web Vitals)
+    ✅ Playwright E2E
+    ✅ Bundle Analysis (if applicable)
+    ✅ Mobile Audit (if applicable)
+"""
+
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+from typing import List, Dict, Optional
+from datetime import datetime
+
+# ANSI colors
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+
+def print_header(text: str):
+    print(f"\n{Colors.BOLD}{Colors.CYAN}{'='*70}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{text.center(70)}{Colors.ENDC}")
+    print(f"{Colors.BOLD}{Colors.CYAN}{'='*70}{Colors.ENDC}\n")
+
+def print_step(text: str):
+    print(f"{Colors.BOLD}{Colors.BLUE}🔄 {text}{Colors.ENDC}")
+
+def print_success(text: str):
+    print(f"{Colors.GREEN}✅ {text}{Colors.ENDC}")
+
+def print_warning(text: str):
+    print(f"{Colors.YELLOW}⚠️  {text}{Colors.ENDC}")
+
+def print_error(text: str):
+    print(f"{Colors.RED}❌ {text}{Colors.ENDC}")
+
+# Complete verification suite
+VERIFICATION_SUITE = [
+    # P0: Security (CRITICAL)
+    {
+        "category": "Security",
+        "checks": [
+            ("Security Scan", ".agent/skills/vulnerability-scanner/scripts/security_scan.py", True),
+            ("Dependency Analysis", ".agent/skills/vulnerability-scanner/scripts/dependency_analyzer.py", False),
+        ]
+    },
+    
+    # P1: Code Quality (CRITICAL)
+    {
+        "category": "Code Quality",
+        "checks": [
+            ("Lint Check", ".agent/skills/lint-and-validate/scripts/lint_runner.py", True),
+            ("Type Coverage", ".agent/skills/lint-and-validate/scripts/type_coverage.py", False),
+        ]
+    },
+    
+    # P2: Data Layer
+    {
+        "category": "Data Layer",
+        "checks": [
+            ("Schema Validation", ".agent/skills/database-design/scripts/schema_validator.py", False),
+        ]
+    },
+    
+    # P3: Testing
+    {
+        "category": "Testing",
+        "checks": [
+            ("Test Suite", ".agent/skills/testing-patterns/scripts/test_runner.py", False),
+        ]
+    },
+    
+    # P4: UX & Accessibility
+    {
+        "category": "UX & Accessibility",
+        "checks": [
+            ("UX Audit", ".agent/skills/frontend-design/scripts/ux_audit.py", False),
+            ("Accessibility Check", ".agent/skills/frontend-design/scripts/accessibility_checker.py", False),
+        ]
+    },
+    
+    # P5: SEO & Content
+    {
+        "category": "SEO & Content",
+        "checks": [
+            ("SEO Check", ".agent/skills/seo-fundamentals/scripts/seo_checker.py", False),
+            ("GEO Check", ".agent/skills/geo-fundamentals/scripts/geo_checker.py", False),
+        ]
+    },
+    
+    # P6: Performance (requires URL)
+    {
+        "category": "Performance",
+        "requires_url": True,
+        "checks": [
+            ("Lighthouse Audit", ".agent/skills/performance-profiling/scripts/lighthouse_audit.py", True),
+            ("Bundle Analysis", ".agent/skills/performance-profiling/scripts/bundle_analyzer.py", False),
+        ]
+    },
+    
+    # P7: E2E Testing (requires URL)
+    {
+        "category": "E2E Testing",
+        "requires_url": True,
+        "checks": [
+            ("Playwright E2E", ".agent/skills/webapp-testing/scripts/playwright_runner.py", False),
+        ]
+    },
+    
+    # P8: Mobile (if applicable)
+    {
+        "category": "Mobile",
+        "checks": [
+            ("Mobile Audit", ".agent/skills/mobile-design/scripts/mobile_audit.py", False),
+        ]
+    },
+    
+    # P9: Internationalization
+    {
+        "category": "Internationalization",
+        "checks": [
+            ("i18n Check", ".agent/skills/i18n-localization/scripts/i18n_checker.py", False),
+        ]
+    },
+]
+
+def run_script(name: str, script_path: Path, project_path: str, url: Optional[str] = None) -> dict:
+    """Run validation script"""
+    if not script_path.exists():
+        print_warning(f"{name}: Script not found, skipping")
+        return {"name": name, "passed": True, "skipped": True, "duration": 0}
+    
+    print_step(f"Running: {name}")
+    start_time = datetime.now()
+    
+    # Build command
+    cmd = ["python", str(script_path), project_path]
+    if url and ("lighthouse" in script_path.name.lower() or "playwright" in script_path.name.lower()):
+        cmd.append(url)
+    
+    # Run
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=600  # 10 minute timeout for slow checks
+        )
+        
+        duration = (datetime.now() - start_time).total_seconds()
+        passed = result.returncode == 0
+        
+        if passed:
+            print_success(f"{name}: PASSED ({duration:.1f}s)")
+        else:
+            print_error(f"{name}: FAILED ({duration:.1f}s)")
+            if result.stderr:
+                print(f"  {result.stderr[:300]}")
+        
+        return {
+            "name": name,
+            "passed": passed,
+            "output": result.stdout,
+            "error": result.stderr,
+            "skipped": False,
+            "duration": duration
+        }
+    
+    except subprocess.TimeoutExpired:
+        duration = (datetime.now() - start_time).total_seconds()
+        print_error(f"{name}: TIMEOUT (>{duration:.0f}s)")
+        return {"name": name, "passed": False, "skipped": False, "duration": duration, "error": "Timeout"}
+    
+    except Exception as e:
+        duration = (datetime.now() - start_time).total_seconds()
+        print_error(f"{name}: ERROR - {str(e)}")
+        return {"name": name, "passed": False, "skipped": False, "duration": duration, "error": str(e)}
+
+def print_final_report(results: List[dict], start_time: datetime):
+    """Print comprehensive final report"""
+    total_duration = (datetime.now() - start_time).total_seconds()
+    
+    print_header("📊 FULL VERIFICATION REPORT")
+    
+    # Statistics
+    total = len(results)
+    passed = sum(1 for r in results if r["passed"] and not r.get("skipped"))
+    failed = sum(1 for r in results if not r["passed"] and not r.get("skipped"))
+    skipped = sum(1 for r in results if r.get("skipped"))
+    
+    print(f"Total Duration: {total_duration:.1f}s")
+    print(f"Total Checks: {total}")
+    print(f"{Colors.GREEN}✅ Passed: {passed}{Colors.ENDC}")
+    print(f"{Colors.RED}❌ Failed: {failed}{Colors.ENDC}")
+    print(f"{Colors.YELLOW}⏭️  Skipped: {skipped}{Colors.ENDC}")
+    print()
+    
+    # Category breakdown
+    print(f"{Colors.BOLD}Results by Category:{Colors.ENDC}")
+    current_category = None
+    for r in results:
+        # Print category header if changed
+        if r.get("category") and r["category"] != current_category:
+            current_category = r["category"]
+            print(f"\n{Colors.BOLD}{Colors.CYAN}{current_category}:{Colors.ENDC}")
+        
+        # Print result
+        if r.get("skipped"):
+            status = f"{Colors.YELLOW}⏭️ {Colors.ENDC}"
+        elif r["passed"]:
+            status = f"{Colors.GREEN}✅{Colors.ENDC}"
+        else:
+            status = f"{Colors.RED}❌{Colors.ENDC}"
+        
+        duration_str = f"({r.get('duration', 0):.1f}s)" if not r.get("skipped") else ""
+        print(f"  {status} {r['name']} {duration_str}")
+    
+    print()
+    
+    # Failed checks detail
+    if failed > 0:
+        print(f"{Colors.BOLD}{Colors.RED}❌ FAILED CHECKS:{Colors.ENDC}")
+        for r in results:
+            if not r["passed"] and not r.get("skipped"):
+                print(f"\n{Colors.RED}✗ {r['name']}{Colors.ENDC}")
+                if r.get("error"):
+                    error_preview = r["error"][:200]
+                    print(f"  Error: {error_preview}")
+        print()
+    
+    # Final verdict
+    if failed > 0:
+        print_error(f"VERIFICATION FAILED - {failed} check(s) need attention")
+        print(f"\n{Colors.YELLOW}💡 Tip: Fix critical (security, lint) issues first{Colors.ENDC}")
+        return False
+    else:
+        print_success("✨ ALL CHECKS PASSED - Ready for deployment! ✨")
+        return True
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run complete Antigravity Kit verification suite",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python scripts/verify_all.py . --url http://localhost:3000
+  python scripts/verify_all.py . --url https://staging.example.com --no-e2e
+        """
+    )
+    parser.add_argument("project", help="Project path to validate")
+    parser.add_argument("--url", required=True, help="URL for performance & E2E checks")
+    parser.add_argument("--no-e2e", action="store_true", help="Skip E2E tests")
+    parser.add_argument("--stop-on-fail", action="store_true", help="Stop on first failure")
+    
+    args = parser.parse_args()
+    
+    project_path = Path(args.project).resolve()
+    
+    if not project_path.exists():
+        print_error(f"Project path does not exist: {project_path}")
+        sys.exit(1)
+    
+    print_header("🚀 ANTIGRAVITY KIT - FULL VERIFICATION SUITE")
+    print(f"Project: {project_path}")
+    print(f"URL: {args.url}")
+    print(f"Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    start_time = datetime.now()
+    results = []
+    
+    # Run all verification categories
+    for suite in VERIFICATION_SUITE:
+        category = suite["category"]
+        requires_url = suite.get("requires_url", False)
+        
+        # Skip if requires URL and not provided
+        if requires_url and not args.url:
+            continue
+        
+        # Skip E2E if flag set
+        if args.no_e2e and category == "E2E Testing":
+            continue
+        
+        print_header(f"📋 {category.upper()}")
+        
+        for name, script_path, required in suite["checks"]:
+            script = project_path / script_path
+            result = run_script(name, script, str(project_path), args.url)
+            result["category"] = category
+            results.append(result)
+            
+            # Stop on critical failure if flag set
+            if args.stop_on_fail and required and not result["passed"] and not result.get("skipped"):
+                print_error(f"CRITICAL: {name} failed. Stopping verification.")
+                print_final_report(results, start_time)
+                sys.exit(1)
+    
+    # Print final report
+    all_passed = print_final_report(results, start_time)
+    
+    sys.exit(0 if all_passed else 1)
+
+if __name__ == "__main__":
+    main()

package/.agent/skills/agent-ops/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: agent-ops
+description: Master reasoning protocol (TNbN) and dynamic tool registry for Antigravity agents. Mandatory for all complex operations.
+version: 1.0.0
+---
+
+# Agent Ops - The Reasoning Operating System
+
+This skill defines the core "Logic Gates" and "Verification Protocols" that all Antigravity agents use to ensure high-fidelity, autonomous performance.
+
+---
+
+## 🧠 Think Node-by-Node (TNbN) Protocol
+
+To eliminate state hallucinations, agents MUST follow the **TNbN Reasoning Gate** before every action that modifies the workspace.
+
+### The Reasoning Gate Steps:
+
+1. **🌳 State Node (Input Verification):**
+    - Declare what you THINK is true (e.g., "I am about to edit `utils.py`").
+    - Explicitly state any assumptions (e.g., "I assume `utils.py` contains the helper function `foo`").
+
+2. **🔍 Verify Node (Filesystem Check):**
+    - Perform a `Read` or `Grep` to confirm the State Node.
+    - **Rule:** If the verification fails or differs from the State Node, you MUST stop and recalibrate.
+
+3. **🛠️ Act Node (Execution):**
+    - Perform the tool call (e.g., `Edit`, `Write`, `Bash`).
+    - Explain the direct impact of this action.
+
+4. **✅ Confirm Node (Verification):**
+    - Perform a final check to confirm the action was successful (e.g., `Read` the edited file or check `command_status`).
+
+---
+
+## 🛠️ Tool Registry Discovery
+
+Agents should use the built-in `registry.py` script to discover and validate available tools (skills/scripts) before attempting to use them.
+
+### Usage:
+```bash
+# Get the full map of available capabilities
+python .agent/skills/agent-ops/scripts/registry.py map
+
+# Verify if a specific tool is configured
+python .agent/skills/agent-ops/scripts/registry.py verify --tool [tool-name]
+```
+
+---
+
+## 🛑 Critical Rules
+
+- **Filesystem-First:** Never assume a file exists based on memory or `ARCHITECTURE.md`. Verify it with a tool.
+- **Node-Wait:** A task is not "In Progress" until the Verify Node is complete.
+- **Fail Early:** If you find a discrepancy in the Verify Node, do not "guess." Report it.
+
+---
+
+## 📋 Examples
+
+### ❌ WRONG (Hallucination Risk)
+"I will now add the feature to `main.js`."
+[Proceeds to edit `main.js` without reading it first]
+
+### ✅ CORRECT (TNbN Flow)
+"**State Node**: I am about to add the logging feature to `main.js`.
+**Verify Node**: I will read `main.js` to ensure the entry point is standard.
+[Agent reads file...]
+**Observation**: Found entry point at line 42.
+**Act Node**: I will now use `Edit` to add the logger.
+[Agent edits file...]
+**Confirm Node**: Verifying edit success by reading lines 42-50."

package/.agent/skills/agent-ops/scripts/export_ide_rules.py

@@ -0,0 +1,131 @@
+import os
+import re
+import argparse
+from pathlib import Path
+
+# Mapping agents to native IDE file triggers (Globs)
+GLOB_MAP = {
+    "frontend-specialist": ["**/*.tsx", "**/*.jsx", "**/*.html", "**/*.css", "src/components/**/*"],
+    "backend-specialist": ["**/*.ts", "**/api/**/*", "**/server/**/*", "**/routes/**/*"],
+    "database-architect": ["**/prisma/**/*", "**/drizzle/**/*", "**/*.sql", "**/db/**/*"],
+    "mobile-developer": ["**/*.tsx", "**/*.jsx", "ios/**/*", "android/**/*", "**/mobile/**/*"],
+    "security-auditor": ["**/auth/**/*", "**/security/**/*", ".env*", "**/middleware/**/*"],
+    "test-engineer": ["**/*.test.ts", "**/*.test.tsx", "**/__tests__/**/*", "**/tests/**/*"],
+    "devops-engineer": ["Dockerfile", "docker-compose.yml", ".github/**/*", "**/deploy/**/*", "scripts/**/*"],
+    "seo-specialist": ["**/pages/**/*", "**/metadata/**/*", "next.config.js", "sitemap.xml"],
+}
+
+def get_agent_root():
+    """Navigate to the .agent directory."""
+    current_path = Path(__file__).resolve()
+    for parent in current_path.parents:
+        if (parent / ".agent").exists():
+            return parent / ".agent"
+    return None
+
+def extract_markdown_data(file_path):
+    """Extract frontmatter and content from a markdown file."""
+    content = file_path.read_text(encoding="utf-8")
+    frontmatter = {}
+    body = content
+    
+    if content.startswith("---"):
+        match = re.match(r"---(.*?)---(.*)", content, re.DOTALL)
+        if match:
+            fm_text = match.group(1)
+            body = match.group(2).strip()
+            for line in fm_text.splitlines():
+                if ":" in line:
+                    k, v = line.split(":", 1)
+                    frontmatter[k.strip()] = v.strip()
+    return frontmatter, body
+
+def get_tnbn_protocol(agent_root):
+    """Fetch the TNbN protocol from GEMINI.md."""
+    gemini_path = agent_root / "rules" / "GEMINI.md"
+    if gemini_path.exists():
+        _, body = extract_markdown_data(gemini_path)
+        # Extract the TNbN section
+        match = re.search(r"### 🧠 Think Node-by-Node (TNbN)(.*?)---", body, re.DOTALL)
+        if match:
+            return f"## 🧠 Think Node-by-Node (TNbN)\n{match.group(1).strip()}"
+    return ""
+
+def export_to_cursor(agent_root, tnbn):
+    """Compile agent kit for Cursor (.mdc files)."""
+    cursor_rules_dir = agent_root.parent / ".cursor" / "rules"
+    cursor_rules_dir.mkdir(parents=True, exist_ok=True)
+    
+    agents_dir = agent_root / "agents"
+    if not agents_dir.exists():
+        return
+    
+    for agent_file in agents_dir.glob("*.md"):
+        fm, body = extract_markdown_data(agent_file)
+        name = fm.get("name", agent_file.stem)
+        description = fm.get("description", f"Specialist rules for {name}")
+        globs = GLOB_MAP.get(agent_file.stem, ["*"])
+        
+        # Build .mdc content
+        mdc_content = f"---"
+        mdc_content += f"\ndescription: {description}"
+        mdc_content += f"\nglobs: [" + ", ".join([f'"{g}"' for g in globs]) + "]"
+        mdc_content += f"\n---"
+        mdc_content += f"\n\n# {name}\n\n"
+        mdc_content += f"{tnbn}\n\n"
+        mdc_content += f"## Specialist Protocol\n\n{body}"
+        
+        # Clean up @skills references for Cursor
+        mdc_content = re.sub(r"@\[skills/.*?\]", "specialized agents", mdc_content)
+        
+        target_path = cursor_rules_dir / f"{agent_file.stem}.mdc"
+        target_path.write_text(mdc_content, encoding="utf-8")
+        print(f"✅ Cursor: Compiled {target_path.name}")
+
+def export_to_windsurf(agent_root, tnbn):
+    """Compile agent kit for Windsurf (AGENTS.md)."""
+    agents_dir = agent_root / "agents"
+    if not agents_dir.exists():
+        return
+    
+    master_agents_content = f"# Master Intelligence (Antigravity Kit)\n\n"
+    master_agents_content += f"{tnbn}\n\n"
+    master_agents_content += "---"
+    
+    for agent_file in agents_dir.glob("*.md"):
+        fm, body = extract_markdown_data(agent_file)
+        name = fm.get("name", agent_file.stem)
+        master_agents_content += f"\n\n## Specialist: {name}\n\n{body}\n\n---"
+    
+    # Export AGENTS.md to root
+    target_path = agent_root.parent / "AGENTS.md"
+    target_path.write_text(master_agents_content, encoding="utf-8")
+    
+    # Update .windsurfrules to point to AGENTS.md
+    windsurf_rules = agent_root.parent / ".windsurfrules"
+    windsurf_rules_content = f"## Intelligence Protocol\n\nRefer to AGENTS.md for specialist personas and TNbN reasoning."
+    windsurf_rules.write_text(windsurf_rules_content, encoding="utf-8")
+    print(f"✅ Windsurf: Compiled AGENTS.md & .windsurfrules")
+
+def main():
+    parser = argparse.ArgumentParser(description="Antigravity Kit Universal Compiler")
+    parser.add_argument("--cursor", action="store_true", help="Compile for Cursor (.mdc)")
+    parser.add_argument("--windsurf", action="store_true", help="Compile for Windsurf (AGENTS.md)")
+    parser.add_argument("--all", action="store_true", help="Compile for all platforms")
+    args = parser.parse_args()
+
+    agent_root = get_agent_root()
+    if not agent_root:
+        print("Error: Could not find .agent directory.")
+        return
+
+    tnbn = get_tnbn_protocol(agent_root)
+    
+    if args.cursor or args.all:
+        export_to_cursor(agent_root, tnbn)
+    
+    if args.windsurf or args.all:
+        export_to_windsurf(agent_root, tnbn)
+
+if __name__ == "__main__":
+    main()

package/.agent/skills/agent-ops/scripts/registry.py

@@ -0,0 +1,125 @@
+import os
+import json
+import argparse
+from pathlib import Path
+
+def get_agent_root():
+    """Navigate to the .agent directory."""
+    current_path = Path(__file__).resolve()
+    for parent in current_path.parents:
+        if (parent / ".agent").exists():
+            return parent / ".agent"
+    return None
+
+def list_skills(agent_root):
+    """Index all folders in the skills directory and parse their metadata."""
+    skills_dir = agent_root / "skills"
+    skills_map = {}
+    if skills_dir.exists():
+        for skill_folder in skills_dir.iterdir():
+            if skill_folder.is_dir():
+                skill_md = skill_folder / "SKILL.md"
+                description = "No description available."
+                if skill_md.exists():
+                    try:
+                        content = skill_md.read_text(encoding="utf-8")
+                        # Basic YAML frontmatter parser for simplicity
+                        if content.startswith("---"):
+                            end_pos = content.find("---", 3)
+                            if end_pos != -1:
+                                frontmatter = content[3:end_pos]
+                                for line in frontmatter.splitlines():
+                                    if "description:" in line:
+                                        description = line.split("description:", 1)[1].strip()
+                                        break
+                    except Exception:
+                        pass
+                
+                scripts = []
+                scripts_dir = skill_folder / "scripts"
+                if scripts_dir.exists():
+                    scripts = [f.name for f in scripts_dir.iterdir() if f.is_file()]
+                
+                skills_map[skill_folder.name] = {
+                    "description": description,
+                    "scripts": scripts
+                }
+    return skills_map
+
+def list_workflows(agent_root):
+    workflows_dir = agent_root / "workflows"
+    workflows_map = {}
+    if workflows_dir.exists():
+        for workflow_file in workflows_dir.iterdir():
+            if workflow_file.is_file() and workflow_file.suffix == ".md":
+                name = workflow_file.stem
+                description = "No description available."
+                try:
+                    content = workflow_file.read_text(encoding="utf-8")
+                    if content.startswith("---"):
+                        end_pos = content.find("---", 3)
+                        if end_pos != -1:
+                            frontmatter = content[3:end_pos]
+                            for line in frontmatter.splitlines():
+                                if "description:" in line:
+                                    description = line.split("description:", 1)[1].strip()
+                                    break
+                except Exception:
+                    pass
+                workflows_map[name] = description
+    return workflows_map
+
+def list_master_scripts(agent_root):
+    scripts_dir = agent_root / "scripts"
+    master_scripts = []
+    if scripts_dir.exists():
+        master_scripts = [f.name for f in scripts_dir.iterdir() if f.is_file()]
+    return master_scripts
+
+def main():
+    parser = argparse.ArgumentParser(description="Antigravity Tool Registry Discovery")
+    parser.add_argument("command", choices=["map", "verify"], help="Command to run")
+    parser.add_argument("--tool", help="Specific tool name to verify")
+    args = parser.parse_args()
+
+    agent_root = get_agent_root()
+    if not agent_root:
+        print("Error: Could not find .agent directory.")
+        return
+
+    if args.command == "map":
+        results = {
+            "skills": list_skills(agent_root),
+            "workflows": list_workflows(agent_root),
+            "master_scripts": list_master_scripts(agent_root)
+        }
+        print(json.dumps(results, indent=2))
+    
+    elif args.command == "verify":
+        if not args.tool:
+            print("Error: Please provide a tool name with --tool")
+            return
+        
+        skills = list_skills(agent_root)
+        workflows = list_workflows(agent_root)
+        scripts = list_master_scripts(agent_root)
+        
+        found = False
+        if args.tool in skills:
+            print(f"Tool FOUND in SKILLS: {args.tool}")
+            print(f"Description: {skills[args.tool]['description']}")
+            print(f"Scripts: {skills[args.tool]['scripts']}")
+            found = True
+        elif args.tool in workflows:
+            print(f"Tool FOUND in WORKFLOWS: {args.tool}")
+            print(f"Description: {workflows[args.tool]}")
+            found = True
+        elif args.tool in scripts:
+            print(f"Tool FOUND in MASTER SCRIPTS: {args.tool}")
+            found = True
+        
+        if not found:
+            print(f"Tool NOT FOUND: {args.tool}")
+
+if __name__ == "__main__":
+    main()