claude-code-templates 1.21.4 → 1.21.6

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

@@ -0,0 +1,343 @@
+#!/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

@@ -0,0 +1,216 @@
+#!/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

@@ -0,0 +1,82 @@
+#!/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}")