claude-code-templates 1.21.13 → 1.22.1

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

@@ -1,306 +0,0 @@
-#!/usr/bin/env python3
-"""
-Daily Notes Connectivity Agent
-Analyzes daily notes and creates meaningful connections between them and other vault content.
-"""
-
-import os
-import re
-import yaml
-from datetime import datetime, timedelta
-from pathlib import Path
-from collections import defaultdict
-import json
-
-class DailyNotesConnector:
-    def __init__(self, vault_path):
-        self.vault_path = Path(vault_path)
-        self.connections_made = 0
-        self.notes_processed = 0
-        self.patterns = {
-            'project': r'(?:project|AI IDEAS|idea|experiment|build|develop)',
-            'meeting': r'(?:meeting|call|discussion|client|consultation)',
-            'technical': r'(?:MCP|LangChain|GraphRAG|AI|ML|model|agent|tool)',
-            'client': r'(?:client|consulting|business|CamRohn)',
-            'personal': r'(?:family|personal|reflection|stoic|goal)',
-            'research': r'(?:research|paper|study|article|documentation)',
-            'community': r'(?:Austin|LangChain|meetup|community|conference)'
-        }
-        self.connection_map = defaultdict(list)
-        
-    def find_daily_notes(self):
-        """Find all daily notes across the vault."""
-        daily_notes = []
-        
-        # Search patterns for daily notes
-        patterns = [
-            self.vault_path / "Daily Notes" / "*.md",
-            self.vault_path / "REMOTE_VAULT01" / "Daily Notes" / "*.md",
-            self.vault_path / "Daily Email" / "*.md",
-            self.vault_path / "_PERSONAL_" / "JOURNAL" / "**" / "*.md"
-        ]
-        
-        for pattern in patterns:
-            for file_path in self.vault_path.glob(str(pattern).split(str(self.vault_path) + "/")[1]):
-                # Check if filename matches date pattern
-                if re.match(r'\d{4}-\d{2}-\d{2}', file_path.stem):
-                    daily_notes.append(file_path)
-                    
-        return sorted(daily_notes)
-    
-    def extract_frontmatter(self, file_path):
-        """Extract frontmatter from a markdown file."""
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-            
-        if content.startswith('---'):
-            try:
-                end_index = content.index('---', 3)
-                frontmatter_text = content[3:end_index].strip()
-                return yaml.safe_load(frontmatter_text), content[end_index+3:]
-            except:
-                return {}, content
-        return {}, content
-    
-    def update_frontmatter(self, file_path, frontmatter, body):
-        """Update the frontmatter of a file."""
-        yaml_content = yaml.dump(frontmatter, default_flow_style=False, allow_unicode=True)
-        new_content = f"---\n{yaml_content}---\n{body}"
-        
-        with open(file_path, 'w', encoding='utf-8') as f:
-            f.write(new_content)
-    
-    def analyze_content(self, content):
-        """Analyze content to identify topics and themes."""
-        content_lower = content.lower()
-        topics = defaultdict(int)
-        
-        for topic, pattern in self.patterns.items():
-            matches = re.findall(pattern, content_lower)
-            topics[topic] = len(matches)
-            
-        # Extract specific mentions
-        mentions = {
-            'projects': re.findall(r'\[\[([^]]+)\]\]', content),
-            'headers': re.findall(r'^#+\s+(.+)$', content, re.MULTILINE),
-            'urls': re.findall(r'https?://[^\s\]]+', content),
-            'tags': re.findall(r'#(\w+)', content)
-        }
-        
-        return topics, mentions
-    
-    def find_related_content(self, topics, mentions, current_file):
-        """Find related content based on topics and mentions."""
-        related = []
-        
-        # Map topics to vault directories
-        topic_dirs = {
-            'project': ['AI IDEAS', 'AI Development'],
-            'meeting': ['CamRohn LLC/Client Work', 'Austin LangChain'],
-            'technical': ['AI Development', 'Model Context Protocol (MCP)'],
-            'client': ['CamRohn LLC', 'Second Opinion DDS'],
-            'research': ['AI Articles and Research', 'Clippings'],
-            'community': ['Austin LangChain', 'AI Conferences and Competitions']
-        }
-        
-        # Find files based on dominant topics
-        for topic, count in sorted(topics.items(), key=lambda x: x[1], reverse=True):
-            if count > 0 and topic in topic_dirs:
-                for dir_name in topic_dirs[topic]:
-                    dir_path = self.vault_path / dir_name
-                    if dir_path.exists():
-                        # Add MOC if exists
-                        moc_path = dir_path / f"MOC - {dir_name.split('/')[-1]}.md"
-                        if moc_path.exists():
-                            related.append((moc_path, f"{topic} reference"))
-                        
-                        # Add specific mentioned files
-                        for mention in mentions['projects']:
-                            if dir_name in mention:
-                                file_path = self.vault_path / f"{mention}.md"
-                                if file_path.exists() and file_path != current_file:
-                                    related.append((file_path, "direct mention"))
-        
-        return related[:10]  # Limit to top 10 connections
-    
-    def find_temporal_connections(self, file_path, all_notes):
-        """Find temporal connections (previous/next days, weekly summaries)."""
-        temporal = []
-        
-        # Extract date from filename
-        date_match = re.match(r'(\d{4})-(\d{2})-(\d{2})', file_path.stem)
-        if not date_match:
-            return temporal
-            
-        current_date = datetime(int(date_match.group(1)), 
-                                int(date_match.group(2)), 
-                                int(date_match.group(3)))
-        
-        # Find previous and next days
-        for days_offset in [-1, 1]:
-            target_date = current_date + timedelta(days=days_offset)
-            target_str = target_date.strftime('%Y-%m-%d')
-            
-            for note in all_notes:
-                if target_str in note.stem:
-                    temporal.append((note, f"{'Previous' if days_offset < 0 else 'Next'} day"))
-                    break
-        
-        # Find weekly connections (same week)
-        week_start = current_date - timedelta(days=current_date.weekday())
-        week_end = week_start + timedelta(days=6)
-        
-        for note in all_notes:
-            date_match = re.match(r'(\d{4})-(\d{2})-(\d{2})', note.stem)
-            if date_match:
-                note_date = datetime(int(date_match.group(1)), 
-                                     int(date_match.group(2)), 
-                                     int(date_match.group(3)))
-                if week_start <= note_date <= week_end and note != file_path:
-                    temporal.append((note, "Same week"))
-        
-        return temporal
-    
-    def process_daily_note(self, file_path, all_notes):
-        """Process a single daily note and add connections."""
-        print(f"Processing: {file_path.relative_to(self.vault_path)}")
-        
-        frontmatter, body = self.extract_frontmatter(file_path)
-        topics, mentions = self.analyze_content(body)
-        
-        # Find related content
-        content_related = self.find_related_content(topics, mentions, file_path)
-        temporal_related = self.find_temporal_connections(file_path, all_notes)
-        
-        # Build related list
-        new_related = []
-        
-        # Add temporal connections first
-        for related_file, relation_type in temporal_related:
-            if "Previous" in relation_type or "Next" in relation_type:
-                relative_path = related_file.relative_to(self.vault_path)
-                link = f"[[{relative_path.with_suffix('').as_posix()}]]"
-                if relation_type == "Previous day":
-                    new_related.insert(0, f"{link} # {relation_type}")
-                else:
-                    new_related.append(f"{link} # {relation_type}")
-        
-        # Add content-based connections
-        for related_file, relation_type in content_related:
-            relative_path = related_file.relative_to(self.vault_path)
-            link = f"[[{relative_path.with_suffix('').as_posix()}]]"
-            comment = f" # {relation_type.title()}"
-            new_related.append(f"{link}{comment}")
-        
-        # Update frontmatter if we found new connections
-        if new_related:
-            existing_related = frontmatter.get('related', [])
-            if isinstance(existing_related, list):
-                # Merge and deduplicate - convert lists to strings for deduplication
-                combined = existing_related + new_related
-                seen = set()
-                all_related = []
-                for item in combined:
-                    if item not in seen:
-                        seen.add(item)
-                        all_related.append(item)
-            else:
-                all_related = new_related
-            
-            frontmatter['related'] = all_related
-            self.update_frontmatter(file_path, frontmatter, body)
-            self.connections_made += len(new_related)
-            
-        self.notes_processed += 1
-        
-        # Track patterns for reporting
-        for topic, count in topics.items():
-            if count > 0:
-                self.connection_map[topic].append(file_path.stem)
-    
-    def generate_report(self):
-        """Generate a report of connections made."""
-        report = f"""# Daily Notes Connectivity Report
-
-Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}
-
-## Summary
-- Total daily notes processed: {self.notes_processed}
-- Total connections created: {self.connections_made}
-- Average connections per note: {self.connections_made / max(self.notes_processed, 1):.1f}
-
-## Connection Patterns Discovered
-
-"""
-        
-        for topic, dates in self.connection_map.items():
-            if dates:
-                report += f"### {topic.title()} Topics\n"
-                report += f"Found in {len(dates)} daily notes:\n"
-                # Show recent examples
-                for date in sorted(dates)[-5:]:
-                    report += f"- [[{date}]]\n"
-                report += "\n"
-        
-        report += """## Themes Across Time Periods
-
-### Recent Trends (Last 30 days)
-"""
-        
-        # Analyze recent trends
-        recent_date = datetime.now() - timedelta(days=30)
-        recent_topics = defaultdict(int)
-        
-        for topic, dates in self.connection_map.items():
-            for date_str in dates:
-                try:
-                    date_match = re.match(r'(\d{4})-(\d{2})-(\d{2})', date_str)
-                    if date_match:
-                        note_date = datetime(int(date_match.group(1)), 
-                                             int(date_match.group(2)), 
-                                             int(date_match.group(3)))
-                        if note_date >= recent_date:
-                            recent_topics[topic] += 1
-                except:
-                    pass
-        
-        for topic, count in sorted(recent_topics.items(), key=lambda x: x[1], reverse=True):
-            report += f"- **{topic.title()}**: {count} occurrences\n"
-        
-        report += "\n## Recommendations\n\n"
-        report += "1. Consider creating weekly/monthly summary notes to consolidate themes\n"
-        report += "2. Review orphaned daily notes that lack connections\n"
-        report += "3. Add more content to empty daily notes for better connectivity\n"
-        
-        return report
-    
-    def run(self):
-        """Main execution method."""
-        print("Daily Notes Connectivity Agent Starting...")
-        print(f"Vault path: {self.vault_path}")
-        
-        # Find all daily notes
-        daily_notes = self.find_daily_notes()
-        print(f"Found {len(daily_notes)} daily notes")
-        
-        # Process each note
-        for note in daily_notes:
-            try:
-                self.process_daily_note(note, daily_notes)
-            except Exception as e:
-                print(f"Error processing {note}: {e}")
-        
-        # Generate and save report
-        report = self.generate_report()
-        report_path = self.vault_path / "System_Files" / "Daily_Notes_Connectivity_Report.md"
-        
-        with open(report_path, 'w', encoding='utf-8') as f:
-            f.write(report)
-        
-        print(f"\nComplete! Report saved to: {report_path}")
-        print(f"Processed {self.notes_processed} notes, created {self.connections_made} connections")
-
-if __name__ == "__main__":
-    vault_path = "/Users/cam/VAULT01"
-    connector = DailyNotesConnector(vault_path)
-    connector.run()

package/cli-tool/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()