claude-code-templates 1.21.6 → 1.21.8

package/components/agents/obsidian-ops-team/Scripts/enhance_tag_standardizer.py

@@ -1,343 +0,0 @@
-#!/usr/bin/env python3
-"""
-Enhanced Tag Standardizer for hierarchical tag structure.
-Consolidates similar tags and applies hierarchical organization.
-"""
-
-import os
-import re
-import yaml
-from pathlib import Path
-from collections import defaultdict, Counter
-
-class EnhancedTagStandardizer:
-    def __init__(self, vault_path):
-        self.vault_path = Path(vault_path)
-        self.files_updated = 0
-        
-        # Enhanced mappings for better consolidation
-        self.enhanced_mappings = {
-            # AI hierarchy consolidation
-            'ai-development': 'ai/development',
-            'ai-ideas': 'idea',  # Ideas are tracked with 'idea' tag
-            'ai-tools': 'ai/tools',
-            'ai-consulting': 'consulting',
-            'ai-courses': 'learning/course',
-            'ai-conferences-and-competitions': 'learning/conference',
-            'ai-articles-and-research': 'ai/research',
-            'ai-agent': 'ai/agents',
-            'ai-community': 'community',
-            'ai-integration': 'ai/development',
-            'ai-services': 'ai/tools',
-            
-            # Business hierarchy
-            'business-strategy': 'business/strategy',
-            'business-development': 'business/development',
-            'business-intelligence': 'business/analytics',
-            'business-model': 'business/strategy',
-            'business-automation': 'automation',
-            'business-systems': 'business/systems',
-            'business-case': 'business/strategy',
-            'business-context': 'business',
-            'business-research': 'business/research',
-            'business-mapping': 'business/strategy',
-            'business-report': 'business/analytics',
-            'business-operations': 'business/operations',
-            'business-plan': 'business/strategy',
-            'business-transformation': 'business/strategy',
-            'business-solutions': 'business/solutions',
-            'business-assets': 'business/assets',
-            
-            # Client work standardization
-            'client-work': 'client',
-            'client-materials': 'client',
-            'client-analytics': 'client',
-            'client-communication': 'client',
-            
-            # Learning hierarchy
-            'tutorial/course': 'learning/course',
-            'learning-paths': 'learning',
-            'courses': 'learning/course',
-            'tutorials': 'tutorial',
-            'guides': 'tutorial',
-            'training': 'learning',
-            'certifications': 'learning/certification',
-            
-            # Technical tags
-            'development-tools': 'ai/tools',
-            'tools': 'ai/tools',
-            'apis': 'api',
-            'api-integration': 'api',
-            'api-testing': 'testing',
-            
-            # Content organization
-            'daily-notes': 'daily',
-            'daily-email': 'email',
-            'email-summary': 'email',
-            'email-processing': 'email',
-            'email-marketing': 'marketing',
-            
-            # Web development
-            'web-development': 'development',
-            'web-presence': 'business/web-presence',
-            '_web-presence-development': 'business/web-presence',
-            
-            # Personal tags
-            '_personal_': 'personal',
-            'personal-development': 'personal/development',
-            
-            # Project management
-            'project-management': 'project',
-            'project-timeline': 'project',
-            
-            # Marketing & content
-            'content-strategy': 'marketing/content',
-            'content-marketing': 'marketing/content',
-            'content-calendar': 'marketing/calendar',
-            'content-distribution': 'marketing/distribution',
-            'marketing-strategy': 'marketing/strategy',
-            
-            # Technical infrastructure
-            'it-infrastructure': 'infrastructure',
-            'server-management': 'infrastructure',
-            'server-setup': 'infrastructure',
-            
-            # Data and analytics
-            'data-processing': 'data',
-            'data-sources': 'data',
-            'data-security': 'security',
-            
-            # Remove underscores from tags
-            '_tutorials_': 'tutorial',
-            '_business-formation_': 'business/formation',
-            
-            # Standardize compound words
-            'meeting-notes': 'meeting',
-            'meetings': 'meeting',
-            
-            # Standardize plural forms
-            'agents': 'ai/agents',
-            'templates': 'template',
-            'projects': 'project',
-            'tasks': 'action/todo',
-            'sources': 'source',
-            'systems': 'system',
-            'solutions': 'solution',
-            'recommendations': 'recommendation',
-            'transcripts': 'transcript',
-            'discussions': 'discussion',
-            'platforms': 'platform',
-            'frameworks': 'framework',
-            'pipelines': 'pipeline',
-            'servers': 'server',
-            'summaries': 'summary',
-            'conferences': 'conference',
-            'opportunities': 'opportunity',
-            'datasets': 'dataset',
-            
-            # Consolidate similar concepts
-            'thought-leadership': 'authority-building',
-            'technical-authority': 'authority-building',
-            'brainstorming': 'idea',
-            'strategic-planning': 'strategy',
-            'strategic-decision-making': 'strategy',
-            'strategic-overview': 'strategy',
-            'strategic-connections': 'strategy',
-            
-            # Standardize vendor/tool names
-            'anthropic_blog': 'anthropic',
-            'anthropic_github': 'anthropic',
-            'github_topic_-_mcp': 'mcp',
-            'github_topic_-_mcp_server': 'mcp',
-            'mcp_reddit': 'mcp',
-            'mcp_documentation': 'mcp',
-            'mcp_github_discussions': 'mcp',
-            'mcp-server': 'mcp',
-            'npm_-_mcp_packages': 'mcp',
-            'dev.to_mcp_tag': 'mcp',
-            'medium_-_mcp_topics': 'mcp',
-            'pulsemcp_blog': 'pulsemcp',
-            
-            # Clean up system tags
-            'system_files': 'system',
-            'remote_vault01': 'remote-sync',
-            
-            # Consolidate database tags
-            'graph-db': 'database',
-            'graph-databases': 'database',
-            'vector-databases': 'database',
-            'database-queries': 'database',
-            'database-updates': 'database',
-            
-            # Consolidate AI concepts
-            'ai/rag': 'ai/embeddings',
-            'agentic-rag': 'ai/embeddings',
-            'knowledge-graph': 'graphrag',
-            'knowledge-network': 'graphrag',
-            'knowledge-management': 'knowledge-base',
-            
-            # Family tags
-            'family-projects': 'family/projects',
-            'family/index': 'family',
-            
-            # Visual content
-            'visual-assets': 'visual-assets',
-            'visual-organization': 'visual-assets',
-            'visual-learning': 'visual-assets',
-            'visual-search': 'visual-assets',
-            'image-gallery': 'gallery',
-            'image-generation': 'ai/tools',
-            'screenshots': 'visual-assets',
-            'screenshots-and-references': 'visual-assets',
-            'infographics': 'visual-assets',
-            'charts': 'visual-assets',
-            'images': 'visual-assets',
-            'snagit-captures': 'visual-assets',
-            
-            # Analytics and metrics
-            'analytics': 'analytics',
-            'client-analytics': 'analytics',
-            'revenue-analytics': 'analytics',
-            'performance-metrics': 'analytics',
-            'financial-analysis': 'finance',
-            'roi-analysis': 'roi',
-            'roi-calculator': 'roi',
-            
-            # Simplify compound concepts
-            'complexity-analysis': 'analysis',
-            'connection-analysis': 'analysis',
-            'network-analysis': 'analysis',
-            'schema-analysis': 'analysis',
-            'competitive-intelligence': 'analysis',
-            'competitor-tracking': 'analysis',
-            
-            # Standardize workflow tags
-            'workflow': 'workflows',
-            
-            # Clean up misc tags
-            '--ollama-deep-research': 'ollama',
-            'second-opinion-dds': 'dental',
-            'austin-langchain': 'community',
-            'the-build': 'build',
-            'mcpcentral.io': 'mcpcentral',
-        }
-    
-    def extract_frontmatter(self, content):
-        """Extract YAML frontmatter from content."""
-        if not content.strip().startswith('---'):
-            return None, content
-        
-        lines = content.split('\n')
-        if len(lines) < 3:
-            return None, content
-        
-        end_idx = None
-        for i in range(1, len(lines)):
-            if lines[i].strip() == '---':
-                end_idx = i
-                break
-        
-        if end_idx is None:
-            return None, content
-        
-        try:
-            frontmatter_text = '\n'.join(lines[1:end_idx])
-            frontmatter = yaml.safe_load(frontmatter_text)
-            remaining_content = '\n'.join(lines[end_idx + 1:])
-            return frontmatter, remaining_content
-        except yaml.YAMLError:
-            return None, content
-    
-    def enhance_tag(self, tag):
-        """Apply enhanced tag standardization."""
-        # Remove leading/trailing whitespace
-        tag = tag.strip()
-        
-        # Remove hash if present
-        if tag.startswith('#'):
-            tag = tag[1:]
-        
-        # Apply enhanced mappings
-        if tag in self.enhanced_mappings:
-            return self.enhanced_mappings[tag]
-        
-        # Default: lowercase and replace spaces with hyphens
-        return tag.lower().replace(' ', '-')
-    
-    def process_file(self, file_path):
-        """Process a single file with enhanced tag standardization."""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            
-            frontmatter, remaining_content = self.extract_frontmatter(content)
-            
-            if frontmatter is None or 'tags' not in frontmatter:
-                return False
-            
-            # Get current tags
-            current_tags = frontmatter.get('tags', [])
-            if not current_tags:
-                return False
-            
-            # Standardize tags
-            if isinstance(current_tags, list):
-                new_tags = []
-                changed = False
-                
-                for tag in current_tags:
-                    if isinstance(tag, str):
-                        enhanced = self.enhance_tag(tag)
-                        if enhanced != tag:
-                            changed = True
-                        if enhanced and enhanced not in new_tags:
-                            new_tags.append(enhanced)
-                
-                if changed:
-                    # Update frontmatter
-                    frontmatter['tags'] = new_tags
-                    
-                    # Reconstruct content
-                    new_frontmatter = yaml.dump(frontmatter, default_flow_style=False, sort_keys=False)
-                    new_content = f"---\n{new_frontmatter}---\n{remaining_content}"
-                    
-                    # Write back to file
-                    with open(file_path, 'w', encoding='utf-8') as f:
-                        f.write(new_content)
-                    
-                    print(f"Enhanced: {file_path.relative_to(self.vault_path)}")
-                    return True
-            
-            return False
-            
-        except Exception as e:
-            print(f"Error processing {file_path}: {e}")
-            return False
-    
-    def process_vault(self):
-        """Process all files in the vault."""
-        skip_dirs = {'.obsidian', '.trash', '.git'}
-        
-        for file_path in self.vault_path.rglob('*.md'):
-            if any(skip_dir in file_path.parts for skip_dir in skip_dirs):
-                continue
-            
-            if self.process_file(file_path):
-                self.files_updated += 1
-        
-        return self.files_updated
-
-def main():
-    vault_path = '/Users/cam/VAULT01'
-    print(f"Enhanced tag standardization for: {vault_path}")
-    print("This will consolidate similar tags and apply hierarchical organization")
-    print("-" * 60)
-    
-    standardizer = EnhancedTagStandardizer(vault_path)
-    updated = standardizer.process_vault()
-    
-    print("-" * 60)
-    print(f"Total files updated: {updated}")
-
-if __name__ == '__main__':
-    main()

package/components/agents/obsidian-ops-team/Scripts/find_keyword_connections.py

@@ -1,216 +0,0 @@
-#!/usr/bin/env python3
-"""Find and implement keyword-based connections between files."""
-
-import os
-import re
-from collections import Counter, defaultdict
-from pathlib import Path
-
-# Priority keywords to focus on
-PRIORITY_KEYWORDS = {
-    'llm', 'langchain', 'langgraph', 'rag', 'embedding', 'vector',
-    'agent', 'automation', 'workflow', 'pipeline', 'mcp', 'api',
-    'anthropic', 'openai', 'google', 'claude', 'gpt', 'model',
-    'context', 'protocol', 'fastapi', 'docker', 'cloudflare', 
-    'supabase', 'integration', 'framework', 'retrieval', 'augmented',
-    'generation', 'prompt', 'engineering', 'multimodal', 'function',
-    'calling', 'tool', 'use', 'chain', 'thought', 'reasoning'
-}
-
-def extract_keywords_from_file(file_path):
-    """Extract meaningful keywords from a file."""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read().lower()
-        
-        # Extract words (alphanumeric plus hyphens)
-        words = re.findall(r'\b[a-z0-9-]+\b', content)
-        
-        # Filter for priority keywords and count occurrences
-        keyword_counts = Counter()
-        for word in words:
-            if word in PRIORITY_KEYWORDS:
-                keyword_counts[word] += 1
-        
-        return keyword_counts
-    except:
-        return Counter()
-
-def find_keyword_connections(vault_root):
-    """Find files that share multiple priority keywords."""
-    search_dirs = [
-        vault_root / "AI Development",
-        vault_root / "AI Articles and Research",
-        vault_root / "AI IDEAS",
-        vault_root / "AI Courses",
-        vault_root / "CamRohn LLC",
-        vault_root / "Clippings"
-    ]
-    
-    # Collect keyword data for all files
-    file_keywords = {}
-    print("Analyzing files for keywords...")
-    
-    for search_dir in search_dirs:
-        if not search_dir.exists():
-            continue
-            
-        for root, dirs, files in os.walk(search_dir):
-            for file in files:
-                if file.endswith('.md'):
-                    file_path = Path(root) / file
-                    keywords = extract_keywords_from_file(file_path)
-                    if keywords:
-                        file_keywords[file_path] = keywords
-    
-    print(f"Analyzed {len(file_keywords)} files")
-    
-    # Find connections between files
-    connections = []
-    processed_pairs = set()
-    
-    files = list(file_keywords.keys())
-    for i, file1 in enumerate(files):
-        if i % 100 == 0:
-            print(f"Processing file {i+1}/{len(files)}...")
-            
-        for j, file2 in enumerate(files[i+1:], start=i+1):
-            # Skip if already processed
-            pair = tuple(sorted([str(file1), str(file2)]))
-            if pair in processed_pairs:
-                continue
-            processed_pairs.add(pair)
-            
-            # Find common keywords
-            common_keywords = set(file_keywords[file1].keys()) & set(file_keywords[file2].keys())
-            
-            if len(common_keywords) >= 5:  # At least 5 common keywords
-                # Calculate relevance score
-                score = sum(
-                    min(file_keywords[file1][kw], file_keywords[file2][kw])
-                    for kw in common_keywords
-                )
-                
-                connections.append({
-                    'file1': file1,
-                    'file2': file2,
-                    'keywords': list(common_keywords),
-                    'score': score
-                })
-    
-    # Sort by score
-    connections.sort(key=lambda x: x['score'], reverse=True)
-    
-    return connections
-
-def add_link_to_file(file_path, link_to_add, link_text=None):
-    """Add a link to a file if it doesn't already exist."""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-        
-        # Extract just the filename for the link
-        link_filename = Path(link_to_add).stem
-        
-        # Check if link already exists
-        if f'[[{link_filename}]]' in content:
-            return False
-        
-        # Find or create Related section
-        related_match = re.search(r'^## Related\s*$', content, re.MULTILINE)
-        
-        if related_match:
-            # Insert after the Related header
-            insert_pos = related_match.end()
-            # Skip to next line
-            next_line = content.find('\n', insert_pos)
-            if next_line != -1:
-                insert_pos = next_line + 1
-        else:
-            # Add Related section at end
-            if not content.endswith('\n'):
-                content += '\n'
-            content += '\n## Related\n'
-            insert_pos = len(content)
-        
-        # Create the link line
-        if link_text:
-            link_line = f"- [[{link_filename}]] - {link_text}\n"
-        else:
-            link_line = f"- [[{link_filename}]]\n"
-        
-        # Insert the link
-        new_content = content[:insert_pos] + link_line + content[insert_pos:]
-        
-        with open(file_path, 'w', encoding='utf-8') as f:
-            f.write(new_content)
-        
-        return True
-    except Exception as e:
-        print(f"Error updating {file_path}: {e}")
-        return False
-
-def implement_keyword_connections(connections, limit=50):
-    """Implement the top keyword-based connections."""
-    connections_made = 0
-    keyword_clusters = defaultdict(list)
-    
-    for conn in connections[:limit]:
-        file1 = conn['file1']
-        file2 = conn['file2']
-        keywords = conn['keywords']
-        
-        # Create descriptive text
-        keyword_text = f"Shares keywords: {', '.join(sorted(keywords)[:5])}"
-        
-        # Add bidirectional links
-        if add_link_to_file(file1, file2, keyword_text):
-            connections_made += 1
-            print(f"Connected {file1.name} ↔ {file2.name}")
-            
-            # Track keyword clusters
-            for kw in keywords:
-                keyword_clusters[kw].append((file1.name, file2.name))
-        
-        if add_link_to_file(file2, file1, keyword_text):
-            connections_made += 1
-    
-    return connections_made, keyword_clusters
-
-def main():
-    vault_root = Path("/Users/cam/VAULT01")
-    
-    print("Finding keyword-based connections...")
-    connections = find_keyword_connections(vault_root)
-    
-    print(f"\nFound {len(connections)} potential keyword connections")
-    
-    # Show top connections
-    print("\nTop 10 keyword connections by relevance:")
-    for i, conn in enumerate(connections[:10]):
-        print(f"{i+1}. {conn['file1'].name} ↔ {conn['file2'].name}")
-        print(f"   Keywords ({len(conn['keywords'])}): {', '.join(sorted(conn['keywords'])[:8])}")
-        print(f"   Score: {conn['score']}")
-    
-    # Implement connections
-    print("\nImplementing connections...")
-    connections_made, keyword_clusters = implement_keyword_connections(connections)
-    
-    print(f"\n=== Keyword Connection Report ===")
-    print(f"Total connections made: {connections_made}")
-    
-    print("\nMost connected keywords:")
-    sorted_keywords = sorted(keyword_clusters.items(), key=lambda x: len(x[1]), reverse=True)[:10]
-    for keyword, connections in sorted_keywords:
-        print(f"  {keyword}: {len(connections)} connections")
-    
-    # Find cross-domain connections
-    print("\nCross-domain connections:")
-    cross_domain = 0
-    for i, (keyword, conn_list) in enumerate(sorted_keywords[:5]):
-        print(f"\n{keyword}-related cross-domain connections:")
-        for file1_name, file2_name in conn_list[:3]:  # Show first 3 for each keyword
-            print(f"  - {file1_name} ↔ {file2_name}")
-
-if __name__ == "__main__":
-    main()

package/components/agents/obsidian-ops-team/Scripts/fix_quoted_tags.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-"""
-Fix quoted tags in frontmatter by converting single-quoted tags to unquoted format.
-"""
-
-import os
-import re
-import yaml
-from pathlib import Path
-
-def fix_quoted_tags(vault_path):
-    """Fix single-quoted tags in all markdown files."""
-    vault_path = Path(vault_path)
-    files_updated = 0
-    
-    for file_path in vault_path.rglob('*.md'):
-        if any(skip in file_path.parts for skip in ['.obsidian', '.trash', '.git']):
-            continue
-            
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            
-            # Check if file has frontmatter
-            if not content.strip().startswith('---'):
-                continue
-                
-            # Find frontmatter boundaries
-            lines = content.split('\n')
-            if len(lines) < 3:
-                continue
-                
-            end_idx = None
-            for i in range(1, len(lines)):
-                if lines[i].strip() == '---':
-                    end_idx = i
-                    break
-                    
-            if end_idx is None:
-                continue
-                
-            # Extract frontmatter
-            frontmatter_text = '\n'.join(lines[1:end_idx])
-            
-            # Check if tags line has quoted values
-            if re.search(r"tags:\s*\[['\"]", frontmatter_text):
-                # Parse frontmatter
-                try:
-                    frontmatter = yaml.safe_load(frontmatter_text)
-                    if frontmatter and 'tags' in frontmatter:
-                        # Update tags (remove quotes)
-                        tags = frontmatter['tags']
-                        if isinstance(tags, list):
-                            # Tags are already in list format, just ensure they're not quoted
-                            frontmatter['tags'] = [str(tag) for tag in tags]
-                            
-                            # Reconstruct content
-                            new_frontmatter = yaml.dump(frontmatter, default_flow_style=False, sort_keys=False)
-                            remaining_content = '\n'.join(lines[end_idx + 1:])
-                            new_content = f"---\n{new_frontmatter}---\n{remaining_content}"
-                            
-                            # Write back
-                            with open(file_path, 'w', encoding='utf-8') as f:
-                                f.write(new_content)
-                            
-                            files_updated += 1
-                            print(f"Fixed: {file_path.relative_to(vault_path)}")
-                            
-                except yaml.YAMLError as e:
-                    print(f"YAML error in {file_path}: {e}")
-                    
-        except Exception as e:
-            print(f"Error processing {file_path}: {e}")
-    
-    return files_updated
-
-if __name__ == '__main__':
-    vault_path = '/Users/cam/VAULT01'
-    print(f"Fixing quoted tags in: {vault_path}")
-    
-    updated = fix_quoted_tags(vault_path)
-    print(f"\nTotal files updated: {updated}")