agentic-sdlc 1.5.1 → 1.8.1

package/bin/lib/kb_common.py

@@ -1,224 +0,0 @@
-"""
-Common utilities for KB operations
-Cross-platform helper functions
-"""
-
-import os
-import re
-import platform
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, List, Optional
-
-
-class KBConfig:
-    """KB configuration"""
-    def __init__(self):
-        self.root_dir = self._find_project_root()
-        self.kb_path = self.root_dir / ".agent" / "knowledge-base"
-        self.docs_path = self.root_dir / "docs"
-        self.index_path = self.kb_path / "INDEX.md"
-        self.platform = platform.system()
-    
-    def _find_project_root(self) -> Path:
-        """Find project root by searching for .agent directory"""
-        # Start from cwd
-        current = Path.cwd()
-        
-        # Search up to 10 levels
-        for _ in range(10):
-            if (current / ".agent").exists():
-                return current
-            if (current / ".git").exists():
-                return current
-            parent = current.parent
-            if parent == current:  # Reached root
-                break
-            current = parent
-        
-        # Fallback: try from script location
-        script_dir = Path(__file__).parent.parent.parent  # lib -> bin -> root
-        if (script_dir / ".agent").exists():
-            return script_dir
-        
-        # Last resort: use cwd
-        return Path.cwd()
-    
-    def get_kb_path(self) -> Path:
-        """Get KB path"""
-        return self.kb_path
-    
-    def get_docs_path(self) -> Path:
-        """Get docs path"""
-        return self.docs_path
-    
-    def get_all_kb_paths(self) -> List[Path]:
-        """Get all knowledge base paths (KB + docs)"""
-        return [self.kb_path, self.docs_path]
-    
-    def get_index_path(self) -> Path:
-        """Get INDEX.md path"""
-        return self.index_path
-    
-    def is_windows(self) -> bool:
-        """Check if running on Windows"""
-        return self.platform == 'Windows'
-    
-    def is_linux(self) -> bool:
-        """Check if running on Linux"""
-        return self.platform == 'Linux'
-    
-    def is_macos(self) -> bool:
-        """Check if running on macOS"""
-        return self.platform == 'Darwin'
-
-
-class Colors:
-    """ANSI color codes"""
-    RESET = '\033[0m'
-    BOLD = '\033[1m'
-    
-    RED = '\033[31m'
-    GREEN = '\033[32m'
-    YELLOW = '\033[33m'
-    BLUE = '\033[34m'
-    MAGENTA = '\033[35m'
-    CYAN = '\033[36m'
-    WHITE = '\033[37m'
-    GRAY = '\033[90m'
-    
-    @staticmethod
-    def enable_windows():
-        """Enable ANSI colors on Windows"""
-        if platform.system() == 'Windows':
-            try:
-                import ctypes
-                kernel32 = ctypes.windll.kernel32
-                kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
-            except:
-                pass
-
-
-def parse_frontmatter(content: str) -> Dict:
-    """Parse YAML frontmatter from markdown"""
-    metadata = {}
-    
-    # Extract frontmatter
-    frontmatter_match = re.search(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
-    if frontmatter_match:
-        frontmatter = frontmatter_match.group(1)
-        
-        # Parse simple YAML
-        for line in frontmatter.split('\n'):
-            if ':' in line:
-                key, value = line.split(':', 1)
-                key = key.strip()
-                value = value.strip().strip('"\'')
-                
-                # Handle arrays
-                if value.startswith('[') and value.endswith(']'):
-                    value = [v.strip().strip('"\'') for v in value[1:-1].split(',')]
-                
-                metadata[key] = value
-    
-    return metadata
-
-
-def get_kb_entries(kb_path: Path, pattern: str = "KB-*.md") -> List[Path]:
-    """Get all KB entries"""
-    return list(kb_path.rglob(pattern))
-
-
-def get_all_kb_entries(paths: List[Path]) -> List[Path]:
-    """Get all KB entries from multiple paths"""
-    entries = []
-    for path in paths:
-        if path.exists():
-            # Get KB-*.md files from knowledge-base
-            if path.name == "knowledge-base":
-                entries.extend(list(path.rglob("KB-*.md")))
-            
-            # Get all markdown files from docs/ (excluding sprints)
-            elif path.name == "docs":
-                for md_file in path.rglob("*.md"):
-                    # Skip sprint artifacts
-                    if "sprints" in str(md_file):
-                        continue
-                    entries.append(md_file)
-    
-    return entries
-
-
-def format_time_ago(file_path: Path) -> str:
-    """Format time ago string"""
-    mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
-    now = datetime.now()
-    delta = now - mtime
-    
-    days = delta.days
-    if days == 0:
-        return "Today"
-    elif days == 1:
-        return "Yesterday"
-    else:
-        return f"{days} days ago"
-
-
-def get_priority_icon(priority: str) -> str:
-    """Get priority icon"""
-    icons = {
-        'critical': '🔴',
-        'high': '🟠',
-        'medium': '🟡',
-        'low': '🟢'
-    }
-    return icons.get(priority.lower(), '⚪')
-
-
-def get_category_icon(category: str) -> str:
-    """Get category icon"""
-    icons = {
-        'bug': '🐛',
-        'feature': '✨',
-        'architecture': '🏗️',
-        'security': '🔒',
-        'performance': '⚡',
-        'platform': '💻'
-    }
-    return icons.get(category.lower(), '📄')
-
-
-def print_separator(char='━', length=60, color=Colors.CYAN):
-    """Print separator line"""
-    print(f"{color}{char * length}{Colors.RESET}")
-
-
-def print_header(title: str, subtitle: str = None):
-    """Print section header"""
-    Colors.enable_windows()
-    print_separator()
-    print(f"{Colors.CYAN}{Colors.BOLD}{title}{Colors.RESET}")
-    if subtitle:
-        print(f"{Colors.MAGENTA}   {subtitle}{Colors.RESET}")
-    print_separator()
-    print()
-
-
-def print_success(message: str):
-    """Print success message"""
-    print(f"{Colors.GREEN}✅ {message}{Colors.RESET}")
-
-
-def print_error(message: str):
-    """Print error message"""
-    print(f"{Colors.RED}❌ {message}{Colors.RESET}")
-
-
-def print_warning(message: str):
-    """Print warning message"""
-    print(f"{Colors.YELLOW}⚠️  {message}{Colors.RESET}")
-
-
-def print_info(message: str):
-    """Print info message"""
-    print(f"{Colors.CYAN}ℹ️  {message}{Colors.RESET}")

package/bin/lib/kb_compound.py

@@ -1,250 +0,0 @@
-"""
-KB Compound Module
-Cross-platform Neo4j integration
-"""
-
-import os
-import sys
-import subprocess
-from pathlib import Path
-from kb_common import (
-    KBConfig, Colors, print_header, print_success, print_warning, print_error, print_separator
-)
-from kb_search import search_kb
-from kb_add import add_entry
-from kb_index import update_index
-from kb_stats import show_stats
-
-
-def compound_operation(action: str, search_term: str = None):
-    """Execute compound operation"""
-    config = KBConfig()
-    Colors.enable_windows()
-    
-    print_header(
-        "🧠 Knowledge Base Compound System",
-        "Integrated with Neo4j Brain"
-    )
-    
-    if action == 'search':
-        compound_search(config, search_term)
-    elif action == 'add':
-        compound_add(config)
-    elif action == 'sync':
-        compound_sync(config)
-    elif action == 'query':
-        compound_query(config, search_term)
-    elif action == 'stats':
-        compound_stats(config)
-    else:
-        print_error(f"Unknown compound action: {action}")
-
-
-def check_neo4j_available(config: KBConfig) -> bool:
-    """Check if Neo4j tools are available"""
-    neo4j_sync = config.root_dir / "tools" / "neo4j" / "sync_skills_to_neo4j.py"
-    return neo4j_sync.exists()
-
-
-def run_neo4j_script(config: KBConfig, script_name: str, args: list = None) -> bool:
-    """Run Neo4j Python script"""
-    script_path = config.root_dir / "tools" / "neo4j" / script_name
-    
-    if not script_path.exists():
-        return False
-    
-    try:
-        cmd = [sys.executable, str(script_path)]
-        if args:
-            cmd.extend(args)
-        
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print(result.stdout)
-            return True
-        else:
-            print_warning("Neo4j operation had issues (continuing in file mode)")
-            if result.stderr:
-                print(f"{Colors.GRAY}{result.stderr}{Colors.RESET}")
-            return False
-    except Exception as e:
-        print_warning(f"Could not connect to Neo4j: {e}")
-        return False
-
-
-def compound_search(config: KBConfig, search_term: str):
-    """Compound search: Neo4j + File system"""
-    print(f"{Colors.CYAN}🔍 Compound Search: '{search_term}'{Colors.RESET}")
-    print()
-    
-    # Phase 1: Neo4j Brain Search
-    print(f"{Colors.MAGENTA}━━━ Phase 1: Neo4j Brain Search ━━━{Colors.RESET}")
-    
-    if check_neo4j_available(config):
-        neo4j_success = run_neo4j_script(
-            config,
-            'query_skills_neo4j.py',
-            ['--search', search_term]
-        )
-        
-        if neo4j_success:
-            print_success("Neo4j query successful!")
-        else:
-            print_warning("Neo4j not available, using file search only")
-    else:
-        print_warning("Neo4j tools not found, using file search only")
-    
-    print()
-    
-    # Phase 2: File System Search
-    print(f"{Colors.MAGENTA}━━━ Phase 2: File System Search ━━━{Colors.RESET}")
-    search_kb(search_term)
-    
-    print()
-    print_separator('━', 60, Colors.MAGENTA)
-    print(f"{Colors.GREEN}{Colors.BOLD}💡 Compound Search Complete!{Colors.RESET}")
-    print(f"   Searched: Neo4j Brain + File System")
-    print_separator('━', 60, Colors.MAGENTA)
-
-
-def compound_add(config: KBConfig):
-    """Compound add: Create + Index + Sync"""
-    print(f"{Colors.CYAN}➕ Adding New Knowledge Entry{Colors.RESET}")
-    print()
-    
-    # Phase 1: Create Entry
-    print(f"{Colors.MAGENTA}━━━ Phase 1: Create Entry ━━━{Colors.RESET}")
-    add_entry()
-    print()
-    
-    # Phase 2: Update Index
-    print(f"{Colors.MAGENTA}━━━ Phase 2: Update Index ━━━{Colors.RESET}")
-    update_index()
-    print()
-    
-    # Phase 3: Sync to Neo4j
-    print(f"{Colors.MAGENTA}━━━ Phase 3: Sync to Neo4j Brain ━━━{Colors.RESET}")
-    
-    if check_neo4j_available(config):
-        synced = run_neo4j_script(config, 'sync_skills_to_neo4j.py')
-        
-        if synced:
-            print_success("Synced to Neo4j successfully!")
-        else:
-            print_warning("Neo4j sync failed, entry saved to file system")
-    else:
-        print_warning("Neo4j tools not available")
-    
-    print()
-    print_separator('━', 60, Colors.MAGENTA)
-    print(f"{Colors.GREEN}{Colors.BOLD}✅ Compound Add Complete!{Colors.RESET}")
-    print(f"   Entry created, indexed, and synced to brain")
-    print_separator('━', 60, Colors.MAGENTA)
-    
-    if check_neo4j_available(config):
-        print()
-        print(f"{Colors.CYAN}🧠 Your knowledge is now in the Neo4j Brain!{Colors.RESET}")
-        print(f"   It can be queried with relationships and context")
-
-
-def compound_sync(config: KBConfig):
-    """Compound sync: Index + Neo4j + Stats"""
-    print(f"{Colors.CYAN}🔄 Full Compound Sync{Colors.RESET}")
-    print()
-    
-    # Phase 1: Update Index
-    print(f"{Colors.MAGENTA}━━━ Phase 1: Update Index ━━━{Colors.RESET}")
-    update_index()
-    print()
-    
-    # Phase 2: Sync to Neo4j (includes docs/)
-    print(f"{Colors.MAGENTA}━━━ Phase 2: Sync to Neo4j Brain ━━━{Colors.RESET}")
-    print(f"   Syncing: .agent/knowledge-base/ + docs/")
-    print()
-    
-    if check_neo4j_available(config):
-        synced = run_neo4j_script(config, 'sync_skills_to_neo4j.py')
-        
-        if synced:
-            print_success("Synced to Neo4j successfully!")
-        else:
-            print_warning("Neo4j sync had issues")
-    else:
-        print_warning("Neo4j tools not available")
-    
-    print()
-    
-    # Phase 3: Show Stats
-    print(f"{Colors.MAGENTA}━━━ Phase 3: Compound Stats ━━━{Colors.RESET}")
-    show_stats()
-    
-    print()
-    print_separator('━', 60, Colors.MAGENTA)
-    print(f"{Colors.GREEN}{Colors.BOLD}✅ Compound Sync Complete!{Colors.RESET}")
-    print(f"   All knowledge indexed and synced to brain")
-    print_separator('━', 60, Colors.MAGENTA)
-
-
-def compound_query(config: KBConfig, query_term: str):
-    """Compound query: Intelligent Neo4j queries"""
-    print(f"{Colors.CYAN}🧠 Intelligent Query via Neo4j Brain{Colors.RESET}")
-    print()
-    
-    if not check_neo4j_available(config):
-        print_error("Neo4j tools not available")
-        print(f"   Install Neo4j tools in tools/neo4j/")
-        return
-    
-    print(f"Query: '{query_term}'")
-    print()
-    
-    # Search skills
-    print(f"{Colors.MAGENTA}━━━ Searching Skills ━━━{Colors.RESET}")
-    run_neo4j_script(config, 'query_skills_neo4j.py', ['--search', query_term])
-    
-    print()
-    
-    # Related skills
-    print(f"{Colors.MAGENTA}━━━ Related Skills ━━━{Colors.RESET}")
-    run_neo4j_script(config, 'query_skills_neo4j.py', ['--skill', query_term])
-    
-    print()
-    print_separator('━', 60, Colors.MAGENTA)
-    print(f"{Colors.GREEN}{Colors.BOLD}💡 Neo4j Brain Query Complete!{Colors.RESET}")
-    print_separator('━', 60, Colors.MAGENTA)
-
-
-def compound_stats(config: KBConfig):
-    """Compound stats: File system + Neo4j"""
-    print(f"{Colors.CYAN}📊 Compound System Health{Colors.RESET}")
-    print()
-    
-    # Phase 1: File System Stats
-    print(f"{Colors.MAGENTA}━━━ File System Stats ━━━{Colors.RESET}")
-    show_stats()
-    
-    print()
-    
-    # Phase 2: Neo4j Stats
-    print(f"{Colors.MAGENTA}━━━ Neo4j Brain Stats ━━━{Colors.RESET}")
-    
-    if check_neo4j_available(config):
-        success = run_neo4j_script(config, 'query_skills_neo4j.py', ['--all-skills'])
-        
-        if success:
-            print(f"   {Colors.GRAY}(Showing first 20 skills){Colors.RESET}")
-    else:
-        print_warning("Neo4j not available")
-    
-    print()
-    print_separator('━', 60, Colors.MAGENTA)
-    print(f"{Colors.GREEN}{Colors.BOLD}💡 Compound System Status{Colors.RESET}")
-    print(f"   File System: ✅ Active")
-    
-    if check_neo4j_available(config):
-        print(f"   Neo4j Brain: ✅ Connected")
-    else:
-        print(f"   Neo4j Brain: ⚠️  Not Available")
-    
-    print_separator('━', 60, Colors.MAGENTA)

package/bin/lib/kb_index.py

@@ -1,193 +0,0 @@
-"""
-KB Index Module
-Cross-platform INDEX.md generation
-"""
-
-from pathlib import Path
-from datetime import datetime
-from collections import defaultdict
-from kb_common import (
-    KBConfig, Colors, parse_frontmatter, get_kb_entries, get_all_kb_entries,
-    print_header, print_success, get_priority_icon, get_category_icon
-)
-
-
-def update_index():
-    """Update INDEX.md"""
-    config = KBConfig()
-    Colors.enable_windows()
-    
-    print_header("📇 Updating Knowledge Base Index", "Scanning KB + docs directories...")
-    
-    all_paths = config.get_all_kb_paths()
-    entries = get_all_kb_entries(all_paths)
-    
-    # Parse all entries
-    parsed_entries = []
-    for entry_path in entries:
-        try:
-            content = entry_path.read_text(encoding='utf-8')
-            metadata = parse_frontmatter(content)
-            
-            if metadata:
-                metadata['path'] = entry_path
-                metadata['filename'] = entry_path.name
-                parsed_entries.append(metadata)
-        except Exception as e:
-            continue
-    
-    # Group entries
-    by_category = defaultdict(list)
-    by_priority = defaultdict(list)
-    by_date = defaultdict(list)
-    
-    for entry in parsed_entries:
-        category = entry.get('category', 'unknown')
-        priority = entry.get('priority', 'unknown')
-        date = entry.get('date', 'unknown')
-        
-        by_category[category].append(entry)
-        by_priority[priority].append(entry)
-        by_date[date].append(entry)
-    
-    # Generate INDEX.md
-    index_content = generate_index_content(parsed_entries, by_category, by_priority, by_date)
-    
-    # Write INDEX.md
-    index_path = config.get_index_path()
-    index_path.write_text(index_content, encoding='utf-8')
-    
-    print_success(f"INDEX.md Updated Successfully!")
-    print()
-    print(f"{Colors.CYAN}📊 Statistics:{Colors.RESET}")
-    print(f"   Total Entries: {len(parsed_entries)}")
-    print(f"   Categories: {len(by_category)}")
-    print(f"   Priorities: {len(by_priority)}")
-    print()
-
-
-def generate_index_content(entries, by_category, by_priority, by_date):
-    """Generate INDEX.md content"""
-    content = f"""# Knowledge Base Index
-
-**Last Updated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}  
-**Total Entries:** {len(entries)}
-
-This index provides a searchable overview of all knowledge base entries.
-
----
-
-## 📊 Quick Stats
-
-- **Total Entries:** {len(entries)}
-- **Categories:** {len(by_category)}
-- **Priorities:** {len(by_priority)}
-
----
-
-## 📁 By Category
-
-"""
-    
-    # Add entries by category
-    for category in sorted(by_category.keys()):
-        icon = get_category_icon(category)
-        entries_list = by_category[category]
-        content += f"\n### {icon} {category.title()} ({len(entries_list)} entries)\n\n"
-        
-        for entry in sorted(entries_list, key=lambda x: x.get('date', ''), reverse=True):
-            title = entry.get('title', 'Unknown')
-            filename = entry.get('filename', '')
-            priority = entry.get('priority', 'unknown')
-            date = entry.get('date', 'unknown')
-            tags = entry.get('tags', [])
-            
-            priority_icon = get_priority_icon(priority)
-            tags_str = ', '.join(tags) if isinstance(tags, list) else tags
-            
-            content += f"- {priority_icon} **{title}**\n"
-            content += f"  - File: `{filename}`\n"
-            content += f"  - Date: {date} | Priority: {priority}\n"
-            if tags_str:
-                content += f"  - Tags: {tags_str}\n"
-            content += "\n"
-    
-    # Add by priority
-    content += "\n---\n\n## ⚠️ By Priority\n\n"
-    
-    priority_order = ['critical', 'high', 'medium', 'low']
-    for priority in priority_order:
-        if priority in by_priority:
-            icon = get_priority_icon(priority)
-            entries_list = by_priority[priority]
-            content += f"\n### {icon} {priority.title()} ({len(entries_list)} entries)\n\n"
-            
-            for entry in sorted(entries_list, key=lambda x: x.get('date', ''), reverse=True)[:10]:
-                title = entry.get('title', 'Unknown')
-                filename = entry.get('filename', '')
-                category = entry.get('category', 'unknown')
-                
-                content += f"- **{title}** ({category})\n"
-                content += f"  - `{filename}`\n"
-    
-    # Add recent entries
-    content += "\n---\n\n## 📅 Recent Entries (Last 20)\n\n"
-    
-    recent = sorted(entries, key=lambda x: x.get('date', ''), reverse=True)[:20]
-    for entry in recent:
-        title = entry.get('title', 'Unknown')
-        filename = entry.get('filename', '')
-        category = entry.get('category', 'unknown')
-        priority = entry.get('priority', 'unknown')
-        date = entry.get('date', 'unknown')
-        
-        icon = get_priority_icon(priority)
-        content += f"- {icon} **{title}**\n"
-        content += f"  - `{filename}`\n"
-        content += f"  - {date} | {category} | {priority}\n\n"
-    
-    # Add search tips
-    content += """
----
-
-## 🔍 How to Search
-
-### Using CLI
-```bash
-# Search by keyword
-kb search "react hydration"
-
-# Compound search (file + Neo4j)
-kb compound search "authentication"
-```
-
-### Using Scripts
-```bash
-# PowerShell (Windows)
-.\\bin\\kb.ps1 search "term"
-
-# Bash (Linux/Mac)
-./bin/kb search "term"
-```
-
----
-
-## 📝 Adding Entries
-
-```bash
-# Interactive add
-kb add
-
-# Compound add (auto-sync to Neo4j)
-kb compound add
-```
-
----
-
-**Generated by:** Knowledge Base Index Generator  
-**Platform:** Cross-platform (Windows/Linux/macOS)
-
-#knowledge-base #index #searchable
-"""
-    
-    return content