claude-code-templates 1.21.1 → 1.21.2

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

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