claude-code-templates 1.21.13 → 1.22.0

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

@@ -1,216 +0,0 @@
-#!/usr/bin/env python3
-"""Find and implement keyword-based connections between files."""
-
-import os
-import re
-from collections import Counter, defaultdict
-from pathlib import Path
-
-# Priority keywords to focus on
-PRIORITY_KEYWORDS = {
-    'llm', 'langchain', 'langgraph', 'rag', 'embedding', 'vector',
-    'agent', 'automation', 'workflow', 'pipeline', 'mcp', 'api',
-    'anthropic', 'openai', 'google', 'claude', 'gpt', 'model',
-    'context', 'protocol', 'fastapi', 'docker', 'cloudflare', 
-    'supabase', 'integration', 'framework', 'retrieval', 'augmented',
-    'generation', 'prompt', 'engineering', 'multimodal', 'function',
-    'calling', 'tool', 'use', 'chain', 'thought', 'reasoning'
-}
-
-def extract_keywords_from_file(file_path):
-    """Extract meaningful keywords from a file."""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read().lower()
-        
-        # Extract words (alphanumeric plus hyphens)
-        words = re.findall(r'\b[a-z0-9-]+\b', content)
-        
-        # Filter for priority keywords and count occurrences
-        keyword_counts = Counter()
-        for word in words:
-            if word in PRIORITY_KEYWORDS:
-                keyword_counts[word] += 1
-        
-        return keyword_counts
-    except:
-        return Counter()
-
-def find_keyword_connections(vault_root):
-    """Find files that share multiple priority keywords."""
-    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"
-    ]
-    
-    # Collect keyword data for all files
-    file_keywords = {}
-    print("Analyzing files for keywords...")
-    
-    for search_dir in search_dirs:
-        if not search_dir.exists():
-            continue
-            
-        for root, dirs, files in os.walk(search_dir):
-            for file in files:
-                if file.endswith('.md'):
-                    file_path = Path(root) / file
-                    keywords = extract_keywords_from_file(file_path)
-                    if keywords:
-                        file_keywords[file_path] = keywords
-    
-    print(f"Analyzed {len(file_keywords)} files")
-    
-    # Find connections between files
-    connections = []
-    processed_pairs = set()
-    
-    files = list(file_keywords.keys())
-    for i, file1 in enumerate(files):
-        if i % 100 == 0:
-            print(f"Processing file {i+1}/{len(files)}...")
-            
-        for j, file2 in enumerate(files[i+1:], start=i+1):
-            # Skip if already processed
-            pair = tuple(sorted([str(file1), str(file2)]))
-            if pair in processed_pairs:
-                continue
-            processed_pairs.add(pair)
-            
-            # Find common keywords
-            common_keywords = set(file_keywords[file1].keys()) & set(file_keywords[file2].keys())
-            
-            if len(common_keywords) >= 5:  # At least 5 common keywords
-                # Calculate relevance score
-                score = sum(
-                    min(file_keywords[file1][kw], file_keywords[file2][kw])
-                    for kw in common_keywords
-                )
-                
-                connections.append({
-                    'file1': file1,
-                    'file2': file2,
-                    'keywords': list(common_keywords),
-                    'score': score
-                })
-    
-    # Sort by score
-    connections.sort(key=lambda x: x['score'], reverse=True)
-    
-    return connections
-
-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."""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-        
-        # Extract just the filename for the link
-        link_filename = Path(link_to_add).stem
-        
-        # Check if link already exists
-        if f'[[{link_filename}]]' in content:
-            return False
-        
-        # Find or create Related section
-        related_match = re.search(r'^## Related\s*$', content, re.MULTILINE)
-        
-        if related_match:
-            # Insert after the Related header
-            insert_pos = related_match.end()
-            # Skip to next line
-            next_line = content.find('\n', insert_pos)
-            if next_line != -1:
-                insert_pos = next_line + 1
-        else:
-            # Add Related section at end
-            if not content.endswith('\n'):
-                content += '\n'
-            content += '\n## Related\n'
-            insert_pos = len(content)
-        
-        # Create the link line
-        if link_text:
-            link_line = f"- [[{link_filename}]] - {link_text}\n"
-        else:
-            link_line = f"- [[{link_filename}]]\n"
-        
-        # Insert the link
-        new_content = content[:insert_pos] + link_line + content[insert_pos:]
-        
-        with open(file_path, 'w', encoding='utf-8') as f:
-            f.write(new_content)
-        
-        return True
-    except Exception as e:
-        print(f"Error updating {file_path}: {e}")
-        return False
-
-def implement_keyword_connections(connections, limit=50):
-    """Implement the top keyword-based connections."""
-    connections_made = 0
-    keyword_clusters = defaultdict(list)
-    
-    for conn in connections[:limit]:
-        file1 = conn['file1']
-        file2 = conn['file2']
-        keywords = conn['keywords']
-        
-        # Create descriptive text
-        keyword_text = f"Shares keywords: {', '.join(sorted(keywords)[:5])}"
-        
-        # Add bidirectional links
-        if add_link_to_file(file1, file2, keyword_text):
-            connections_made += 1
-            print(f"Connected {file1.name} ↔ {file2.name}")
-            
-            # Track keyword clusters
-            for kw in keywords:
-                keyword_clusters[kw].append((file1.name, file2.name))
-        
-        if add_link_to_file(file2, file1, keyword_text):
-            connections_made += 1
-    
-    return connections_made, keyword_clusters
-
-def main():
-    vault_root = Path("/Users/cam/VAULT01")
-    
-    print("Finding keyword-based connections...")
-    connections = find_keyword_connections(vault_root)
-    
-    print(f"\nFound {len(connections)} potential keyword connections")
-    
-    # Show top connections
-    print("\nTop 10 keyword connections by relevance:")
-    for i, conn in enumerate(connections[:10]):
-        print(f"{i+1}. {conn['file1'].name} ↔ {conn['file2'].name}")
-        print(f"   Keywords ({len(conn['keywords'])}): {', '.join(sorted(conn['keywords'])[:8])}")
-        print(f"   Score: {conn['score']}")
-    
-    # Implement connections
-    print("\nImplementing connections...")
-    connections_made, keyword_clusters = implement_keyword_connections(connections)
-    
-    print(f"\n=== Keyword Connection Report ===")
-    print(f"Total connections made: {connections_made}")
-    
-    print("\nMost connected keywords:")
-    sorted_keywords = sorted(keyword_clusters.items(), key=lambda x: len(x[1]), reverse=True)[:10]
-    for keyword, connections in sorted_keywords:
-        print(f"  {keyword}: {len(connections)} connections")
-    
-    # Find cross-domain connections
-    print("\nCross-domain connections:")
-    cross_domain = 0
-    for i, (keyword, conn_list) in enumerate(sorted_keywords[:5]):
-        print(f"\n{keyword}-related cross-domain connections:")
-        for file1_name, file2_name in conn_list[:3]:  # Show first 3 for each keyword
-            print(f"  - {file1_name} ↔ {file2_name}")
-
-if __name__ == "__main__":
-    main()

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

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-"""
-Fix quoted tags in frontmatter by converting single-quoted tags to unquoted format.
-"""
-
-import os
-import re
-import yaml
-from pathlib import Path
-
-def fix_quoted_tags(vault_path):
-    """Fix single-quoted tags in all markdown files."""
-    vault_path = Path(vault_path)
-    files_updated = 0
-    
-    for file_path in vault_path.rglob('*.md'):
-        if any(skip in file_path.parts for skip in ['.obsidian', '.trash', '.git']):
-            continue
-            
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            
-            # Check if file has frontmatter
-            if not content.strip().startswith('---'):
-                continue
-                
-            # Find frontmatter boundaries
-            lines = content.split('\n')
-            if len(lines) < 3:
-                continue
-                
-            end_idx = None
-            for i in range(1, len(lines)):
-                if lines[i].strip() == '---':
-                    end_idx = i
-                    break
-                    
-            if end_idx is None:
-                continue
-                
-            # Extract frontmatter
-            frontmatter_text = '\n'.join(lines[1:end_idx])
-            
-            # Check if tags line has quoted values
-            if re.search(r"tags:\s*\[['\"]", frontmatter_text):
-                # Parse frontmatter
-                try:
-                    frontmatter = yaml.safe_load(frontmatter_text)
-                    if frontmatter and 'tags' in frontmatter:
-                        # Update tags (remove quotes)
-                        tags = frontmatter['tags']
-                        if isinstance(tags, list):
-                            # Tags are already in list format, just ensure they're not quoted
-                            frontmatter['tags'] = [str(tag) for tag in tags]
-                            
-                            # Reconstruct content
-                            new_frontmatter = yaml.dump(frontmatter, default_flow_style=False, sort_keys=False)
-                            remaining_content = '\n'.join(lines[end_idx + 1:])
-                            new_content = f"---\n{new_frontmatter}---\n{remaining_content}"
-                            
-                            # Write back
-                            with open(file_path, 'w', encoding='utf-8') as f:
-                                f.write(new_content)
-                            
-                            files_updated += 1
-                            print(f"Fixed: {file_path.relative_to(vault_path)}")
-                            
-                except yaml.YAMLError as e:
-                    print(f"YAML error in {file_path}: {e}")
-                    
-        except Exception as e:
-            print(f"Error processing {file_path}: {e}")
-    
-    return files_updated
-
-if __name__ == '__main__':
-    vault_path = '/Users/cam/VAULT01'
-    print(f"Fixing quoted tags in: {vault_path}")
-    
-    updated = fix_quoted_tags(vault_path)
-    print(f"\nTotal files updated: {updated}")

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