agentic-sdlc 1.0.0 → 1.5.0

package/bin/lib/kb_index.py

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

package/bin/lib/kb_list.py

@@ -0,0 +1,144 @@
+"""
+KB List Module
+Cross-platform entry listing
+"""
+
+from pathlib import Path
+from kb_common import (
+    KBConfig, Colors, parse_frontmatter, get_kb_entries, format_time_ago,
+    print_header, get_priority_icon, get_category_icon
+)
+
+
+def list_entries(category=None, recent=None):
+    """List KB entries"""
+    config = KBConfig()
+    Colors.enable_windows()
+    
+    if recent:
+        list_recent_entries(config, recent)
+    elif category:
+        list_by_category(config, category)
+    else:
+        list_all_entries(config)
+
+
+def list_all_entries(config: KBConfig):
+    """List all entries"""
+    print_header("📋 Listing All Entries", "All knowledge base entries")
+    
+    kb_path = config.get_kb_path()
+    entries = get_kb_entries(kb_path)
+    
+    if not entries:
+        print(f"{Colors.YELLOW}No entries found.{Colors.RESET}")
+        return
+    
+    print(f"{Colors.GREEN}Found {len(entries)} entries:{Colors.RESET}")
+    print()
+    
+    # Sort by date (newest first)
+    sorted_entries = sorted(entries, key=lambda x: x.name, reverse=True)
+    
+    for entry_path in sorted_entries:
+        try:
+            content = entry_path.read_text(encoding='utf-8')
+            metadata = parse_frontmatter(content)
+            
+            title = metadata.get('title', 'Unknown')
+            priority = metadata.get('priority', 'unknown')
+            category = metadata.get('category', 'unknown')
+            
+            priority_icon = get_priority_icon(priority)
+            category_icon = get_category_icon(category)
+            
+            rel_path = entry_path.relative_to(config.root_dir)
+            
+            print(f"  {priority_icon} {category_icon} {Colors.WHITE}{title}{Colors.RESET}")
+            print(f"     {Colors.GRAY}{rel_path}{Colors.RESET}")
+            print()
+        except:
+            continue
+
+
+def list_by_category(config: KBConfig, category: str):
+    """List entries by category"""
+    print_header(f"📋 Listing Entries in Category: {category}", f"Filtered by {category}")
+    
+    kb_path = config.get_kb_path()
+    category_path = kb_path / category
+    
+    if not category_path.exists():
+        # Try common category paths
+        for cat_dir in ['bugs', 'features', 'architecture', 'security', 'performance', 'platform-specific']:
+            if category.lower() in cat_dir:
+                category_path = kb_path / cat_dir
+                break
+    
+    if not category_path.exists():
+        print(f"{Colors.YELLOW}Category not found: {category}{Colors.RESET}")
+        print()
+        print(f"{Colors.CYAN}Available categories:{Colors.RESET}")
+        for cat_dir in kb_path.iterdir():
+            if cat_dir.is_dir() and not cat_dir.name.startswith('.'):
+                print(f"  - {cat_dir.name}")
+        return
+    
+    entries = list(category_path.rglob('KB-*.md'))
+    
+    if not entries:
+        print(f"{Colors.YELLOW}No entries found in category: {category}{Colors.RESET}")
+        return
+    
+    print(f"{Colors.GREEN}Found {len(entries)} entries:{Colors.RESET}")
+    print()
+    
+    for entry_path in sorted(entries, key=lambda x: x.name, reverse=True):
+        try:
+            content = entry_path.read_text(encoding='utf-8')
+            metadata = parse_frontmatter(content)
+            
+            title = metadata.get('title', 'Unknown')
+            priority = metadata.get('priority', 'unknown')
+            
+            priority_icon = get_priority_icon(priority)
+            rel_path = entry_path.relative_to(config.root_dir)
+            
+            print(f"  {priority_icon} {Colors.WHITE}{title}{Colors.RESET}")
+            print(f"     {Colors.GRAY}{rel_path}{Colors.RESET}")
+            print()
+        except:
+            continue
+
+
+def list_recent_entries(config: KBConfig, count: int):
+    """List recent entries"""
+    print_header(f"📅 Recent {count} Entries", "Most recently modified")
+    
+    kb_path = config.get_kb_path()
+    entries = get_kb_entries(kb_path)
+    
+    if not entries:
+        print(f"{Colors.YELLOW}No entries found.{Colors.RESET}")
+        return
+    
+    # Sort by modification time
+    sorted_entries = sorted(entries, key=lambda x: x.stat().st_mtime, reverse=True)[:count]
+    
+    for entry_path in sorted_entries:
+        try:
+            content = entry_path.read_text(encoding='utf-8')
+            metadata = parse_frontmatter(content)
+            
+            title = metadata.get('title', 'Unknown')
+            category = metadata.get('category', 'unknown')
+            priority = metadata.get('priority', 'unknown')
+            
+            time_ago = format_time_ago(entry_path)
+            category_icon = get_category_icon(category)
+            
+            print(f"  {category_icon} {Colors.WHITE}{title}{Colors.RESET}")
+            print(f"     Category: {category} | {Colors.GRAY}{time_ago}{Colors.RESET}")
+            print()
+        except:
+            continue

package/bin/lib/kb_search.py

@@ -0,0 +1,121 @@
+"""
+KB Search Module
+Cross-platform search functionality
+"""
+
+import re
+from pathlib import Path
+from typing import List, Dict
+from kb_common import (
+    KBConfig, Colors, parse_frontmatter, get_kb_entries, get_all_kb_entries,
+    print_header, print_success, print_warning, get_priority_icon
+)
+
+
+def search_kb(search_term: str):
+    """Search knowledge base"""
+    config = KBConfig()
+    Colors.enable_windows()
+    
+    print_header(
+        f"🔍 Searching Knowledge Base for: '{search_term}'",
+        "File System Search"
+    )
+    
+    # Search INDEX.md first
+    results_from_index = search_index(config, search_term)
+    
+    # Search all KB files
+    results_from_files = search_files(config, search_term)
+    
+    # Display results
+    total_results = len(results_from_index) + len(results_from_files)
+    
+    if total_results == 0:
+        print_warning(f"No results found for '{search_term}'")
+        print()
+        print(f"{Colors.CYAN}💡 Tips:{Colors.RESET}")
+        print(f"   - Try different keywords")
+        print(f"   - Use broader search terms")
+        print(f"   - Check spelling")
+        print(f"   - Try compound search: {Colors.MAGENTA}kb compound search '{search_term}'{Colors.RESET}")
+    else:
+        print()
+        print(f"{Colors.GREEN}📊 Search Results: {total_results} entries found{Colors.RESET}")
+    
+    print()
+
+
+def search_index(config: KBConfig, search_term: str) -> List[str]:
+    """Search INDEX.md"""
+    if not config.get_index_path().exists():
+        return []
+    
+    content = config.get_index_path().read_text(encoding='utf-8')
+    results = []
+    
+    # Search for term in index
+    pattern = re.compile(re.escape(search_term), re.IGNORECASE)
+    
+    for line in content.split('\n'):
+        if pattern.search(line) and line.strip().startswith('-'):
+            results.append(line.strip())
+    
+    if results:
+        print(f"{Colors.GREEN}✅ Found in INDEX:{Colors.RESET}")
+        for result in results[:5]:  # Show first 5
+            print(f"  {result}")
+        print()
+    
+    return results
+
+
+def search_files(config: KBConfig, search_term: str) -> List[Dict]:
+    """Search all KB files (KB + docs)"""
+    all_paths = config.get_all_kb_paths()
+    entries = get_all_kb_entries(all_paths)
+    
+    results = []
+    pattern = re.compile(re.escape(search_term), re.IGNORECASE)
+    
+    for entry_path in entries:
+        try:
+            content = entry_path.read_text(encoding='utf-8')
+            
+            # Check if term is in content
+            if pattern.search(content):
+                metadata = parse_frontmatter(content)
+                
+                # Extract context (line with match)
+                context_lines = []
+                for line in content.split('\n'):
+                    if pattern.search(line):
+                        context_lines.append(line.strip())
+                        if len(context_lines) >= 3:
+                            break
+                
+                results.append({
+                    'path': entry_path,
+                    'title': metadata.get('title', 'Unknown'),
+                    'category': metadata.get('category', 'unknown'),
+                    'priority': metadata.get('priority', 'unknown'),
+                    'context': context_lines
+                })
+        except Exception as e:
+            continue
+    
+    # Display file results
+    if results:
+        for i, result in enumerate(results, 1):
+            icon = get_priority_icon(result['priority'])
+            print(f"{Colors.GREEN}✅ Found: {result['title']}{Colors.RESET}")
+            print(f"   {icon} File: {result['path'].relative_to(config.root_dir)}")
+            print(f"   Category: {result['category']} | Priority: {result['priority']}")
+            
+            if result['context']:
+                print(f"   {Colors.CYAN}Context:{Colors.RESET}")
+                for ctx in result['context'][:2]:
+                    print(f"     {ctx[:80]}...")
+            print()
+    
+    return results

package/bin/lib/kb_stats.py

@@ -0,0 +1,153 @@
+"""
+KB Stats Module
+Cross-platform statistics display
+"""
+
+from pathlib import Path
+from datetime import datetime
+from collections import defaultdict
+from kb_common import (
+    KBConfig, Colors, parse_frontmatter, get_kb_entries, format_time_ago,
+    print_header, get_priority_icon, get_category_icon
+)
+
+
+def show_stats():
+    """Show KB statistics"""
+    config = KBConfig()
+    Colors.enable_windows()
+    
+    print_header("📊 Knowledge Base Statistics", "Analyzing entries...")
+    
+    kb_path = config.get_kb_path()
+    entries = get_kb_entries(kb_path)
+    
+    if not entries:
+        print(f"{Colors.YELLOW}No entries found in knowledge base.{Colors.RESET}")
+        print()
+        print(f"{Colors.CYAN}💡 Add your first entry:{Colors.RESET}")
+        print(f"   kb add")
+        return
+    
+    # Parse entries
+    parsed = []
+    total_attempts = 0
+    total_time_saved = 0
+    
+    by_category = defaultdict(int)
+    by_priority = defaultdict(int)
+    by_month = defaultdict(int)
+    
+    for entry_path in entries:
+        try:
+            content = entry_path.read_text(encoding='utf-8')
+            metadata = parse_frontmatter(content)
+            
+            if metadata:
+                metadata['path'] = entry_path
+                parsed.append(metadata)
+                
+                # Count stats
+                category = metadata.get('category', 'unknown')
+                priority = metadata.get('priority', 'unknown')
+                date = metadata.get('date', 'unknown')
+                
+                by_category[category] += 1
+                by_priority[priority] += 1
+                
+                if date != 'unknown':
+                    month = date[:7]  # YYYY-MM
+                    by_month[month] += 1
+                
+                # Attempts
+                attempts = metadata.get('attempts', '0')
+                try:
+                    total_attempts += int(attempts)
+                except:
+                    pass
+                
+                # Time saved
+                time_saved = metadata.get('time_saved', '0')
+                if 'hour' in time_saved.lower():
+                    try:
+                        hours = float(time_saved.split()[0])
+                        total_time_saved += hours
+                    except:
+                        pass
+        except:
+            continue
+    
+    # Display stats
+    print(f"{Colors.WHITE}{Colors.BOLD}📚 Total Entries: {len(parsed)}{Colors.RESET}")
+    print()
+    
+    # By category
+    if by_category:
+        print(f"{Colors.YELLOW}{Colors.BOLD}📁 By Category:{Colors.RESET}")
+        max_count = max(by_category.values())
+        for category in sorted(by_category.keys()):
+            count = by_category[category]
+            percentage = (count / len(parsed)) * 100
+            icon = get_category_icon(category)
+            bar_length = int((count / max_count) * 30)
+            bar = '█' * bar_length
+            
+            print(f"   {icon} {category.ljust(15)} : {count} entries ({percentage:.1f}%)")
+            print(f"   {Colors.CYAN}{bar}{Colors.RESET}")
+        print()
+    
+    # By priority
+    if by_priority:
+        print(f"{Colors.YELLOW}{Colors.BOLD}⚠️  By Priority:{Colors.RESET}")
+        priority_order = ['critical', 'high', 'medium', 'low']
+        for priority in priority_order:
+            if priority in by_priority:
+                count = by_priority[priority]
+                percentage = (count / len(parsed)) * 100
+                icon = get_priority_icon(priority)
+                print(f"   {icon} {priority.ljust(12)} : {count} entries ({percentage:.1f}%)")
+        print()
+    
+    # Compound metrics
+    print(f"{Colors.YELLOW}{Colors.BOLD}📈 Compound Learning Metrics:{Colors.RESET}")
+    avg_attempts = total_attempts / len(parsed) if parsed else 0
+    avg_time_saved = total_time_saved / len(parsed) if parsed else 0
+    projected_time = total_time_saved * 2  # Assume 2x reuse
+    
+    print(f"   Total Attempts: {total_attempts}")
+    print(f"   Avg Attempts per Entry: {avg_attempts:.1f}")
+    print(f"   Total Time Saved: ~{int(total_time_saved)} hours")
+    print(f"   Avg Time Saved per Entry: ~{avg_time_saved:.1f} hours")
+    print(f"   Projected Time Saved (2x reuse): ~{int(projected_time)} hours")
+    print()
+    
+    # Recent activity
+    print(f"{Colors.YELLOW}{Colors.BOLD}📅 Recent Activity:{Colors.RESET}")
+    recent = sorted(parsed, key=lambda x: x.get('path').stat().st_mtime, reverse=True)[:5]
+    
+    for entry in recent:
+        title = entry.get('title', 'Unknown')
+        path = entry.get('path')
+        time_ago = format_time_ago(path)
+        
+        print(f"   - {title}")
+        print(f"     {Colors.GRAY}{time_ago}{Colors.RESET}")
+    print()
+    
+    # Growth trend
+    if by_month:
+        print(f"{Colors.YELLOW}{Colors.BOLD}📊 Growth Trend:{Colors.RESET}")
+        for month in sorted(by_month.keys(), reverse=True)[:6]:
+            count = by_month[month]
+            bar = '█' * count
+            print(f"   {month} : {count} entries")
+            print(f"   {Colors.CYAN}{bar}{Colors.RESET}")
+        print()
+    
+    # Compound effect message
+    print(f"{Colors.CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━{Colors.RESET}")
+    print(f"{Colors.GREEN}{Colors.BOLD}💡 Compound Effect:{Colors.RESET}")
+    print(f"   Each entry makes future work easier!")
+    print(f"   Keep documenting to compound your knowledge! 🚀")
+    print(f"{Colors.CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━{Colors.RESET}")
+    print()