claude-code-templates 1.21.1 → 1.21.2

package/cli-tool/components/agents/obsidian-ops-team/Scripts/moc_generator.py

@@ -1,296 +0,0 @@
-#!/usr/bin/env python3
-"""
-MOC (Map of Content) Generator for Obsidian Vault
-Automatically generates MOCs for directories and topics.
-"""
-
-import os
-import re
-from pathlib import Path
-from datetime import datetime
-from collections import defaultdict
-import argparse
-
-class MOCGenerator:
-    def __init__(self, vault_path):
-        self.vault_path = Path(vault_path)
-        self.directory_stats = {}
-        self.topic_clusters = defaultdict(list)
-        
-    def analyze_directory(self, directory_path):
-        """Analyze a directory and its contents."""
-        stats = {
-            'total_files': 0,
-            'md_files': 0,
-            'subdirectories': [],
-            'file_types': defaultdict(int),
-            'common_topics': defaultdict(int)
-        }
-        
-        try:
-            for item in directory_path.iterdir():
-                if item.is_file():
-                    stats['total_files'] += 1
-                    if item.suffix == '.md':
-                        stats['md_files'] += 1
-                        # Extract topics from filename
-                        topics = self.extract_topics_from_filename(item.name)
-                        for topic in topics:
-                            stats['common_topics'][topic] += 1
-                    stats['file_types'][item.suffix] += 1
-                elif item.is_dir() and not item.name.startswith('.'):
-                    stats['subdirectories'].append(item.name)
-        except PermissionError:
-            print(f"Permission denied: {directory_path}")
-            
-        return stats
-    
-    def extract_topics_from_filename(self, filename):
-        """Extract potential topics from filename."""
-        # Remove extension and common prefixes
-        name = filename.replace('.md', '')
-        name = re.sub(r'^\d{4}-\d{2}-\d{2}[_-]', '', name)  # Remove date prefix
-        name = re.sub(r'^MOC[_-]', '', name)  # Remove MOC prefix
-        
-        # Split on common separators and filter
-        words = re.split(r'[_\-\s]+', name)
-        topics = []
-        
-        # Filter out common words and keep meaningful terms
-        stop_words = {'and', 'the', 'for', 'with', 'to', 'of', 'in', 'on', 'at', 'by'}
-        
-        for word in words:
-            if len(word) > 2 and word.lower() not in stop_words:
-                topics.append(word.lower())
-        
-        return topics
-    
-    def generate_moc_content(self, directory_path, title, description=""):
-        """Generate MOC content for a directory."""
-        stats = self.analyze_directory(directory_path)
-        
-        # Create frontmatter
-        frontmatter = f"""---
-tags: [MOC, {directory_path.name.lower().replace(' ', '-')}]
-type: map-of-content
-created: {datetime.now().strftime('%Y-%m-%d')}
-modified: {datetime.now().strftime('%Y-%m-%d')}
-status: active
-cssclass: moc
-aliases: [{title} Hub, {title} Overview]
-hub_for: [{directory_path.name}]
-related_mocs: []
----
-
-"""
-        
-        # Create content
-        content = f"""# {title} Map of Content
-
-## Overview
-{description if description else f"This MOC organizes all content related to {title.lower()}."}
-
-**Directory**: `{directory_path.name}/`
-**Total Files**: {stats['md_files']} markdown files
-**Last Updated**: {datetime.now().strftime('%Y-%m-%d')}
-
-"""
-        
-        # Add subdirectories if any
-        if stats['subdirectories']:
-            content += "## Subdirectories\n\n"
-            for subdir in sorted(stats['subdirectories']):
-                content += f"### {subdir}\n"
-                content += f"- [[MOC - {subdir}|{subdir} Overview]]\n\n"
-        
-        # Organize files by topic
-        content += self.organize_files_by_topic(directory_path, stats)
-        
-        # Add common topics section
-        if stats['common_topics']:
-            content += "## Key Topics\n\n"
-            sorted_topics = sorted(stats['common_topics'].items(), key=lambda x: x[1], reverse=True)
-            for topic, count in sorted_topics[:10]:  # Top 10 topics
-                content += f"- **{topic.title()}** ({count} files)\n"
-            content += "\n"
-        
-        # Add templates and resources
-        content += """## Related MOCs
-- [[MOC - AI Development|AI Development]]
-- [[MOC - Learning Resources|Learning Resources]]
-- [[Master Index|🗂️ Master Index]]
-
-## Status & Progress
-- [ ] Organize files by topic
-- [ ] Add cross-references
-- [ ] Review and update links
-- [ ] Add examples and tutorials
-
-## Next Steps
-- Review all files in this directory
-- Create sub-MOCs for large topic clusters
-- Add relevant tags to all files
-- Connect to related MOCs
-
----
-*This MOC was auto-generated. Please review and customize as needed.*
-"""
-        
-        return frontmatter + content
-    
-    def organize_files_by_topic(self, directory_path, stats):
-        """Organize files by topic clusters."""
-        content = "## Content Organization\n\n"
-        
-        # Group files by topic
-        topic_files = defaultdict(list)
-        ungrouped_files = []
-        
-        try:
-            for file_path in directory_path.glob('*.md'):
-                if file_path.name.startswith('MOC'):
-                    continue  # Skip existing MOCs
-                
-                topics = self.extract_topics_from_filename(file_path.name)
-                if topics:
-                    # Use first topic as primary grouping
-                    primary_topic = topics[0]
-                    topic_files[primary_topic].append(file_path)
-                else:
-                    ungrouped_files.append(file_path)
-        
-        except Exception as e:
-            print(f"Error organizing files: {e}")
-            return content
-        
-        # Sort topics by number of files
-        sorted_topics = sorted(topic_files.items(), key=lambda x: len(x[1]), reverse=True)
-        
-        for topic, files in sorted_topics:
-            if len(files) > 1:  # Only create sections for topics with multiple files
-                content += f"### {topic.title()}\n"
-                for file_path in sorted(files):
-                    title = file_path.stem.replace('_', ' ').replace('-', ' ')
-                    content += f"- [[{title}]]\n"
-                content += "\n"
-        
-        # Add ungrouped files
-        if ungrouped_files:
-            content += "### Other Files\n"
-            for file_path in sorted(ungrouped_files):
-                title = file_path.stem.replace('_', ' ').replace('-', ' ')
-                content += f"- [[{title}]]\n"
-            content += "\n"
-        
-        return content
-    
-    def create_moc_file(self, directory_path, title, description="", output_path=None):
-        """Create a MOC file for a directory."""
-        content = self.generate_moc_content(directory_path, title, description)
-        
-        if output_path is None:
-            # Create MOCs in the centralized map-of-content directory
-            moc_dir = self.vault_path / "map-of-content"
-            moc_dir.mkdir(exist_ok=True)
-            output_path = moc_dir / f"MOC - {title}.md"
-        
-        # Check if file already exists
-        if output_path.exists():
-            print(f"MOC already exists: {output_path}")
-            return False
-        
-        try:
-            with open(output_path, 'w', encoding='utf-8') as f:
-                f.write(content)
-            print(f"Created MOC: {output_path}")
-            return True
-        except Exception as e:
-            print(f"Error creating MOC: {e}")
-            return False
-    
-    def suggest_mocs(self):
-        """Suggest MOCs for directories that don't have them."""
-        suggestions = []
-        
-        # Skip these directories
-        skip_dirs = {'.obsidian', '.trash', 'System_Files', '.git'}
-        
-        for directory in self.vault_path.iterdir():
-            if not directory.is_dir() or directory.name in skip_dirs:
-                continue
-            
-            stats = self.analyze_directory(directory)
-            
-            # Check if directory has enough content to warrant a MOC
-            if stats['md_files'] >= 3:
-                # Check if MOC already exists
-                existing_mocs = list(directory.glob('MOC*.md'))
-                if not existing_mocs:
-                    suggestions.append({
-                        'directory': directory,
-                        'title': directory.name,
-                        'file_count': stats['md_files'],
-                        'subdirs': len(stats['subdirectories']),
-                        'top_topics': sorted(stats['common_topics'].items(), 
-                                          key=lambda x: x[1], reverse=True)[:5]
-                    })
-        
-        return suggestions
-
-def main():
-    parser = argparse.ArgumentParser(description='Generate MOCs for Obsidian vault')
-    parser.add_argument('--vault', default='/Users/cam/VAULT01',
-                       help='Path to Obsidian vault')
-    parser.add_argument('--directory', 
-                       help='Specific directory to create MOC for')
-    parser.add_argument('--title',
-                       help='Title for the MOC')
-    parser.add_argument('--description',
-                       help='Description for the MOC')
-    parser.add_argument('--suggest', action='store_true',
-                       help='Suggest directories that need MOCs')
-    parser.add_argument('--create-all', action='store_true',
-                       help='Create MOCs for all suggested directories')
-    
-    args = parser.parse_args()
-    
-    generator = MOCGenerator(args.vault)
-    
-    if args.suggest or args.create_all:
-        suggestions = generator.suggest_mocs()
-        
-        if args.suggest:
-            print("MOC Suggestions:")
-            print("="*50)
-            for suggestion in suggestions:
-                print(f"Directory: {suggestion['directory'].name}")
-                print(f"  Files: {suggestion['file_count']}")
-                print(f"  Subdirs: {suggestion['subdirs']}")
-                if suggestion['top_topics']:
-                    topics = [f"{topic} ({count})" for topic, count in suggestion['top_topics']]
-                    print(f"  Topics: {', '.join(topics)}")
-                print()
-        
-        if args.create_all:
-            for suggestion in suggestions:
-                generator.create_moc_file(
-                    suggestion['directory'],
-                    suggestion['title']
-                )
-    
-    elif args.directory:
-        directory_path = Path(args.vault) / args.directory
-        if not directory_path.exists():
-            print(f"Directory not found: {directory_path}")
-            return
-        
-        title = args.title or directory_path.name
-        description = args.description or ""
-        
-        generator.create_moc_file(directory_path, title, description)
-    
-    else:
-        parser.print_help()
-
-if __name__ == '__main__':
-    main()

package/cli-tool/components/agents/obsidian-ops-team/Scripts/parse_keyword_connections.py

@@ -1,122 +0,0 @@
-#!/usr/bin/env python3
-"""Parse keyword connections from Link Suggestions Report."""
-
-import re
-import sys
-from pathlib import Path
-
-def parse_keyword_connections(report_path):
-    """Parse keyword connections from the report and find meaningful ones."""
-    
-    with open(report_path, 'r', encoding='utf-8') as f:
-        content = f.read()
-    
-    # Find the keyword-based section
-    keyword_section_start = content.find("## Keyword-Based Link Suggestions")
-    if keyword_section_start == -1:
-        print("Could not find keyword-based section")
-        return []
-    
-    # Find the next section (orphaned notes)
-    orphaned_section_start = content.find("## Orphaned Notes", keyword_section_start)
-    if orphaned_section_start == -1:
-        keyword_section = content[keyword_section_start:]
-    else:
-        keyword_section = content[keyword_section_start:orphaned_section_start]
-    
-    # Pattern to match connections
-    pattern = r'- \[\[([^\]]+)\]\] ↔ \[\[([^\]]+)\]\]\s*\n\s*Common words: ([^\n]+)'
-    
-    connections = []
-    for match in re.finditer(pattern, keyword_section):
-        file1 = match.group(1).strip()
-        file2 = match.group(2).strip()
-        keywords = match.group(3).strip()
-        
-        # Skip self-connections
-        if file1 == file2:
-            continue
-            
-        # Count keywords
-        keyword_list = [k.strip() for k in keywords.split(',')]
-        keyword_count = len(keyword_list)
-        
-        # Only include connections with 5+ keywords
-        if keyword_count >= 5:
-            connections.append({
-                'file1': file1,
-                'file2': file2,
-                'keywords': keyword_list,
-                'count': keyword_count
-            })
-    
-    # Sort by keyword count descending
-    connections.sort(key=lambda x: x['count'], reverse=True)
-    
-    return connections
-
-def main():
-    report_path = Path("/Users/cam/VAULT01/System_Files/Link_Suggestions_Report.md")
-    
-    connections = parse_keyword_connections(report_path)
-    
-    print(f"Found {len(connections)} meaningful keyword connections (5+ keywords)\n")
-    
-    # Group by keyword themes
-    tech_keywords = {'llm', 'langchain', 'langgraph', 'rag', 'embedding', 'vector', 'agent', 'model', 'api', 'mcp'}
-    framework_keywords = {'langchain', 'langgraph', 'fastapi', 'docker', 'cloudflare', 'supabase'}
-    company_keywords = {'openai', 'anthropic', 'google', 'microsoft', 'meta'}
-    concept_keywords = {'automation', 'workflow', 'pipeline', 'integration', 'generation', 'retrieval'}
-    
-    tech_connections = []
-    framework_connections = []
-    company_connections = []
-    concept_connections = []
-    
-    for conn in connections:
-        keywords_lower = [k.lower() for k in conn['keywords']]
-        
-        tech_score = len([k for k in keywords_lower if any(tech in k for tech in tech_keywords)])
-        framework_score = len([k for k in keywords_lower if any(fw in k for fw in framework_keywords)])
-        company_score = len([k for k in keywords_lower if any(comp in k for comp in company_keywords)])
-        concept_score = len([k for k in keywords_lower if any(conc in k for conc in concept_keywords)])
-        
-        if tech_score >= 2:
-            tech_connections.append(conn)
-        if framework_score >= 2:
-            framework_connections.append(conn)
-        if company_score >= 1:
-            company_connections.append(conn)
-        if concept_score >= 2:
-            concept_connections.append(conn)
-    
-    print("## High-Priority Technical Connections")
-    print(f"Found {len(tech_connections)} connections with technical keywords\n")
-    for i, conn in enumerate(tech_connections[:20]):  # Top 20
-        print(f"{i+1}. [[{conn['file1']}]] ↔ [[{conn['file2']}]]")
-        print(f"   Keywords ({conn['count']}): {', '.join(conn['keywords'][:10])}")
-        print()
-    
-    print("\n## Framework-Related Connections")
-    print(f"Found {len(framework_connections)} connections with framework keywords\n")
-    for i, conn in enumerate(framework_connections[:15]):  # Top 15
-        print(f"{i+1}. [[{conn['file1']}]] ↔ [[{conn['file2']}]]")
-        print(f"   Keywords ({conn['count']}): {', '.join(conn['keywords'][:10])}")
-        print()
-    
-    print("\n## Company/Provider Connections")
-    print(f"Found {len(company_connections)} connections with company keywords\n")
-    for i, conn in enumerate(company_connections[:10]):  # Top 10
-        print(f"{i+1}. [[{conn['file1']}]] ↔ [[{conn['file2']}]]")
-        print(f"   Keywords ({conn['count']}): {', '.join(conn['keywords'][:10])}")
-        print()
-    
-    print("\n## Concept/Workflow Connections")
-    print(f"Found {len(concept_connections)} connections with concept keywords\n")
-    for i, conn in enumerate(concept_connections[:10]):  # Top 10
-        print(f"{i+1}. [[{conn['file1']}]] ↔ [[{conn['file2']}]]")
-        print(f"   Keywords ({conn['count']}): {', '.join(conn['keywords'][:10])}")
-        print()
-
-if __name__ == "__main__":
-    main()