claude-code-templates 1.21.5 → 1.21.6

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

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Implement entity-based connections from Link Suggestions Report."""
+
+import re
+import os
+from pathlib import Path
+
+# Priority entities to focus on
+PRIORITY_ENTITIES = {
+    'langchain', 'langgraph', 'llm', 'rag', 'embedding', 'vector', 
+    'mcp', 'model context protocol', 'api integration', 'function calling',
+    'anthropic', 'openai', 'google', 'claude', 'gpt',
+    'autonomous agent', 'ai agent', 'chain of thought', 'prompt engineering',
+    'retrieval augmented', 'graphrag', 'multimodal', 'tool use'
+}
+
+def read_file(file_path):
+    """Read file content."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except:
+        return None
+
+def write_file(file_path, content):
+    """Write content to file."""
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return True
+    except:
+        return False
+
+def find_file(filename, search_dirs):
+    """Find a file in the vault."""
+    for dir_path in search_dirs:
+        for root, dirs, files in os.walk(dir_path):
+            for file in files:
+                if file == filename or file == filename + '.md':
+                    return os.path.join(root, file)
+    return None
+
+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."""
+    content = read_file(file_path)
+    if not content:
+        return False
+    
+    # Check if link already exists
+    if f'[[{link_to_add}]]' in content:
+        return False
+    
+    # Find a good place to add the link
+    # Look for existing "Related:" or "See also:" sections
+    related_patterns = [
+        r'^#+\s*Related.*?$',
+        r'^#+\s*See also.*?$',
+        r'^#+\s*Links.*?$',
+        r'^#+\s*References.*?$'
+    ]
+    
+    insert_pos = None
+    for pattern in related_patterns:
+        match = re.search(pattern, content, re.MULTILINE | re.IGNORECASE)
+        if match:
+            # Find the end of this section
+            insert_pos = match.end()
+            # Skip to next line
+            next_line = content.find('\n', insert_pos)
+            if next_line != -1:
+                insert_pos = next_line + 1
+            break
+    
+    # If no related section found, add at the end of frontmatter
+    if insert_pos is None:
+        # Find end of frontmatter
+        frontmatter_end = content.find('---', 3)
+        if frontmatter_end != -1:
+            insert_pos = content.find('\n', frontmatter_end + 3) + 1
+        else:
+            # No frontmatter, add at beginning
+            insert_pos = 0
+    
+    # Create the link line
+    if link_text:
+        link_line = f"- [[{link_to_add}]] - {link_text}\n"
+    else:
+        link_line = f"- [[{link_to_add}]]\n"
+    
+    # If we're not in a list section, create one
+    if insert_pos is None or (insert_pos > 0 and content[insert_pos-2:insert_pos] != '\n\n'):
+        # Check if we need to add a Related section
+        needs_section = True
+        for pattern in related_patterns:
+            if re.search(pattern, content, re.MULTILINE | re.IGNORECASE):
+                needs_section = False
+                break
+        
+        if needs_section:
+            # Add at end of file with new Related section
+            if not content.endswith('\n'):
+                content += '\n'
+            content += '\n## Related\n'
+            content += link_line
+        else:
+            # Insert in existing section
+            new_content = content[:insert_pos] + link_line + content[insert_pos:]
+            content = new_content
+    else:
+        # Insert at found position
+        new_content = content[:insert_pos] + link_line + content[insert_pos:]
+        content = new_content
+    
+    return write_file(file_path, content)
+
+def implement_connections():
+    """Implement priority entity connections."""
+    vault_root = Path("/Users/cam/VAULT01")
+    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"
+    ]
+    
+    # Read the report
+    report_path = vault_root / "System_Files" / "Link_Suggestions_Report.md"
+    report_content = read_file(report_path)
+    
+    if not report_content:
+        print("Could not read report")
+        return
+    
+    # Parse entity connections
+    connections_made = 0
+    connections_by_entity = {}
+    
+    # Find entity sections
+    entity_pattern = r'^### (.+)$'
+    connection_pattern = r'- \[\[([^\]]+)\]\] ↔ \[\[([^\]]+)\]\]'
+    
+    current_entity = None
+    for line in report_content.split('\n'):
+        # Check for entity header
+        entity_match = re.match(entity_pattern, line)
+        if entity_match:
+            current_entity = entity_match.group(1).strip().lower()
+            continue
+        
+        # Check for connection
+        if current_entity and current_entity in [e.lower() for e in PRIORITY_ENTITIES]:
+            conn_match = re.match(connection_pattern, line)
+            if conn_match:
+                file1 = conn_match.group(1).strip()
+                file2 = conn_match.group(2).strip()
+                
+                # Skip self-connections
+                if file1 == file2:
+                    continue
+                
+                # Find actual file paths
+                file1_path = find_file(file1 + '.md', search_dirs)
+                file2_path = find_file(file2 + '.md', search_dirs)
+                
+                if file1_path and file2_path:
+                    # Add bidirectional links
+                    if add_link_to_file(file1_path, file2, f"Related to {current_entity}"):
+                        connections_made += 1
+                        if current_entity not in connections_by_entity:
+                            connections_by_entity[current_entity] = 0
+                        connections_by_entity[current_entity] += 1
+                        print(f"Added link from {file1} to {file2}")
+                    
+                    if add_link_to_file(file2_path, file1, f"Related to {current_entity}"):
+                        connections_made += 1
+                        if current_entity not in connections_by_entity:
+                            connections_by_entity[current_entity] = 0
+                        connections_by_entity[current_entity] += 1
+                        print(f"Added link from {file2} to {file1}")
+    
+    # Generate report
+    print("\n=== Connection Implementation Report ===")
+    print(f"Total connections made: {connections_made}")
+    print("\nConnections by entity:")
+    for entity, count in sorted(connections_by_entity.items(), key=lambda x: x[1], reverse=True):
+        print(f"  {entity}: {count} connections")
+    
+    # Find cross-domain connections
+    print("\nCross-domain connections created:")
+    # This would require more complex analysis of file paths
+
+if __name__ == "__main__":
+    implement_connections()

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

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""
+Link Suggester for Obsidian Vault
+Identifies potential connections between notes based on content analysis.
+"""
+
+import os
+import re
+from pathlib import Path
+from collections import defaultdict, Counter
+import argparse
+import json
+
+class LinkSuggester:
+    def __init__(self, vault_path):
+        self.vault_path = Path(vault_path)
+        self.notes = {}
+        self.entity_mentions = defaultdict(set)
+        self.potential_links = []
+        
+        # Common entities to look for
+        self.entities = {
+            'technologies': [
+                'langchain', 'langgraph', 'mcp', 'model context protocol',
+                'graphrag', 'openai', 'anthropic', 'claude', 'gpt', 'llm',
+                'ollama', 'huggingface', 'github', 'python', 'javascript',
+                'cloudflare', 'supabase', 'vector database', 'embedding',
+                'ai agent', 'autonomous agent', 'rag', 'retrieval augmented'
+            ],
+            'concepts': [
+                'machine learning', 'deep learning', 'neural network',
+                'transformer', 'attention mechanism', 'fine-tuning',
+                'prompt engineering', 'chain of thought', 'reasoning',
+                'multimodal', 'text generation', 'code generation',
+                'tool use', 'function calling', 'api integration'
+            ],
+            'companies': [
+                'google', 'microsoft', 'amazon', 'meta', 'apple',
+                'nvidia', 'intel', 'amd', 'tesla', 'stripe',
+                'y combinator', 'techstars', 'propel', 'dental'
+            ],
+            'people': [
+                'andrew ng', 'geoffrey hinton', 'yann lecun', 'ilya sutskever',
+                'sam altman', 'dario amodei', 'demis hassabis', 'jensen huang'
+            ]
+        }
+        
+        # Flatten entities for easier searching
+        self.all_entities = []
+        for category, entities in self.entities.items():
+            self.all_entities.extend(entities)
+    
+    def load_notes(self):
+        """Load all markdown files and their content."""
+        skip_dirs = {'.obsidian', '.trash', 'System_Files', '.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
+            
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                # Extract title
+                title_match = re.search(r'^#\s+(.+)$', content, re.MULTILINE)
+                title = title_match.group(1) if title_match else file_path.stem
+                
+                # Extract existing links
+                existing_links = set(re.findall(r'\[\[([^\]]+)\]\]', content))
+                
+                self.notes[file_path] = {
+                    'title': title,
+                    'content': content.lower(),
+                    'existing_links': existing_links,
+                    'word_count': len(content.split())
+                }
+                
+            except Exception as e:
+                print(f"Error reading {file_path}: {e}")
+    
+    def find_entity_mentions(self):
+        """Find mentions of entities across all notes."""
+        for file_path, note_data in self.notes.items():
+            content = note_data['content']
+            
+            for entity in self.all_entities:
+                if entity in content:
+                    self.entity_mentions[entity].add(file_path)
+    
+    def suggest_links_by_entities(self):
+        """Suggest links based on common entity mentions."""
+        suggestions = []
+        
+        for entity, files in self.entity_mentions.items():
+            if len(files) >= 2:  # Entity mentioned in at least 2 files
+                file_list = list(files)
+                
+                for i, file1 in enumerate(file_list):
+                    for file2 in file_list[i+1:]:
+                        # Check if files don't already link to each other
+                        note1 = self.notes[file1]
+                        note2 = self.notes[file2]
+                        
+                        if (note2['title'] not in note1['existing_links'] and
+                            note1['title'] not in note2['existing_links']):
+                            
+                            suggestions.append({
+                                'file1': file1,
+                                'file2': file2,
+                                'title1': note1['title'],
+                                'title2': note2['title'],
+                                'common_entity': entity,
+                                'type': 'entity_mention',
+                                'confidence': len(files) / 10  # Simple confidence score
+                            })
+        
+        return suggestions
+    
+    def suggest_links_by_keywords(self):
+        """Suggest links based on keyword overlap."""
+        suggestions = []
+        
+        # Extract keywords from titles and content
+        for file_path, note_data in self.notes.items():
+            if note_data['word_count'] < 100:  # Skip very short notes
+                continue
+            
+            # Get keywords from title
+            title_words = set(re.findall(r'\b\w{4,}\b', note_data['title'].lower()))
+            
+            # Find other notes with similar keywords
+            for other_path, other_data in self.notes.items():
+                if file_path == other_path:
+                    continue
+                
+                other_title_words = set(re.findall(r'\b\w{4,}\b', other_data['title'].lower()))
+                
+                # Check for keyword overlap
+                common_words = title_words.intersection(other_title_words)
+                if len(common_words) >= 2:  # At least 2 common significant words
+                    
+                    # Check if files don't already link to each other
+                    if (other_data['title'] not in note_data['existing_links'] and
+                        note_data['title'] not in other_data['existing_links']):
+                        
+                        suggestions.append({
+                            'file1': file_path,
+                            'file2': other_path,
+                            'title1': note_data['title'],
+                            'title2': other_data['title'],
+                            'common_words': list(common_words),
+                            'type': 'keyword_overlap',
+                            'confidence': len(common_words) / 5
+                        })
+        
+        return suggestions
+    
+    def find_orphaned_notes(self):
+        """Find notes with no incoming or outgoing links."""
+        orphaned = []
+        
+        for file_path, note_data in self.notes.items():
+            if len(note_data['existing_links']) == 0:
+                # Check if any other notes link to this one
+                mentioned_in = []
+                for other_path, other_data in self.notes.items():
+                    if note_data['title'] in other_data['existing_links']:
+                        mentioned_in.append(other_path)
+                
+                if not mentioned_in:
+                    orphaned.append({
+                        'file': file_path,
+                        'title': note_data['title'],
+                        'word_count': note_data['word_count']
+                    })
+        
+        return orphaned
+    
+    def analyze_vault(self):
+        """Perform complete analysis of the vault."""
+        print("Loading notes...")
+        self.load_notes()
+        print(f"Loaded {len(self.notes)} notes")
+        
+        print("Finding entity mentions...")
+        self.find_entity_mentions()
+        
+        print("Generating link suggestions...")
+        entity_suggestions = self.suggest_links_by_entities()
+        keyword_suggestions = self.suggest_links_by_keywords()
+        orphaned_notes = self.find_orphaned_notes()
+        
+        return {
+            'entity_suggestions': entity_suggestions,
+            'keyword_suggestions': keyword_suggestions,
+            'orphaned_notes': orphaned_notes,
+            'stats': {
+                'total_notes': len(self.notes),
+                'entity_suggestions': len(entity_suggestions),
+                'keyword_suggestions': len(keyword_suggestions),
+                'orphaned_notes': len(orphaned_notes)
+            }
+        }
+    
+    def generate_report(self, results, output_file=None):
+        """Generate a human-readable report."""
+        report = []
+        
+        report.append("# Link Suggestions Report")
+        report.append(f"Generated for vault: {self.vault_path}")
+        report.append(f"Total notes analyzed: {results['stats']['total_notes']}")
+        report.append("")
+        
+        # Entity-based suggestions
+        report.append("## Entity-Based Link Suggestions")
+        report.append(f"Found {len(results['entity_suggestions'])} potential connections")
+        report.append("")
+        
+        # Group by entity
+        entity_groups = defaultdict(list)
+        for suggestion in results['entity_suggestions']:
+            entity_groups[suggestion['common_entity']].append(suggestion)
+        
+        for entity, suggestions in sorted(entity_groups.items()):
+            report.append(f"### {entity.title()}")
+            for suggestion in suggestions[:5]:  # Top 5 per entity
+                report.append(f"- [[{suggestion['title1']}]] ↔ [[{suggestion['title2']}]]")
+            report.append("")
+        
+        # Keyword-based suggestions
+        report.append("## Keyword-Based Link Suggestions")
+        report.append(f"Found {len(results['keyword_suggestions'])} potential connections")
+        report.append("")
+        
+        # Sort by confidence
+        sorted_keywords = sorted(results['keyword_suggestions'], 
+                               key=lambda x: x['confidence'], reverse=True)
+        
+        for suggestion in sorted_keywords[:20]:  # Top 20
+            common_words = ', '.join(suggestion['common_words'])
+            report.append(f"- [[{suggestion['title1']}]] ↔ [[{suggestion['title2']}]]")
+            report.append(f"  Common words: {common_words}")
+            report.append("")
+        
+        # Orphaned notes
+        report.append("## Orphaned Notes (No Links)")
+        report.append(f"Found {len(results['orphaned_notes'])} notes with no connections")
+        report.append("")
+        
+        # Sort by word count (longer notes first)
+        sorted_orphaned = sorted(results['orphaned_notes'], 
+                               key=lambda x: x['word_count'], reverse=True)
+        
+        for note in sorted_orphaned[:30]:  # Top 30
+            report.append(f"- [[{note['title']}]] ({note['word_count']} words)")
+        
+        report_text = '\n'.join(report)
+        
+        if output_file:
+            with open(output_file, 'w', encoding='utf-8') as f:
+                f.write(report_text)
+            print(f"Report saved to: {output_file}")
+        
+        return report_text
+
+def main():
+    parser = argparse.ArgumentParser(description='Suggest links for Obsidian vault')
+    parser.add_argument('--vault', default='/Users/cam/VAULT01',
+                       help='Path to Obsidian vault')
+    parser.add_argument('--output', 
+                       default='/Users/cam/VAULT01/System_Files/Link_Suggestions_Report.md',
+                       help='Output file for report')
+    parser.add_argument('--json', 
+                       help='Output JSON file for programmatic use')
+    
+    args = parser.parse_args()
+    
+    suggester = LinkSuggester(args.vault)
+    results = suggester.analyze_vault()
+    
+    # Generate report
+    report = suggester.generate_report(results, args.output)
+    
+    # Save JSON if requested
+    if args.json:
+        with open(args.json, 'w') as f:
+            json.dump(results, f, indent=2, default=str)
+        print(f"JSON data saved to: {args.json}")
+    
+    # Print summary
+    print("\n" + "="*50)
+    print("LINK SUGGESTIONS SUMMARY")
+    print("="*50)
+    print(f"Total notes: {results['stats']['total_notes']}")
+    print(f"Entity-based suggestions: {results['stats']['entity_suggestions']}")
+    print(f"Keyword-based suggestions: {results['stats']['keyword_suggestions']}")
+    print(f"Orphaned notes: {results['stats']['orphaned_notes']}")
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Metadata Adder for Obsidian Vault
+Adds standardized frontmatter to markdown files that lack it.
+"""
+
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+import argparse
+
+class MetadataAdder:
+    def __init__(self, vault_path):
+        self.vault_path = Path(vault_path)
+        self.stats = {
+            'processed': 0,
+            'updated': 0,
+            'skipped': 0,
+            'errors': 0
+        }
+        
+    def get_file_creation_date(self, file_path):
+        """Get file creation date from filesystem."""
+        try:
+            stat = os.stat(file_path)
+            # Use birthtime on macOS, ctime on others
+            timestamp = stat.st_birthtime if hasattr(stat, 'st_birthtime') else stat.st_ctime
+            return datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d')
+        except:
+            return datetime.now().strftime('%Y-%m-%d')
+    
+    def determine_file_type(self, file_path):
+        """Determine the type of note based on path and content."""
+        path_str = str(file_path).lower()
+        
+        if 'moc' in path_str or 'map of content' in path_str:
+            return 'map-of-content'
+        elif 'daily notes' in path_str or 'daily note' in path_str:
+            return 'daily'
+        elif 'research' in path_str or 'articles' in path_str:
+            return 'research'
+        elif 'client' in path_str or 'camrohn llc' in path_str:
+            return 'client-work'
+        elif 'tutorial' in path_str or 'course' in path_str:
+            return 'tutorial'
+        elif 'idea' in path_str:
+            return 'idea'
+        elif 'meeting' in path_str:
+            return 'meeting'
+        elif 'email' in path_str:
+            return 'email'
+        else:
+            return 'note'
+    
+    def generate_tags_from_path(self, file_path):
+        """Generate tags based on file path."""
+        tags = []
+        path_parts = file_path.relative_to(self.vault_path).parts[:-1]  # Exclude filename
+        
+        # Map directory names to tags
+        tag_mapping = {
+            'ai development': 'ai/development',
+            'ai articles': 'ai/research',
+            'ai courses': 'tutorial/course',
+            'ai ideas': 'idea',
+            'camrohn llc': 'client',
+            'daily notes': 'daily',
+            'clippings': 'clippings',
+            'mcp': 'mcp',
+            'langchain': 'langchain',
+            'graphrag': 'graphrag'
+        }
+        
+        for part in path_parts:
+            part_lower = part.lower()
+            for key, tag in tag_mapping.items():
+                if key in part_lower:
+                    tags.append(tag)
+                    break
+        
+        # Add date tags for daily notes
+        if 'daily' in tags:
+            created_date = self.get_file_creation_date(file_path)
+            year_month = datetime.strptime(created_date, '%Y-%m-%d').strftime('%Y/%m')
+            tags.append(f'daily/{year_month}')
+        
+        return list(set(tags))  # Remove duplicates
+    
+    def has_frontmatter(self, content):
+        """Check if content already has frontmatter."""
+        return content.strip().startswith('---')
+    
+    def create_frontmatter(self, file_path, existing_content):
+        """Create appropriate frontmatter for the file."""
+        created_date = self.get_file_creation_date(file_path)
+        file_type = self.determine_file_type(file_path)
+        tags = self.generate_tags_from_path(file_path)
+        
+        # Extract title from first heading or filename
+        title_match = re.search(r'^#\s+(.+)$', existing_content, re.MULTILINE)
+        if title_match:
+            title = title_match.group(1)
+        else:
+            title = file_path.stem.replace('_', ' ').replace('-', ' ')
+        
+        frontmatter = f"""---
+tags: {tags}
+type: {file_type}
+created: {created_date}
+modified: {datetime.now().strftime('%Y-%m-%d')}
+status: active
+related: []
+aliases: []
+---
+
+"""
+        
+        return frontmatter
+    
+    def process_file(self, file_path):
+        """Process a single markdown file."""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            if self.has_frontmatter(content):
+                self.stats['skipped'] += 1
+                return False
+            
+            # Create and prepend frontmatter
+            frontmatter = self.create_frontmatter(file_path, content)
+            new_content = frontmatter + content
+            
+            # Write back to file
+            with open(file_path, 'w', encoding='utf-8') as f:
+                f.write(new_content)
+            
+            self.stats['updated'] += 1
+            return True
+            
+        except Exception as e:
+            print(f"Error processing {file_path}: {e}")
+            self.stats['errors'] += 1
+            return False
+    
+    def process_vault(self, dry_run=False):
+        """Process all markdown files in the vault."""
+        # Directories to skip
+        skip_dirs = {'.obsidian', '.trash', 'System_Files', '.git'}
+        
+        for file_path in self.vault_path.rglob('*.md'):
+            # Skip files in excluded directories
+            if any(skip_dir in file_path.parts for skip_dir in skip_dirs):
+                continue
+            
+            self.stats['processed'] += 1
+            
+            if dry_run:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                if not self.has_frontmatter(content):
+                    print(f"Would update: {file_path.relative_to(self.vault_path)}")
+                    self.stats['updated'] += 1
+                else:
+                    self.stats['skipped'] += 1
+            else:
+                if self.process_file(file_path):
+                    print(f"Updated: {file_path.relative_to(self.vault_path)}")
+        
+        return self.stats
+
+def main():
+    parser = argparse.ArgumentParser(description='Add metadata to Obsidian vault files')
+    parser.add_argument('--vault', default='/Users/cam/VAULT01', 
+                       help='Path to Obsidian vault')
+    parser.add_argument('--dry-run', action='store_true',
+                       help='Show what would be updated without making changes')
+    
+    args = parser.parse_args()
+    
+    adder = MetadataAdder(args.vault)
+    print(f"Processing vault at: {args.vault}")
+    print("Dry run mode" if args.dry_run else "Making changes")
+    print("-" * 50)
+    
+    stats = adder.process_vault(dry_run=args.dry_run)
+    
+    print("-" * 50)
+    print(f"Files processed: {stats['processed']}")
+    print(f"Files updated: {stats['updated']}")
+    print(f"Files skipped (already have metadata): {stats['skipped']}")
+    print(f"Errors: {stats['errors']}")
+
+if __name__ == '__main__':
+    main()