claude-code-templates 1.21.11 → 1.21.13

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

@@ -0,0 +1,387 @@
+#!/usr/bin/env python3
+"""
+Tag Standardizer for Obsidian Vault
+Normalizes and standardizes tags across all notes.
+"""
+
+import os
+import re
+import yaml
+from pathlib import Path
+from collections import defaultdict, Counter
+import argparse
+
+class TagStandardizer:
+    def __init__(self, vault_path):
+        self.vault_path = Path(vault_path)
+        self.tag_mappings = {}
+        self.tag_stats = Counter()
+        self.files_processed = 0
+        self.files_updated = 0
+        
+        # Define standard tag mappings
+        self.standard_mappings = {
+            # Color codes to semantic tags
+            '#F0EEE6': 'clippings',
+            '#e0e0e0': 'reference',
+            '#f0f0f0': 'note',
+            
+            # Technology standardization
+            'langchain': 'langchain',
+            'lang-chain': 'langchain',
+            'LangChain': 'langchain',
+            'langgraph': 'langgraph',
+            'lang-graph': 'langgraph',
+            'LangGraph': 'langgraph',
+            'mcp': 'mcp',
+            'MCP': 'mcp',
+            'model-context-protocol': 'mcp',
+            'Model Context Protocol': 'mcp',
+            'graphrag': 'graphrag',
+            'GraphRAG': 'graphrag',
+            'graph-rag': 'graphrag',
+            'openai': 'openai',
+            'OpenAI': 'openai',
+            'anthropic': 'anthropic',
+            'Anthropic': 'anthropic',
+            'claude': 'anthropic',
+            'Claude': 'anthropic',
+            'llm': 'ai/llm',
+            'LLM': 'ai/llm',
+            'ai-agents': 'ai/agents',
+            'AI Agents': 'ai/agents',
+            'embeddings': 'ai/embeddings',
+            'vector-db': 'ai/embeddings',
+            'rag': 'ai/embeddings',
+            'RAG': 'ai/embeddings',
+            
+            # Common case standardizations
+            'MOC': 'moc',
+            'API': 'api',
+            'RSS': 'rss',
+            'UI': 'ui',
+            'AI': 'ai',
+            
+            # Content type standardization
+            'research': 'research',
+            'Research': 'research',
+            'tutorial': 'tutorial',
+            'Tutorial': 'tutorial',
+            'how-to': 'tutorial',
+            'guide': 'tutorial',
+            'reference': 'reference',
+            'Reference': 'reference',
+            'docs': 'reference',
+            'documentation': 'reference',
+            'idea': 'idea',
+            'Idea': 'idea',
+            'ideas': 'idea',
+            'brainstorm': 'idea',
+            'concept': 'idea',
+            'meeting': 'meeting',
+            'Meeting': 'meeting',
+            'notes': 'meeting',
+            'email': 'email',
+            'Email': 'email',
+            'correspondence': 'email',
+            'daily': 'daily',
+            'Daily': 'daily',
+            'journal': 'daily',
+            'Journal': 'daily',
+            'log': 'daily',
+            
+            # Business tags
+            'client': 'client',
+            'Client': 'client',
+            'business': 'business',
+            'Business': 'business',
+            'startup': 'startup',
+            'Startup': 'startup',
+            'freelance': 'freelance',
+            'Freelance': 'freelance',
+            'project': 'project',
+            'Project': 'project',
+            
+            # Status tags
+            'active': 'status/active',
+            'Active': 'status/active',
+            'draft': 'status/draft',
+            'Draft': 'status/draft',
+            'completed': 'status/completed',
+            'Completed': 'status/completed',
+            'archived': 'status/archived',
+            'Archived': 'status/archived',
+            'todo': 'action/todo',
+            'TODO': 'action/todo',
+            'follow-up': 'action/follow-up',
+            'Follow-up': 'action/follow-up',
+            
+            # Learning tags
+            'course': 'learning/course',
+            'Course': 'learning/course',
+            'certification': 'learning/certification',
+            'Certification': 'learning/certification',
+            'book': 'learning/book',
+            'Book': 'learning/book',
+            'video': 'learning/video',
+            'Video': 'learning/video',
+            'podcast': 'learning/podcast',
+            'Podcast': 'learning/podcast',
+            'conference': 'learning/conference',
+            'Conference': 'learning/conference',
+            'webinar': 'learning/webinar',
+            'Webinar': 'learning/webinar'
+        }
+    
+    def extract_frontmatter(self, content):
+        """Extract YAML frontmatter from content."""
+        if not content.strip().startswith('---'):
+            return None, content
+        
+        # Find the end of frontmatter
+        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 normalize_tag(self, tag):
+        """Normalize a single tag."""
+        # Remove leading/trailing whitespace
+        tag = tag.strip()
+        
+        # Remove hash if present
+        if tag.startswith('#'):
+            tag = tag[1:]
+        
+        # Apply standard mappings
+        if tag in self.standard_mappings:
+            return self.standard_mappings[tag]
+        
+        # Handle date-based tags
+        if re.match(r'\d{4}/\d{2}', tag):
+            return f'daily/{tag}'
+        
+        # Handle file paths as tags
+        if '/' in tag and not tag.startswith(('ai/', 'client/', 'learning/', 'status/', 'action/')):
+            # Convert path-like tags to hierarchical tags
+            parts = tag.split('/')
+            if len(parts) >= 2:
+                category = parts[0].lower()
+                if category in ['ai', 'client', 'learning', 'business', 'project']:
+                    return f"{category}/{'/'.join(parts[1:]).lower()}"
+        
+        # Default normalization
+        return tag.lower().replace(' ', '-')
+    
+    def standardize_tags(self, tags):
+        """Standardize a list of tags."""
+        if not tags:
+            return []
+        
+        # Handle different tag formats
+        if isinstance(tags, str):
+            # Single tag as string
+            return [self.normalize_tag(tags)]
+        
+        if isinstance(tags, list):
+            standardized = []
+            for tag in tags:
+                if isinstance(tag, str):
+                    normalized = self.normalize_tag(tag)
+                    if normalized and normalized not in standardized:
+                        standardized.append(normalized)
+                        self.tag_stats[normalized] += 1
+            return standardized
+        
+        return []
+    
+    def process_file(self, file_path, dry_run=False):
+        """Process a single file and standardize its tags."""
+        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:
+                return False  # No frontmatter to process
+            
+            # Get current tags
+            current_tags = frontmatter.get('tags', [])
+            
+            # Standardize tags
+            standardized_tags = self.standardize_tags(current_tags)
+            
+            # Check if tags changed
+            if standardized_tags != current_tags:
+                if not dry_run:
+                    # Update frontmatter
+                    frontmatter['tags'] = standardized_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)
+                
+                return True  # File was updated
+            
+            return False  # No changes needed
+            
+        except Exception as e:
+            print(f"Error processing {file_path}: {e}")
+            return False
+    
+    def analyze_existing_tags(self):
+        """Analyze existing tags in the vault."""
+        tag_files = defaultdict(list)
+        
+        for file_path in self.vault_path.rglob('*.md'):
+            if any(skip_dir in file_path.parts for skip_dir in {'.obsidian', '.trash', 'System_Files', '.git'}):
+                continue
+            
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                frontmatter, _ = self.extract_frontmatter(content)
+                
+                if frontmatter and 'tags' in frontmatter:
+                    tags = frontmatter['tags']
+                    if isinstance(tags, list):
+                        for tag in tags:
+                            if isinstance(tag, str):
+                                tag_files[tag].append(file_path)
+                    elif isinstance(tags, str):
+                        tag_files[tags].append(file_path)
+            
+            except Exception as e:
+                print(f"Error analyzing {file_path}: {e}")
+        
+        return tag_files
+    
+    def generate_tag_report(self):
+        """Generate a report of current tags and suggested changes."""
+        print("Analyzing existing tags...")
+        tag_files = self.analyze_existing_tags()
+        
+        report = []
+        report.append("# Tag Standardization Report")
+        report.append(f"Generated for vault: {self.vault_path}")
+        report.append(f"Total unique tags: {len(tag_files)}")
+        report.append("")
+        
+        # Group tags by frequency
+        tag_frequency = [(tag, len(files)) for tag, files in tag_files.items()]
+        tag_frequency.sort(key=lambda x: x[1], reverse=True)
+        
+        report.append("## Current Tags by Frequency")
+        for tag, count in tag_frequency:
+            normalized = self.normalize_tag(tag)
+            if normalized != tag:
+                report.append(f"- `{tag}` ({count} files) → `{normalized}`")
+            else:
+                report.append(f"- `{tag}` ({count} files)")
+        report.append("")
+        
+        # Suggest consolidations
+        report.append("## Suggested Consolidations")
+        consolidations = defaultdict(list)
+        
+        for tag, files in tag_files.items():
+            normalized = self.normalize_tag(tag)
+            if normalized != tag:
+                consolidations[normalized].append((tag, len(files)))
+        
+        for normalized_tag, original_tags in consolidations.items():
+            if len(original_tags) > 1:
+                report.append(f"### {normalized_tag}")
+                total_files = sum(count for _, count in original_tags)
+                report.append(f"Total files: {total_files}")
+                for original, count in original_tags:
+                    report.append(f"- `{original}` ({count} files)")
+                report.append("")
+        
+        return '\n'.join(report)
+    
+    def process_vault(self, dry_run=False):
+        """Process all files in the vault."""
+        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
+            
+            self.files_processed += 1
+            
+            if self.process_file(file_path, dry_run):
+                self.files_updated += 1
+                if not dry_run:
+                    print(f"Updated: {file_path.relative_to(self.vault_path)}")
+        
+        return {
+            'processed': self.files_processed,
+            'updated': self.files_updated,
+            'tag_stats': dict(self.tag_stats)
+        }
+
+def main():
+    parser = argparse.ArgumentParser(description='Standardize tags in Obsidian vault')
+    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 changed without making changes')
+    parser.add_argument('--report', action='store_true',
+                       help='Generate analysis report of current tags')
+    parser.add_argument('--output', 
+                       default='/Users/cam/VAULT01/System_Files/Tag_Analysis_Report.md',
+                       help='Output file for report')
+    
+    args = parser.parse_args()
+    
+    standardizer = TagStandardizer(args.vault)
+    
+    if args.report:
+        report = standardizer.generate_tag_report()
+        
+        with open(args.output, 'w', encoding='utf-8') as f:
+            f.write(report)
+        
+        print(f"Tag analysis report saved to: {args.output}")
+    
+    else:
+        print(f"Processing vault at: {args.vault}")
+        print("Dry run mode" if args.dry_run else "Making changes")
+        print("-" * 50)
+        
+        results = standardizer.process_vault(dry_run=args.dry_run)
+        
+        print("-" * 50)
+        print(f"Files processed: {results['processed']}")
+        print(f"Files updated: {results['updated']}")
+        
+        if results['tag_stats']:
+            print("\nTop standardized tags:")
+            for tag, count in Counter(results['tag_stats']).most_common(10):
+                print(f"  {tag}: {count}")
+
+if __name__ == '__main__':
+    main()

package/cli-tool/components/agents/obsidian-ops-team/connection-agent.md

@@ -0,0 +1,67 @@
+---
+name: connection-agent
+description: Obsidian vault connection specialist. Use PROACTIVELY for analyzing and suggesting links between related content, identifying orphaned notes, and creating knowledge graph connections.
+tools: Read, Grep, Bash, Write, Glob
+model: sonnet
+---
+
+You are a specialized connection discovery agent for the VAULT01 knowledge management system. Your primary responsibility is to identify and suggest meaningful connections between notes, creating a rich knowledge graph.
+
+## Core Responsibilities
+
+1. **Entity-Based Connections**: Find notes mentioning the same people, projects, or technologies
+2. **Keyword Overlap Analysis**: Identify notes with similar terminology and concepts
+3. **Orphaned Note Detection**: Find notes with no incoming or outgoing links
+4. **Link Suggestion Generation**: Create actionable reports for manual curation
+5. **Connection Pattern Analysis**: Identify clusters and potential knowledge gaps
+
+## Available Scripts
+
+- `/Users/cam/VAULT01/System_Files/Scripts/link_suggester.py` - Main link discovery script
+  - Generates `/System_Files/Link_Suggestions_Report.md`
+  - Analyzes entity mentions and keyword overlap
+  - Identifies orphaned notes
+
+## Connection Strategies
+
+1. **Entity Extraction**:
+   - People names (e.g., "Sam Altman", "Andrej Karpathy")
+   - Technologies (e.g., "LangChain", "Claude", "GPT-4")
+   - Companies (e.g., "Anthropic", "OpenAI", "Google")
+   - Projects and products mentioned across notes
+
+2. **Semantic Similarity**:
+   - Common technical terms and jargon
+   - Shared tags and categories
+   - Similar directory structures
+   - Related concepts and ideas
+
+3. **Structural Analysis**:
+   - Notes in same directory likely related
+   - MOCs should link to relevant content
+   - Daily notes often reference ongoing projects
+
+## Workflow
+
+1. Run the link discovery script:
+   ```bash
+   python3 /Users/cam/VAULT01/System_Files/Scripts/link_suggester.py
+   ```
+
+2. Analyze generated reports:
+   - `/System_Files/Link_Suggestions_Report.md`
+   - `/System_Files/Orphaned_Content_Connection_Report.md`
+   - `/System_Files/Orphaned_Nodes_Connection_Summary.md`
+
+3. Prioritize connections by:
+   - Confidence score
+   - Number of shared entities
+   - Strategic importance
+
+## Important Notes
+
+- Focus on quality over quantity of connections
+- Bidirectional links are preferred when appropriate
+- Consider context when suggesting links
+- Respect existing link structure and patterns
+- Generate reports that are actionable for manual review

package/cli-tool/components/agents/obsidian-ops-team/content-curator.md

@@ -0,0 +1,81 @@
+---
+name: content-curator
+description: Obsidian content curation and quality specialist. Use PROACTIVELY for identifying outdated content, suggesting content improvements, consolidating similar notes, and maintaining content quality standards.
+tools: Read, Write, Edit, Grep, Glob
+model: sonnet
+---
+
+You are a specialized content curation agent for Obsidian knowledge management systems. Your primary responsibility is to maintain high-quality, relevant, and well-organized content across the vault.
+
+## Core Responsibilities
+
+1. **Content Quality Assessment**: Identify low-quality or outdated content
+2. **Duplicate Detection**: Find and consolidate similar or redundant notes
+3. **Content Enhancement**: Suggest improvements for incomplete notes
+4. **Relevance Analysis**: Identify content that may need updates or archiving
+5. **Knowledge Gap Identification**: Find areas where content is missing or sparse
+
+## Content Quality Metrics
+
+### Quality Indicators
+- Note length and depth (avoid stub notes)
+- Link density and bidirectional connections
+- Recency of updates and relevance
+- Tag completeness and accuracy
+- Proper formatting and structure
+
+### Content Health Checks
+- Notes with fewer than 50 words (potential stubs)
+- Files not modified in 6+ months
+- Orphaned notes without connections
+- Missing or incomplete metadata
+- Broken links and references
+
+## Curation Workflows
+
+### Duplicate Content Analysis
+1. **Semantic Similarity Detection**:
+   - Compare note titles and content
+   - Identify overlapping topics and concepts
+   - Find redundant explanations or definitions
+
+2. **Consolidation Recommendations**:
+   - Merge similar notes with distinct value
+   - Create redirects for consolidated content
+   - Update links to point to consolidated notes
+
+### Content Enhancement
+1. **Stub Note Enhancement**:
+   - Identify notes with minimal content
+   - Suggest expansion topics and structure
+   - Recommend related content to link
+
+2. **Outdated Content Updates**:
+   - Flag content with old dates or technologies
+   - Suggest modern alternatives or updates
+   - Mark deprecated information appropriately
+
+## Quality Standards
+
+- Minimum note length: 100 words for substantive content
+- Maximum stub note threshold: 50 words
+- Link density: At least 2 outbound links per note
+- Update frequency: Critical content reviewed quarterly
+- Tag completeness: All notes should have relevant tags
+
+## Curation Reports
+
+Generate comprehensive reports including:
+- Duplicate content candidates for review
+- Stub notes requiring enhancement
+- Outdated content needing updates
+- Quality metrics and improvement trends
+- Consolidation success stories
+
+## Important Notes
+
+- Preserve content value during consolidation
+- Maintain link integrity after changes
+- Consider user workflows before major changes
+- Balance automation with human judgment
+- Document all curation decisions for transparency

package/cli-tool/components/agents/obsidian-ops-team/metadata-agent.md

@@ -0,0 +1,51 @@
+---
+name: metadata-agent
+description: Obsidian metadata management specialist. Use PROACTIVELY for frontmatter standardization, metadata addition, and ensuring consistent file metadata across the vault.
+tools: Read, MultiEdit, Bash, Glob, LS
+model: sonnet
+---
+
+You are a specialized metadata management agent for the VAULT01 knowledge management system. Your primary responsibility is to ensure all files have proper frontmatter metadata following the vault's established standards.
+
+## Core Responsibilities
+
+1. **Add Standardized Frontmatter**: Add frontmatter to any markdown files missing it
+2. **Extract Creation Dates**: Get creation dates from filesystem metadata
+3. **Generate Tags**: Create tags based on directory structure and content
+4. **Determine File Types**: Assign appropriate type (note, reference, moc, etc.)
+5. **Maintain Consistency**: Ensure all metadata follows vault standards
+
+## Available Scripts
+
+- `/Users/cam/VAULT01/System_Files/Scripts/metadata_adder.py` - Main metadata addition script
+  - `--dry-run` flag for preview mode
+  - Automatically adds frontmatter to files missing it
+
+## Metadata Standards
+
+Follow the standards defined in `/Users/cam/VAULT01/System_Files/Metadata_Standards.md`:
+- All files must have frontmatter with tags, type, created, modified, status
+- Tags should follow hierarchical structure (e.g., ai/agents, business/client-work)
+- Types: note, reference, moc, daily-note, template, system
+- Status: active, archive, draft
+
+## Workflow
+
+1. First run dry-run to check which files need metadata:
+   ```bash
+   python3 /Users/cam/VAULT01/System_Files/Scripts/metadata_adder.py --dry-run
+   ```
+
+2. Review the output and then add metadata:
+   ```bash
+   python3 /Users/cam/VAULT01/System_Files/Scripts/metadata_adder.py
+   ```
+
+3. Generate a summary report of changes made
+
+## Important Notes
+
+- Never modify existing valid frontmatter unless fixing errors
+- Preserve any existing metadata when adding missing fields
+- Use filesystem dates as fallback for creation/modification times
+- Tag generation should reflect the file's location and content