@musashishao/agent-kit 1.2.2

package/.agent/skills/context-engineering/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: context-engineering
+description: Advanced strategies to optimize LLM context window, reduce lost-in-the-middle phenomena, and improve reasoning through structured inputs.
+requirements:
+  - python >= 3.8
+  - tiktoken (for counting tokens)
+types:
+  - strategy
+  - optimization
+---
+
+# Context Engineering
+
+> **"Context is King."** - In the era of LLMs, managing the context window is the single most important factor for performance, accuracy, and cost efficiency.
+
+This skill provides a systematic approach to curating, structuring, and optimizing the information sent to AI models. It moves beyond simple "prompt engineering" into the architectural design of information flow.
+
+## 🧠 Core Philosophy: The 4 Pillars
+
+1.  **Context Curation (Signal-to-Noise Ratio):**
+    -   NEVER dump the entire codebase.
+    -   Use **Dependency Graphs** and **Symbol Jumping** to select only highly relevant files.
+    -   *Technique:* `RepoMap` (Tree structure) for high-level understanding + `Skeleton` (Signatures) for interface understanding.
+
+2.  **Context Structuring (XML & Framing):**
+    -   Use explicit XML tags (`<documents>`, `<instructions>`, `<history>`) to separate semantic zones.
+    -   **Prime Positioning:** Place critical instructions at the very end of the prompt (Recency Bias).
+    -   **Context Caching:** Structure static content (docs, rules) at the top to leverage API caching (Anthropic/Gemini).
+
+3.  **Context Compression (Information Density):**
+    -   **Skeletonization:** Replace function bodies with `...` or `pass` when only the interface is needed.
+    -   **Summarization:** Compress chat history into key architectural decisions, discarding "chit-chat".
+    -   **Token Budgeting:** Allocate tokens strictly: 40% Active Code, 30% Reference, 20% Reasoning buffer, 10% History.
+
+4.  **In-Context Guidance (Few-Shot & CoT):**
+    -   **Few-Shot Learning:** Include 2-3 examples of "Golden Code" (perfect code style for this project) to align style instantly.
+    -   **Chain-of-Thought (CoT):** Force the model to `<think>` before answering.
+
+## 📂 Skill Structure
+
+```text
+skills/context-engineering/
+├── SKILL.md                  # You are here
+├── strategies/
+│   ├── xml-framing.md        # How to organize the prompt payload
+│   ├── context-caching.md    # Optimizing for Anthropic/Gemini Cache
+│   ├── skeleton-code.md      # Technique to compress code reading
+│   └── few-shot-examples.md  # Constructing powerful examples
+└── scripts/
+    ├── token_counter.py      # Utility to estimate token usage
+    └── repo_mapper.py        # Generates a tree-view map of the project
+```
+
+## 🚀 How to Apply
+
+### 1. Before asking a complex question:
+- Run `repo_mapper.py` to give the AI a high-level map.
+- Decide which files are "Active" (need editing) vs "Reference" (need reading).
+- Use **Skeleton** mode for Reference files to save tokens.
+
+### 2. When writing instructions:
+- Wrap your request in standard XML structures.
+- Use the **Golden Rule of Positioning**:
+  - Top: Static Context (Docs, Project Rules) -> *Cached*
+  - Middle: Dynamic Context (Current Files, Chat History)
+  - Bottom: The Request (Instruction + Output Format)
+
+### 3. For Debugging & Architecture:
+- Enable **Chain-of-Thought**: Ask the AI to "Think step-by-step inside <thinking> tags".
+
+## 📚 References
+- **MemGPT:** Paging and eviction strategies (Working vs Reference memory).
+- **Anthropic Research:** Long-context prompting, finding the needle in a haystack.
+- **LlamaIndex:** Node parsing and index retrieval strategies.

package/.agent/skills/context-engineering/examples/advanced_code_request.md

@@ -0,0 +1,73 @@
+# 🤖 Advanced Context-Engineered Prompt Template
+
+Copy this entire block and fill in the placeholders to experience "SOTA" (State-of-the-Art) AI coding.
+
+---
+
+```xml
+<system_context>
+    <role>
+        You are a Principal Software Architect at Google Deepmind, specialized in Next.js, TypeScript, and Shadcn UI.
+        Your goal is to write "Golden Code": secure, performant, readable, and perfectly typed.
+    </role>
+    <constraints>
+        1. NO "any" types. Use proper interfaces or generics.
+        2. Use functional components with hooks.
+        3. Prioritize "Composition over Inheritance".
+        4. Measure twice, cut once: Think before coding.
+    </constraints>
+</system_context>
+
+<project_structure>
+./
+    web/
+        src/
+            components/
+                ui/             # Base Shadcn components
+                layout/         # Structure components
+            app/
+                docs/           # Documentation pages
+            lib/
+                utils.ts        # Helper functions
+</project_structure>
+
+<reference_documents>
+    <!-- We inject the "Skeleton" of a relevant utility to save tokens -->
+    <document path="web/src/lib/utils.ts" type="skeleton">
+        export function cn(...inputs: ClassValue[]): string;
+        export function formatDate(date: Date): string;
+    </document>
+    
+    <!-- We inject the design system rules -->
+    <document path="web/tailwind.config.ts" type="summary">
+        Primary Color: HSL(222.2, 47.4%, 11.2%)
+        Border Radius: 0.5rem
+        Font: Inter
+    </document>
+</reference_documents>
+
+<user_instruction>
+    <task>
+        Create a new "FeatureCard" component in `web/src/components/ui/feature-card.tsx`.
+    </task>
+    
+    <requirements>
+        1. It must look premium (glassmorphism effect).
+        2. It should accept an Icon, Title, Description, and an optional "Learn More" link.
+        3. It must be responsive (stack on mobile, grid on desktop).
+        4. Use the `cn()` utility for class merging.
+    </requirements>
+
+    <example_output>
+        Provide the full code for `feature-card.tsx` and a usage example.
+    </example_output>
+</user_instruction>
+
+<thinking_process_guidance>
+    Before generating the code, you must perform a "Chain of Thought" analysis inside <thinking> tags:
+    1. Analyze the requirements.
+    2. Check the <reference_documents> for available tools (cn).
+    3. Plan the component API (Props interface).
+    4. Plan the Tailwind classes for "glassmorphism".
+</thinking_process_guidance>
+```

package/.agent/skills/context-engineering/scripts/quality_validator.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""
+Agent Kit Quality Validator
+Validates AGENTS.md and .agent folder structure for Codex CLI compatibility.
+
+Usage:
+    python quality_validator.py [path]
+    
+Example:
+    python quality_validator.py .
+    python quality_validator.py /path/to/project
+"""
+
+import os
+import sys
+import re
+import json
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+# ANSI colors
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    MAGENTA = '\033[95m'
+    CYAN = '\033[96m'
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+
+def print_header(msg: str):
+    print(f"\n{Colors.BOLD}{Colors.MAGENTA}{msg}{Colors.RESET}\n")
+
+def print_check(name: str, passed: bool, message: str = ""):
+    status = f"{Colors.GREEN}✓{Colors.RESET}" if passed else f"{Colors.RED}✗{Colors.RESET}"
+    msg_color = Colors.GREEN if passed else Colors.RED
+    print(f"  {status} {Colors.CYAN}{name}{Colors.RESET}: {msg_color}{message}{Colors.RESET}")
+
+
+class AgentKitValidator:
+    def __init__(self, project_path: str):
+        self.project_path = Path(project_path).resolve()
+        self.agent_dir = self.project_path / ".agent"
+        self.agents_md = self.project_path / "AGENTS.md"
+        self.results: List[Tuple[str, bool, str]] = []
+        
+    def validate_all(self) -> Dict:
+        """Run all validations and return summary"""
+        print_header("🔍 Agent Kit Quality Validator")
+        print(f"Project: {self.project_path}\n")
+        
+        checks = [
+            self.check_agents_md_exists,
+            self.check_agent_folder_structure,
+            self.check_agents_format,
+            self.check_skills_format,
+            self.check_workflows_format,
+            self.check_codex_compatibility,
+            self.check_skill_loading_protocol,
+        ]
+        
+        for check in checks:
+            check()
+        
+        return self.summarize()
+    
+    def check_agents_md_exists(self):
+        """Check if AGENTS.md exists at project root"""
+        print_header("📄 AGENTS.md Validation")
+        
+        if self.agents_md.exists():
+            content = self.agents_md.read_text()
+            
+            # Check required sections
+            required_sections = [
+                ("Project Overview", r"##.*Overview"),
+                ("Setup Commands", r"##.*Setup"),
+                ("Code Style", r"##.*Code Style|##.*Standards"),
+            ]
+            
+            for name, pattern in required_sections:
+                found = bool(re.search(pattern, content, re.IGNORECASE))
+                self.results.append((f"AGENTS.md: {name}", found, "Found" if found else "Missing"))
+                print_check(f"Section: {name}", found, "Found" if found else "Missing")
+                
+            # Check for loading protocol
+            has_protocol = "workflow" in content.lower() and "skill" in content.lower()
+            self.results.append(("Loading Protocol", has_protocol, "Found" if has_protocol else "Missing"))
+            print_check("Loading Protocol", has_protocol, "Found" if has_protocol else "Should document how to use skills/workflows")
+            
+        else:
+            self.results.append(("AGENTS.md exists", False, "Not found"))
+            print_check("AGENTS.md", False, f"Not found at {self.agents_md}")
+    
+    def check_agent_folder_structure(self):
+        """Check .agent folder structure"""
+        print_header("📁 Folder Structure Validation")
+        
+        required_dirs = ["agents", "skills", "workflows"]
+        optional_dirs = ["rules", "templates", "plans"]
+        
+        for dir_name in required_dirs:
+            dir_path = self.agent_dir / dir_name
+            exists = dir_path.exists()
+            count = len(list(dir_path.iterdir())) if exists else 0
+            self.results.append((f".agent/{dir_name}", exists, f"{count} items" if exists else "Missing"))
+            print_check(f".agent/{dir_name}/", exists, f"{count} items" if exists else "Missing (required)")
+        
+        for dir_name in optional_dirs:
+            dir_path = self.agent_dir / dir_name
+            exists = dir_path.exists()
+            count = len(list(dir_path.iterdir())) if exists else 0
+            if exists:
+                print_check(f".agent/{dir_name}/", True, f"{count} items (optional)")
+    
+    def check_agents_format(self):
+        """Check agent file format"""
+        print_header("🤖 Agent Files Validation")
+        
+        agents_dir = self.agent_dir / "agents"
+        if not agents_dir.exists():
+            return
+        
+        for agent_file in agents_dir.glob("*.md"):
+            content = agent_file.read_text()
+            
+            # Check frontmatter
+            has_frontmatter = content.startswith("---")
+            has_name = bool(re.search(r"^name:\s*.+", content, re.MULTILINE))
+            has_description = bool(re.search(r"^description:\s*.+", content, re.MULTILINE))
+            
+            is_valid = has_frontmatter and has_name and has_description
+            issues = []
+            if not has_frontmatter:
+                issues.append("missing frontmatter")
+            if not has_name:
+                issues.append("missing name")
+            if not has_description:
+                issues.append("missing description")
+            
+            message = "Valid" if is_valid else f"Issues: {', '.join(issues)}"
+            self.results.append((f"Agent: {agent_file.name}", is_valid, message))
+            print_check(agent_file.name, is_valid, message)
+    
+    def check_skills_format(self):
+        """Check skill file format"""
+        print_header("🧠 Skills Validation")
+        
+        skills_dir = self.agent_dir / "skills"
+        if not skills_dir.exists():
+            return
+        
+        valid_count = 0
+        total_count = 0
+        
+        for skill_dir in skills_dir.iterdir():
+            if not skill_dir.is_dir():
+                continue
+            
+            total_count += 1
+            skill_md = skill_dir / "SKILL.md"
+            
+            if skill_md.exists():
+                content = skill_md.read_text()
+                has_frontmatter = content.startswith("---")
+                has_description = bool(re.search(r"^description:\s*.+", content, re.MULTILINE))
+                
+                if has_frontmatter and has_description:
+                    valid_count += 1
+        
+        is_valid = valid_count == total_count
+        message = f"{valid_count}/{total_count} skills have valid SKILL.md"
+        self.results.append(("Skills Format", is_valid, message))
+        print_check("Skills Format", is_valid, message)
+    
+    def check_workflows_format(self):
+        """Check workflow file format"""
+        print_header("⚡ Workflows Validation")
+        
+        workflows_dir = self.agent_dir / "workflows"
+        if not workflows_dir.exists():
+            return
+        
+        valid_count = 0
+        total_count = 0
+        
+        for wf_file in workflows_dir.glob("*.md"):
+            total_count += 1
+            content = wf_file.read_text()
+            
+            has_frontmatter = content.startswith("---")
+            has_description = bool(re.search(r"^description:\s*.+", content, re.MULTILINE))
+            
+            if has_frontmatter and has_description:
+                valid_count += 1
+            else:
+                print_check(wf_file.name, False, "Missing frontmatter or description")
+        
+        is_valid = valid_count == total_count
+        message = f"{valid_count}/{total_count} workflows are valid"
+        self.results.append(("Workflows Format", is_valid, message))
+        print_check("Overall", is_valid, message)
+    
+    def check_codex_compatibility(self):
+        """Check Codex CLI specific requirements"""
+        print_header("🔗 Codex CLI Compatibility")
+        
+        checks = []
+        
+        # Check 1: AGENTS.md in root
+        checks.append(("AGENTS.md in root", self.agents_md.exists()))
+        
+        # Check 2: .codex folder (optional)
+        codex_dir = self.project_path / ".codex"
+        checks.append((".codex config (optional)", codex_dir.exists()))
+        
+        # Check 3: CODEX.md rules
+        codex_rules = self.agent_dir / "rules" / "CODEX.md"
+        checks.append(("CODEX.md rules", codex_rules.exists()))
+        
+        for name, passed in checks:
+            message = "Found" if passed else "Missing"
+            self.results.append((name, passed, message))
+            print_check(name, passed, message)
+    
+    def check_skill_loading_protocol(self):
+        """Check if AGENTS.md has proper skill loading protocol"""
+        print_header("📖 Skill Loading Protocol")
+        
+        if not self.agents_md.exists():
+            print_check("Protocol Check", False, "AGENTS.md not found")
+            return
+        
+        content = self.agents_md.read_text().lower()
+        
+        protocols = [
+            ("Skill reference", ".agent/skills" in content),
+            ("Workflow reference", ".agent/workflows" in content),
+            ("Agent reference", ".agent/agents" in content),
+            ("Loading order", "loading" in content or "protocol" in content),
+        ]
+        
+        for name, passed in protocols:
+            message = "Documented" if passed else "Should be documented"
+            self.results.append((name, passed, message))
+            print_check(name, passed, message)
+    
+    def summarize(self) -> Dict:
+        """Print summary and return results"""
+        print_header("📊 Summary")
+        
+        passed = sum(1 for _, p, _ in self.results if p)
+        total = len(self.results)
+        percentage = (passed / total * 100) if total > 0 else 0
+        
+        color = Colors.GREEN if percentage >= 80 else Colors.YELLOW if percentage >= 60 else Colors.RED
+        
+        print(f"  {color}Passed: {passed}/{total} ({percentage:.0f}%){Colors.RESET}")
+        
+        if percentage >= 90:
+            print(f"\n  {Colors.GREEN}✓ Excellent! Agent Kit is fully configured for Codex CLI.{Colors.RESET}")
+        elif percentage >= 70:
+            print(f"\n  {Colors.YELLOW}⚠ Good, but some improvements recommended.{Colors.RESET}")
+        else:
+            print(f"\n  {Colors.RED}✗ Several issues found. Please review the checks above.{Colors.RESET}")
+        
+        # Show failed checks
+        failed = [(n, m) for n, p, m in self.results if not p]
+        if failed:
+            print(f"\n  {Colors.BOLD}Issues to fix:{Colors.RESET}")
+            for name, message in failed[:5]:  # Show top 5
+                print(f"    - {name}: {message}")
+        
+        return {
+            "passed": passed,
+            "total": total,
+            "percentage": percentage,
+            "results": self.results
+        }
+
+
+def main():
+    project_path = sys.argv[1] if len(sys.argv) > 1 else "."
+    
+    validator = AgentKitValidator(project_path)
+    results = validator.validate_all()
+    
+    # Exit with error code if less than 70% passed
+    sys.exit(0 if results["percentage"] >= 70 else 1)
+
+
+if __name__ == "__main__":
+    main()

package/.agent/skills/context-engineering/scripts/repo_mapper.py

@@ -0,0 +1,27 @@
+import os
+import sys
+
+def generate_repo_map(root_dir, ignore_dirs=None):
+    if ignore_dirs is None:
+        ignore_dirs = {'.git', 'node_modules', 'dist', 'build', '.next', '__pycache__', '.agent'}
+    
+    repo_map = []
+    
+    for root, dirs, files in os.walk(root_dir):
+        # Modify dirs in-place to skip ignored directories
+        dirs[:] = [d for d in dirs if d not in ignore_dirs]
+        
+        level = root.replace(root_dir, '').count(os.sep)
+        indent = ' ' * 4 * (level)
+        repo_map.append(f'{indent}{os.path.basename(root)}/')
+        
+        subindent = ' ' * 4 * (level + 1)
+        for f in files:
+            if f.startswith('.'): continue
+            repo_map.append(f'{subindent}{f}')
+            
+    return '\n'.join(repo_map)
+
+if __name__ == "__main__":
+    path = sys.argv[1] if len(sys.argv) > 1 else "."
+    print(generate_repo_map(path))

package/.agent/skills/context-engineering/scripts/skill_checker.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Skill Quality Checker
+Analyzes skills for quality and completeness.
+
+Usage:
+    python skill_checker.py [skill_name]
+    python skill_checker.py --all
+    
+Example:
+    python skill_checker.py react-patterns
+    python skill_checker.py --all
+"""
+
+import os
+import sys
+import re
+from pathlib import Path
+from typing import Dict, List, Optional
+
+# ANSI colors
+class Colors:
+    RED = '\033[91m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    BLUE = '\033[94m'
+    MAGENTA = '\033[95m'
+    CYAN = '\033[96m'
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+
+
+class SkillChecker:
+    """Check skill quality and completeness"""
+    
+    REQUIRED_FRONTMATTER = ["name", "description"]
+    RECOMMENDED_FRONTMATTER = ["requirements", "types"]
+    RECOMMENDED_SECTIONS = ["Core Philosophy", "How to Apply", "References"]
+    
+    def __init__(self, skills_dir: Path):
+        self.skills_dir = skills_dir
+        
+    def check_skill(self, skill_name: str) -> Dict:
+        """Check a single skill"""
+        skill_path = self.skills_dir / skill_name
+        skill_md = skill_path / "SKILL.md"
+        
+        if not skill_path.exists():
+            return {"name": skill_name, "exists": False, "score": 0}
+        
+        result = {
+            "name": skill_name,
+            "exists": True,
+            "checks": [],
+            "score": 0
+        }
+        
+        if not skill_md.exists():
+            result["checks"].append(("SKILL.md", False, "Missing"))
+            return result
+        
+        content = skill_md.read_text()
+        
+        # Check frontmatter
+        frontmatter_match = re.match(r"^---\n(.+?)\n---", content, re.DOTALL)
+        if frontmatter_match:
+            frontmatter = frontmatter_match.group(1)
+            
+            for field in self.REQUIRED_FRONTMATTER:
+                has_field = bool(re.search(rf"^{field}:\s*.+", frontmatter, re.MULTILINE))
+                result["checks"].append((f"Frontmatter: {field}", has_field, "Found" if has_field else "Missing (required)"))
+            
+            for field in self.RECOMMENDED_FRONTMATTER:
+                has_field = bool(re.search(rf"^{field}:\s*.+", frontmatter, re.MULTILINE))
+                if has_field:
+                    result["checks"].append((f"Frontmatter: {field}", True, "Found"))
+        else:
+            result["checks"].append(("Frontmatter", False, "Missing YAML frontmatter"))
+        
+        # Check content quality
+        word_count = len(content.split())
+        has_enough_content = word_count > 100
+        result["checks"].append(("Content length", has_enough_content, f"{word_count} words" if has_enough_content else "Too short"))
+        
+        # Check for code examples
+        has_code = "```" in content
+        result["checks"].append(("Code examples", has_code, "Found" if has_code else "Consider adding"))
+        
+        # Check for recommended sections
+        for section in self.RECOMMENDED_SECTIONS:
+            has_section = section.lower() in content.lower()
+            if has_section:
+                result["checks"].append((f"Section: {section}", True, "Found"))
+        
+        # Check for additional files
+        additional_files = list(skill_path.glob("**/*"))
+        has_scripts = any("script" in str(f).lower() for f in additional_files)
+        has_examples = any("example" in str(f).lower() for f in additional_files)
+        
+        if has_scripts:
+            result["checks"].append(("Scripts", True, "Has automation scripts"))
+        if has_examples:
+            result["checks"].append(("Examples", True, "Has examples"))
+        
+        # Calculate score
+        passed = sum(1 for _, p, _ in result["checks"] if p)
+        total = len(result["checks"])
+        result["score"] = (passed / total * 100) if total > 0 else 0
+        
+        return result
+    
+    def check_all(self) -> List[Dict]:
+        """Check all skills"""
+        results = []
+        
+        for skill_dir in sorted(self.skills_dir.iterdir()):
+            if skill_dir.is_dir():
+                result = self.check_skill(skill_dir.name)
+                results.append(result)
+        
+        return results
+    
+    def print_result(self, result: Dict):
+        """Print result for a single skill"""
+        name = result["name"]
+        score = result.get("score", 0)
+        
+        color = Colors.GREEN if score >= 80 else Colors.YELLOW if score >= 60 else Colors.RED
+        status = "✓" if score >= 80 else "⚠" if score >= 60 else "✗"
+        
+        print(f"\n{Colors.BOLD}{Colors.CYAN}{name}{Colors.RESET} {color}[{score:.0f}%]{Colors.RESET}")
+        
+        for check_name, passed, message in result.get("checks", []):
+            status_icon = f"{Colors.GREEN}✓{Colors.RESET}" if passed else f"{Colors.YELLOW}○{Colors.RESET}"
+            print(f"  {status_icon} {check_name}: {message}")
+    
+    def print_summary(self, results: List[Dict]):
+        """Print summary of all skills"""
+        print(f"\n{Colors.BOLD}{Colors.MAGENTA}📊 Skills Quality Summary{Colors.RESET}\n")
+        
+        excellent = sum(1 for r in results if r.get("score", 0) >= 80)
+        good = sum(1 for r in results if 60 <= r.get("score", 0) < 80)
+        needs_work = sum(1 for r in results if r.get("score", 0) < 60)
+        
+        print(f"  {Colors.GREEN}Excellent (80%+): {excellent}{Colors.RESET}")
+        print(f"  {Colors.YELLOW}Good (60-79%): {good}{Colors.RESET}")
+        print(f"  {Colors.RED}Needs work (<60%): {needs_work}{Colors.RESET}")
+        print(f"\n  Total: {len(results)} skills")
+        
+        avg_score = sum(r.get("score", 0) for r in results) / len(results) if results else 0
+        color = Colors.GREEN if avg_score >= 80 else Colors.YELLOW if avg_score >= 60 else Colors.RED
+        print(f"  {color}Average Quality Score: {avg_score:.1f}%{Colors.RESET}")
+
+
+def main():
+    # Find skills directory
+    cwd = Path.cwd()
+    skills_dir = cwd / ".agent" / "skills"
+    
+    if not skills_dir.exists():
+        print(f"{Colors.RED}Error: .agent/skills not found{Colors.RESET}")
+        sys.exit(1)
+    
+    checker = SkillChecker(skills_dir)
+    
+    if len(sys.argv) > 1:
+        arg = sys.argv[1]
+        
+        if arg == "--all":
+            results = checker.check_all()
+            for result in results:
+                if result.get("score", 0) < 80:  # Only show non-excellent
+                    checker.print_result(result)
+            checker.print_summary(results)
+        else:
+            result = checker.check_skill(arg)
+            checker.print_result(result)
+    else:
+        # Default: show summary only
+        results = checker.check_all()
+        checker.print_summary(results)
+        
+        # Show top 5 needing improvement
+        needs_work = sorted([r for r in results if r.get("score", 0) < 80], 
+                           key=lambda x: x.get("score", 0))[:5]
+        
+        if needs_work:
+            print(f"\n{Colors.YELLOW}Skills needing improvement:{Colors.RESET}")
+            for r in needs_work:
+                print(f"  - {r['name']}: {r.get('score', 0):.0f}%")
+
+
+if __name__ == "__main__":
+    main()