agentic-sdlc 1.0.0 → 1.5.0

package/bin/lib/kb_add.py

@@ -0,0 +1,203 @@
+"""
+KB Add Module
+Cross-platform entry creation
+"""
+
+import os
+import subprocess
+from pathlib import Path
+from datetime import datetime
+from kb_common import (
+    KBConfig, Colors, print_header, print_success, print_error, print_info
+)
+
+
+def add_entry():
+    """Add new KB entry interactively"""
+    config = KBConfig()
+    Colors.enable_windows()
+    
+    print_header("📝 Knowledge Base - Add New Entry", "Interactive Entry Creation")
+    
+    # Get entry details
+    print(f"{Colors.CYAN}Enter entry details:{Colors.RESET}")
+    print()
+    
+    title = input(f"{Colors.WHITE}Title: {Colors.RESET}").strip()
+    if not title:
+        print_error("Title is required!")
+        return
+    
+    print()
+    print(f"{Colors.YELLOW}Categories:{Colors.RESET}")
+    print("  1. bug - Bug fixes")
+    print("  2. feature - Complex features")
+    print("  3. architecture - Architecture decisions")
+    print("  4. security - Security fixes")
+    print("  5. performance - Performance optimizations")
+    print("  6. platform - Platform-specific issues")
+    print()
+    
+    category_map = {
+        '1': 'bug',
+        '2': 'feature',
+        '3': 'architecture',
+        '4': 'security',
+        '5': 'performance',
+        '6': 'platform'
+    }
+    
+    category_choice = input(f"{Colors.WHITE}Category (1-6): {Colors.RESET}").strip()
+    category = category_map.get(category_choice, 'feature')
+    
+    print()
+    print(f"{Colors.YELLOW}Priorities:{Colors.RESET}")
+    print("  1. critical - System breaking")
+    print("  2. high - Major issues")
+    print("  3. medium - Moderate issues")
+    print("  4. low - Minor issues")
+    print()
+    
+    priority_map = {
+        '1': 'critical',
+        '2': 'high',
+        '3': 'medium',
+        '4': 'low'
+    }
+    
+    priority_choice = input(f"{Colors.WHITE}Priority (1-4): {Colors.RESET}").strip()
+    priority = priority_map.get(priority_choice, 'medium')
+    
+    print()
+    tags = input(f"{Colors.WHITE}Tags (comma-separated): {Colors.RESET}").strip()
+    attempts = input(f"{Colors.WHITE}Attempts to solve (default: 1): {Colors.RESET}").strip() or "1"
+    time_saved = input(f"{Colors.WHITE}Time saved (e.g., '2 hours'): {Colors.RESET}").strip() or "1 hour"
+    
+    # Generate filename
+    date_str = datetime.now().strftime('%Y-%m-%d')
+    title_slug = title.lower().replace(' ', '-')[:50]
+    title_slug = ''.join(c for c in title_slug if c.isalnum() or c == '-')
+    
+    # Find next ID for today
+    kb_path = config.get_kb_path()
+    existing = list(kb_path.rglob(f"KB-{date_str}-*.md"))
+    next_id = len(existing) + 1
+    
+    filename = f"KB-{date_str}-{next_id:03d}-{title_slug}.md"
+    
+    # Determine folder based on category and priority
+    if category == 'bug':
+        folder = kb_path / 'bugs' / priority
+    elif category == 'feature':
+        folder = kb_path / 'features'
+    else:
+        folder = kb_path / category
+    
+    folder.mkdir(parents=True, exist_ok=True)
+    file_path = folder / filename
+    
+    # Create entry content
+    tags_list = [t.strip() for t in tags.split(',') if t.strip()]
+    
+    content = f"""---
+title: "{title}"
+category: {category}
+priority: {priority}
+sprint: sprint-current
+date: {date_str}
+tags: [{', '.join(tags_list)}]
+related_files: []
+attempts: {attempts}
+time_saved: "{time_saved}"
+---
+
+# {title}
+
+**Date:** {date_str}  
+**Category:** {category}  
+**Priority:** {priority}  
+**Prepared By:** @DEV
+
+---
+
+## Problem
+
+[Describe the problem clearly]
+
+## What Didn't Work
+
+[Document failed attempts - this is valuable learning!]
+
+1. **Attempt 1:**
+   - What was tried
+   - Why it failed
+
+## Root Cause
+
+[What actually caused the problem]
+
+## Solution
+
+[Step-by-step solution that worked]
+
+### Implementation
+
+```
+[Code or configuration that solved it]
+```
+
+## Prevention
+
+[How to avoid this in the future]
+
+## Related Patterns
+
+[Links to similar issues or patterns]
+
+---
+
+## Skills Required
+
+- **Skill 1** - Description
+- **Skill 2** - Description
+
+## Technologies Used
+
+- Technology 1
+- Technology 2
+
+---
+
+#{'#'.join(tags_list)}
+"""
+    
+    # Write file
+    file_path.write_text(content, encoding='utf-8')
+    
+    print()
+    print_success("Entry Created Successfully!")
+    print()
+    print(f"{Colors.CYAN}📄 File: {file_path.relative_to(config.root_dir)}{Colors.RESET}")
+    print()
+    print(f"{Colors.YELLOW}Next steps:{Colors.RESET}")
+    print(f"  1. Edit the file to add details")
+    print(f"  2. Run: {Colors.MAGENTA}kb index{Colors.RESET} to update INDEX.md")
+    print(f"  3. Or use: {Colors.MAGENTA}kb compound add{Colors.RESET} for auto-sync to Neo4j")
+    print()
+    
+    # Try to open in editor
+    try:
+        if config.is_windows():
+            os.startfile(str(file_path))
+        elif config.is_macos():
+            subprocess.run(['open', str(file_path)])
+        else:  # Linux
+            # Try common editors
+            for editor in ['xdg-open', 'gedit', 'nano', 'vim']:
+                try:
+                    subprocess.run([editor, str(file_path)])
+                    break
+                except:
+                    continue
+    except:
+        print_info(f"Please edit the file manually: {file_path}")

package/bin/lib/kb_common.py

@@ -0,0 +1,224 @@
+"""
+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

@@ -0,0 +1,250 @@
+"""
+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)