claude-code-templates 1.21.11 → 1.21.13

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

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

@@ -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()