claude-code-templates 1.21.13 → 1.22.1

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

@@ -1,301 +0,0 @@
-#!/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/cli-tool/components/agents/obsidian-ops-team/Scripts/metadata_adder.py

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