Mem0 Memory

#!/usr/bin/env python3
"""
Batch delete memories from mem0.
Usage: ./batch-delete.py --memory-ids '["mem_123","mem_456"]'
"""
import argparse
import json
import sys
from pathlib import Path

# Add lib directory to path
_SCRIPT_DIR = Path(__file__).parent
_LIB_DIR = _SCRIPT_DIR.parent / "lib"
if str(_LIB_DIR) not in sys.path:
    sys.path.insert(0, str(_LIB_DIR))
from mem0_client import get_mem0_client  # type: ignore  # noqa: E402


def main():
    parser = argparse.ArgumentParser(description="Batch delete mem0 memories")
    parser.add_argument("--memory-ids", required=True, help="JSON array of memory IDs to delete")
    parser.add_argument("--api-key", help="Or use MEM0_API_KEY env")
    parser.add_argument("--org-id", help="Or use MEM0_ORG_ID env")
    parser.add_argument("--project-id", help="Or use MEM0_PROJECT_ID env")
    args = parser.parse_args()

    try:
        client = get_mem0_client(
            api_key=args.api_key,
            org_id=args.org_id,
            project_id=args.project_id
        )

        memory_ids = json.loads(args.memory_ids)
        if not isinstance(memory_ids, list):
            raise ValueError("--memory-ids must be a JSON array")

        result = client.batch_delete(memories=memory_ids)

        print(json.dumps({
            "success": True,
            "deleted_count": len(memory_ids),
            "result": result
        }, indent=2))

    except ValueError as e:
        print(json.dumps({
            "error": str(e),
            "type": "ValueError"
        }, indent=2), file=sys.stderr)
        sys.exit(1)
    except ImportError as e:
        print(json.dumps({
            "error": str(e),
            "type": "ImportError"
        }, indent=2), file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(json.dumps({
            "error": str(e),
            "type": type(e).__name__
        }, indent=2), file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Batch update memories in mem0 (up to 1000 at once).
Usage: ./batch-update.py --memories '[{"memory_id":"mem_123","text":"updated"}]'
"""
import argparse
import json
import sys
from pathlib import Path

# Add lib directory to path
_SCRIPT_DIR = Path(__file__).parent
_LIB_DIR = _SCRIPT_DIR.parent / "lib"
if str(_LIB_DIR) not in sys.path:
    sys.path.insert(0, str(_LIB_DIR))
from mem0_client import get_mem0_client  # type: ignore  # noqa: E402


def main():
    parser = argparse.ArgumentParser(description="Batch update mem0 memories")
    parser.add_argument("--memories", required=True, help="JSON array of memory updates")
    parser.add_argument("--api-key", help="Or use MEM0_API_KEY env")
    parser.add_argument("--org-id", help="Or use MEM0_ORG_ID env")
    parser.add_argument("--project-id", help="Or use MEM0_PROJECT_ID env")
    args = parser.parse_args()

    try:
        client = get_mem0_client(
            api_key=args.api_key,
            org_id=args.org_id,
            project_id=args.project_id
        )

        memories = json.loads(args.memories)
        if not isinstance(memories, list):
            raise ValueError("--memories must be a JSON array")

        result = client.batch_update(memories=memories)

        print(json.dumps({
            "success": True,
            "updated_count": len(memories),
            "result": result
        }, indent=2))

    except ValueError as e:
        print(json.dumps({
            "error": str(e),
            "type": "ValueError"
        }, indent=2), file=sys.stderr)
        sys.exit(1)
    except ImportError as e:
        print(json.dumps({
            "error": str(e),
            "type": "ImportError"
        }, indent=2), file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(json.dumps({
            "error": str(e),
            "type": type(e).__name__
        }, indent=2), file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Bulk export multiple user_ids from mem0.
Usage: ./bulk-export.py --user-ids "user1,user2,user3" --schema '{"format":"json"}'
"""
import argparse
import json
import sys
from pathlib import Path

# Add lib directory to path
_SCRIPT_DIR = Path(__file__).parent
_LIB_DIR = _SCRIPT_DIR.parent / "lib"
if str(_LIB_DIR) not in sys.path:
    sys.path.insert(0, str(_LIB_DIR))
from mem0_client import get_mem0_client  # type: ignore  # noqa: E402


def main():
    parser = argparse.ArgumentParser(description="Bulk export multiple user_ids from mem0")
    parser.add_argument("--user-ids", required=True, help="Comma-separated list of user IDs")
    parser.add_argument("--schema", default='{"format":"json"}', help="Export schema JSON object")
    parser.add_argument("--api-key", help="Or use MEM0_API_KEY env")
    parser.add_argument("--org-id", help="Or use MEM0_ORG_ID env")
    parser.add_argument("--project-id", help="Or use MEM0_PROJECT_ID env")
    args = parser.parse_args()

    try:
        client = get_mem0_client(
            api_key=args.api_key,
            org_id=args.org_id,
            project_id=args.project_id
        )

        # Parse user IDs
        user_ids = [uid.strip() for uid in args.user_ids.split(",")]
        
        # Parse schema
        try:
            schema_obj = json.loads(args.schema) if args.schema else {"format": "json"}
        except json.JSONDecodeError:
            schema_obj = {"format": args.schema}

        # Create exports for each user_id
        exports = []
        for user_id in user_ids:
            try:
                # Create export with filters for this user_id
                result = client.create_memory_export(
                    schema=json.dumps(schema_obj) if isinstance(schema_obj, dict) else str(schema_obj),
                    user_id=user_id
                )
                exports.append({
                    "user_id": user_id,
                    "export_id": result.get("export_id") if isinstance(result, dict) else None,
                    "status": "created",
                    "result": result
                })
            except Exception as e:
                exports.append({
                    "user_id": user_id,
                    "status": "error",
                    "error": str(e)
                })

        print(json.dumps({
            "success": True,
            "count": len(user_ids),
            "exports": exports
        }, indent=2))

    except ValueError as e:
        print(json.dumps({
            "error": str(e),
            "type": "ValueError"
        }, indent=2), file=sys.stderr)
        sys.exit(1)
    except ImportError as e:
        print(json.dumps({
            "error": str(e),
            "type": "ImportError"
        }, indent=2), file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(json.dumps({
            "error": str(e),
            "type": type(e).__name__
        }, indent=2), file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Create memories for all agents in the OrchestKit plugin.
Scans agents/ directory and creates Mem0 memories with skill relationships.
"""
import json
import re
import sys
import yaml
from pathlib import Path
from typing import Dict, Any, List

# Add mem0 scripts to path
SCRIPT_DIR = Path(__file__).parent
PROJECT_ROOT = SCRIPT_DIR.parent.parent.parent.parent
AGENTS_DIR = PROJECT_ROOT / "agents"

sys.path.insert(0, str(SCRIPT_DIR.parent / "lib"))
from mem0_client import get_mem0_client  # type: ignore  # noqa: E402

USER_ID = "orchestkit:all-agents"


def extract_agent_skills(agent_file: Path) -> List[str]:
    """Extract skills list from agent markdown file."""
    content = agent_file.read_text()
    skills = []
    in_skills = False
    
    for line in content.split('\n'):
        if line.strip().startswith('skills:'):
            in_skills = True
            continue
        if in_skills:
            if line.strip().startswith('- '):
                skill = line.strip()[2:].strip()
                skills.append(skill)
            elif line.strip() and not line.startswith(' ') and not line.startswith('\t') and not line.startswith('#'):
                break
    
    return skills


def extract_frontmatter(content: str) -> Dict[str, Any]:
    """Extract YAML frontmatter from markdown."""
    frontmatter = {}
    
    if not content.startswith("---"):
        return frontmatter
    
    try:
        end_idx = content.find("---", 3)
        if end_idx == -1:
            return frontmatter
        
        yaml_content = content[3:end_idx].strip()
        frontmatter = yaml.safe_load(yaml_content) or {}
    except Exception as e:
        print(f"Warning: Failed to parse frontmatter: {e}")
    
    return frontmatter


def create_agent_memory(client, agent_file: Path, agent_name: str) -> Optional[Dict[str, Any]]:
    """Create a memory for a single agent."""
    content = agent_file.read_text()
    frontmatter = extract_frontmatter(content)
    
    # Extract agent info
    name = frontmatter.get("name", agent_name)
    description = frontmatter.get("description", "")
    skills = extract_agent_skills(agent_file)
    
    # Build memory text
    text_parts = [
        f"{name} agent: {description}",
        f"The {name} agent is a specialized AI persona in the OrchestKit plugin."
    ]
    
    if skills:
        text_parts.append(f"The {name} agent uses {len(skills)} skills: {', '.join(skills[:10])}.")
        if len(skills) > 10:
            text_parts.append(f"Additional skills include: {', '.join(skills[10:20])}.")
    
    memory_text = ". ".join(text_parts) + "."
    
    # Build metadata
    metadata = {
        "type": "agent",
        "entity_type": "Agent",
        "color_group": "agent",
        "category": "agents",
        "plugin_component": True,
        "name": name,
        "agent_name": agent_name,
        "agent_type": "specialist",  # Can be "specialist", "generalist", etc.
        "shared": False,  # Agent-specific memory, not shared
        "skills": skills[:30]  # Limit skills in metadata
    }
    
    if description:
        metadata["description"] = description[:300]  # Truncate long descriptions
    
    # Add model if specified
    if "model" in frontmatter:
        metadata["model"] = frontmatter["model"]
    
    try:
        result = client.add(
            messages=[{"role": "user", "content": memory_text}],
            user_id=USER_ID,
            metadata=metadata,
            enable_graph=True
        )
        print(f"  ✓ Created: {name} ({len(skills)} skills)")
        return result
    except Exception as e:
        print(f"  ✗ Failed: {name}: {e}", file=sys.stderr)
        return None


def main():
    import argparse
    
    parser = argparse.ArgumentParser(description="Create Mem0 memories for all agents")
    parser.add_argument("--dry-run", action="store_true", help="Show what would be created without making changes")
    parser.add_argument("--limit", type=int, help="Limit number of agents to process")
    parser.add_argument("--skip-existing", action="store_true", help="Skip agents that already have memories")
    args = parser.parse_args()
    
    try:
        client = get_mem0_client()
        
        # Get all agent files
        agent_files = list(AGENTS_DIR.glob("*.md"))
        agent_files.sort()
        
        if args.limit:
            agent_files = agent_files[:args.limit]
        
        print(f"Found {len(agent_files)} agents to process\n")
        
        if args.dry_run:
            print("DRY RUN MODE - No changes will be made\n")
        
        # Check existing memories if skip-existing
        existing_agents = set()
        if args.skip_existing:
            print("Checking for existing agent memories...")
            try:
                result = client.search(
                    query="agent specialized AI persona",
                    filters={"user_id": USER_ID, "metadata.entity_type": "Agent"},
                    limit=1000
                )
                for memory in result.get("results", []):
                    metadata = memory.get("metadata", {})
                    if "agent_name" in metadata:
                        existing_agents.add(metadata["agent_name"])
                    elif "name" in metadata:
                        existing_agents.add(metadata["name"])
                print(f"Found {len(existing_agents)} existing agent memories\n")
            except Exception as e:
                print(f"Warning: Could not check existing memories: {e}\n")
        
        created_count = 0
        skipped_count = 0
        failed_count = 0
        
        for agent_file in agent_files:
            agent_name = agent_file.stem  # filename without .md
            
            if args.skip_existing and agent_name in existing_agents:
                print(f"  ⊘ Skipped (exists): {agent_name}")
                skipped_count += 1
                continue
            
            if args.dry_run:
                skills = extract_agent_skills(agent_file)
                print(f"  [DRY RUN] Would create: {agent_name} ({len(skills)} skills)")
                created_count += 1
            else:
                result = create_agent_memory(client, agent_file, agent_name)
                if result:
                    created_count += 1
                else:
                    failed_count += 1
        
        print(f"\n=== Summary ===")
        print(f"Created: {created_count}")
        print(f"Skipped: {skipped_count}")
        print(f"Failed: {failed_count}")
        print(f"Total: {len(agent_files)}")
        
        if args.dry_run:
            print("\nRun without --dry-run to create memories")
        else:
            print("\n✓ Agent memories creation complete!")
            print("Note: Agent-skill relationships will be created separately")
        
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Create memories for all skills in the OrchestKit plugin.
Scans skills/ directory and creates Mem0 memories with proper metadata.
"""
import json
import re
import sys
import yaml
from pathlib import Path
from typing import Dict, Any, Optional, List

# Add mem0 scripts to path
SCRIPT_DIR = Path(__file__).parent
PROJECT_ROOT = SCRIPT_DIR.parent.parent.parent.parent
SKILLS_DIR = PROJECT_ROOT / "skills"

sys.path.insert(0, str(SCRIPT_DIR.parent / "lib"))
from mem0_client import get_mem0_client  # type: ignore  # noqa: E402

USER_ID = "orchestkit:all-agents"


def extract_frontmatter(content: str) -> Dict[str, Any]:
    """Extract YAML frontmatter from markdown."""
    frontmatter = {}
    
    if not content.startswith("---"):
        return frontmatter
    
    try:
        # Find frontmatter boundaries
        end_idx = content.find("---", 3)
        if end_idx == -1:
            return frontmatter
        
        yaml_content = content[3:end_idx].strip()
        frontmatter = yaml.safe_load(yaml_content) or {}
    except Exception as e:
        print(f"Warning: Failed to parse frontmatter: {e}")
    
    return frontmatter


def determine_category(skill_name: str, tags: List[str], content: str) -> str:
    """Determine skill category from name, tags, and content."""
    name_lower = skill_name.lower()
    tags_lower = [t.lower() for t in tags]
    content_lower = content.lower()
    
    # Category mapping based on patterns
    if any(tag in ["backend", "api", "fastapi", "sqlalchemy", "database", "async"] for tag in tags_lower):
        return "backend-skills"
    if any(tag in ["frontend", "react", "typescript", "ui", "component"] for tag in tags_lower):
        return "frontend-skills"
    if any(tag in ["ai", "llm", "rag", "langgraph", "embedding", "agent"] for tag in tags_lower):
        return "ai-llm-skills"
    if any(tag in ["test", "testing", "mock", "coverage"] for tag in tags_lower):
        return "testing-skills"
    if any(tag in ["security", "auth", "owasp", "validation"] for tag in tags_lower):
        return "security-skills"
    if any(tag in ["devops", "ci", "cd", "deployment"] for tag in tags_lower):
        return "devops-skills"
    if any(tag in ["git", "github", "release"] for tag in tags_lower):
        return "git-github-skills"
    if any(tag in ["workflow", "coordination", "implementation"] for tag in tags_lower):
        return "workflow-skills"
    if any(tag in ["quality", "review", "golden"] for tag in tags_lower):
        return "quality-skills"
    if any(tag in ["context", "memory", "compression"] for tag in tags_lower):
        return "context-skills"
    if any(tag in ["event", "queue", "cqrs", "saga"] for tag in tags_lower):
        return "event-driven-skills"
    if any(tag in ["database", "migration", "schema"] for tag in tags_lower):
        return "database-skills"
    if any(tag in ["accessibility", "a11y", "wcag"] for tag in tags_lower):
        return "accessibility-skills"
    if any(tag in ["mcp", "model-context"] for tag in tags_lower):
        return "mcp-skills"
    
    # Fallback to name patterns
    if "backend" in name_lower or "api" in name_lower or "fastapi" in name_lower:
        return "backend-skills"
    if "frontend" in name_lower or "react" in name_lower or "ui" in name_lower:
        return "frontend-skills"
    if "ai" in name_lower or "llm" in name_lower or "rag" in name_lower or "langgraph" in name_lower:
        return "ai-llm-skills"
    if "test" in name_lower:
        return "testing-skills"
    if "security" in name_lower or "auth" in name_lower:
        return "security-skills"
    
    return "unknown"


def determine_technology(skill_name: str, tags: List[str], content: str) -> Optional[str]:
    """Determine which technology a skill implements."""
    name_lower = skill_name.lower()
    tags_lower = [t.lower() for t in tags]
    content_lower = content.lower()
    
    # Technology mapping
    tech_patterns = {
        "FastAPI": ["fastapi", "fast-api"],
        "React 19": ["react", "react19", "react-19"],
        "LangGraph": ["langgraph", "lang-graph"],
        "PostgreSQL": ["postgresql", "postgres", "pgvector"],
        "TypeScript": ["typescript", "ts"],
        "Python": ["python", "py"],
        "TanStack Query": ["tanstack", "tanstack-query", "react-query"],
        "Zustand": ["zustand"],
        "Zod": ["zod"],
        "Pydantic": ["pydantic"],
        "Playwright": ["playwright"],
        "pytest": ["pytest"],
        "MSW": ["msw", "mock-service-worker"],
        "Redis": ["redis"],
        "Celery": ["celery"],
        "RabbitMQ": ["rabbitmq", "rabbit-mq"],
        "Docker": ["docker"],
        "GitHub Actions": ["github-actions", "github actions"]
    }
    
    # Check tags first
    for tech, patterns in tech_patterns.items():
        if any(pattern in tag for tag in tags_lower for pattern in patterns):
            return tech
    
    # Check skill name
    for tech, patterns in tech_patterns.items():
        if any(pattern in name_lower for pattern in patterns):
            return tech
    
    # Check content
    for tech, patterns in tech_patterns.items():
        if any(pattern in content_lower for pattern in patterns):
            return tech
    
    return None


def create_skill_memory(client, skill_dir: Path, skill_name: str) -> Optional[Dict[str, Any]]:
    """Create a memory for a single skill."""
    skill_md = skill_dir / "SKILL.md"
    
    if not skill_md.exists():
        print(f"  ⚠ SKILL.md not found for {skill_name}")
        return None
    
    content = skill_md.read_text()
    frontmatter = extract_frontmatter(content)
    
    # Extract skill info
    name = frontmatter.get("name", skill_name)
    description = frontmatter.get("description", "")
    tags = frontmatter.get("tags", [])
    if isinstance(tags, str):
        tags = [t.strip() for t in tags.split(",")]
    
    # Determine category and technology
    category = determine_category(skill_name, tags, content)
    technology = determine_technology(skill_name, tags, content)
    
    # Build memory text
    text_parts = [
        f"{name} skill: {description}",
        f"The {name} skill provides patterns and best practices for {skill_name.replace('-', ' ')}."
    ]
    
    if tags:
        text_parts.append(f"Tags: {', '.join(tags[:5])}")  # Limit tags
    
    if technology:
        text_parts.append(f"The {name} skill implements {technology} technology.")
    
    text_parts.append(f"The {name} skill belongs to {category} category.")
    
    memory_text = ". ".join(text_parts) + "."
    
    # Build metadata
    metadata = {
        "type": "skill",
        "entity_type": "Skill",
        "color_group": "skill",
        "category": category,
        "plugin_component": True,
        "name": name,
        "skill_name": skill_name,
        "shared": True,  # Skills are shared knowledge across agents
        "tags": tags[:10]  # Limit tags in metadata
    }
    
    if technology:
        metadata["implements"] = technology
        metadata["technology"] = technology
    
    if description:
        metadata["description"] = description[:200]  # Truncate long descriptions
    
    try:
        result = client.add(
            messages=[{"role": "user", "content": memory_text}],
            user_id=USER_ID,
            metadata=metadata,
            enable_graph=True
        )
        print(f"  ✓ Created: {name} ({category})")
        if technology:
            print(f"    → implements {technology}")
        return result
    except Exception as e:
        print(f"  ✗ Failed: {name}: {e}", file=sys.stderr)
        return None


def main():
    import argparse
    
    parser = argparse.ArgumentParser(description="Create Mem0 memories for all skills")
    parser.add_argument("--dry-run", action="store_true", help="Show what would be created without making changes")
    parser.add_argument("--limit", type=int, help="Limit number of skills to process")
    parser.add_argument("--skip-existing", action="store_true", help="Skip skills that already have memories")
    args = parser.parse_args()
    
    try:
        client = get_mem0_client()
        
        # Get all skill directories
        skill_dirs = [d for d in SKILLS_DIR.iterdir() if d.is_dir() and (d / "SKILL.md").exists()]
        skill_dirs.sort()
        
        if args.limit:
            skill_dirs = skill_dirs[:args.limit]
        
        print(f"Found {len(skill_dirs)} skills to process\n")
        
        if args.dry_run:
            print("DRY RUN MODE - No changes will be made\n")
        
        created_count = 0
        skipped_count = 0
        failed_count = 0
        
        # Check existing memories if skip-existing
        existing_skills = set()
        if args.skip_existing:
            print("Checking for existing skill memories...")
            try:
                result = client.search(
                    query="skill provides patterns",
                    filters={"user_id": USER_ID, "metadata.entity_type": "Skill"},
                    limit=1000
                )
                for memory in result.get("results", []):
                    metadata = memory.get("metadata", {})
                    if "skill_name" in metadata:
                        existing_skills.add(metadata["skill_name"])
                print(f"Found {len(existing_skills)} existing skill memories\n")
            except Exception as e:
                print(f"Warning: Could not check existing memories: {e}\n")
        
        for skill_dir in skill_dirs:
            skill_name = skill_dir.name
            
            if args.skip_existing and skill_name in existing_skills:
                print(f"  ⊘ Skipped (exists): {skill_name}")
                skipped_count += 1
                continue
            
            if args.dry_run:
                print(f"  [DRY RUN] Would create: {skill_name}")
                created_count += 1
            else:
                result = create_skill_memory(client, skill_dir, skill_name)
                if result:
                    created_count += 1
                else:
                    failed_count += 1
        
        print(f"\n=== Summary ===")
        print(f"Created: {created_count}")
        print(f"Skipped: {skipped_count}")
        print(f"Failed: {failed_count}")
        print(f"Total: {len(skill_dirs)}")
        
        if args.dry_run:
            print("\nRun without --dry-run to create memories")
        else:
            print("\n✓ Skill memories creation complete!")
        
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Create memories for all custom categories in OrchestKit plugin.
Creates category entity memories that group related skills, agents, and technologies.
"""
import sys
from pathlib import Path

# Add mem0 scripts to path
SCRIPT_DIR = Path(__file__).parent
PROJECT_ROOT = SCRIPT_DIR.parent.parent.parent.parent

sys.path.insert(0, str(SCRIPT_DIR.parent / "lib"))
from mem0_client import get_mem0_client  # type: ignore  # noqa: E402

USER_ID = "orchestkit:all-agents"


# Category definitions (matching setup-categories.py)
CATEGORIES = [
    {
        "slug": "agents",
        "name": "Agents",
        "description": "Specialized AI agent personas including backend-system-architect, frontend-ui-developer, database-engineer, llm-integrator, security-auditor, and 30 more. These agents use specific skills to accomplish their tasks."
    },
    {
        "slug": "backend-skills",
        "name": "Backend Skills",
        "description": "Backend development patterns including FastAPI, async Python, SQLAlchemy, API design, REST, GraphQL, microservices, database operations, connection pooling, and backend architecture patterns."
    },
    {
        "slug": "frontend-skills",
        "name": "Frontend Skills",
        "description": "Frontend development patterns including React 19, TypeScript, UI components, TanStack Query, forms, performance optimization, accessibility, animations, lazy loading, and frontend architecture patterns."
    },
    {
        "slug": "ai-llm-skills",
        "name": "AI/LLM Skills",
        "description": "AI and LLM patterns including RAG, embeddings, LangGraph, agent orchestration, LLM safety, prompt engineering, function calling, streaming, semantic caching, and AI/ML integration patterns."
    },
    {
        "slug": "testing-skills",
        "name": "Testing Skills",
        "description": "Testing patterns including unit tests, integration tests, E2E tests, property-based testing, test coverage, mocking, test data management, and testing best practices."
    },
    {
        "slug": "security-skills",
        "name": "Security Skills",
        "description": "Security patterns including OWASP Top 10, authentication, authorization, input validation, defense-in-depth, LLM safety, MCP security, and security auditing patterns."
    },
    {
        "slug": "devops-skills",
        "name": "DevOps Skills",
        "description": "DevOps patterns for CI/CD, observability, GitHub operations, deployment, monitoring, and infrastructure as code."
    },
    {
        "slug": "git-github-skills",
        "name": "Git/GitHub Skills",
        "description": "Git workflow, GitHub operations, releases, recovery patterns, stacked PRs, and version control best practices."
    },
    {
        "slug": "workflow-skills",
        "name": "Workflow Skills",
        "description": "Workflow patterns for implementation, exploration, coordination, multi-agent workflows, and development processes."
    },
    {
        "slug": "quality-skills",
        "name": "Quality Skills",
        "description": "Quality gates, reviews, golden dataset management, code quality, and quality assurance patterns."
    },
    {
        "slug": "context-skills",
        "name": "Context Skills",
        "description": "Context compression, engineering, brainstorming, planning, memory management, and context optimization patterns."
    },
    {
        "slug": "event-driven-skills",
        "name": "Event-Driven Skills",
        "description": "Event sourcing, message queues, outbox patterns, CQRS, and event-driven architecture patterns."
    },
    {
        "slug": "database-skills",
        "name": "Database Skills",
        "description": "Database migrations, versioning, zero-downtime patterns, schema design, and database optimization patterns."
    },
    {
        "slug": "accessibility-skills",
        "name": "Accessibility Skills",
        "description": "WCAG compliance, focus management, React ARIA patterns, and accessibility best practices."
    },
    {
        "slug": "mcp-skills",
        "name": "MCP Skills",
        "description": "MCP advanced patterns, server building, tool composition, and Model Context Protocol integration."
    },
    {
        "slug": "technologies",
        "name": "Technologies",
        "description": "Core technologies and frameworks including FastAPI, React 19, LangGraph, PostgreSQL, pgvector, TypeScript, Python 3.11+, and Claude Code 2.1.11."
    },
    {
        "slug": "architecture-decisions",
        "name": "Architecture Decisions",
        "description": "Key architectural decisions including Graph-First Memory Architecture, Progressive Loading Protocol, CC 2.1.7 Flat Skill Structure, Hook-Based Lifecycle Automation, and Multi-Worktree Coordination."
    },
    {
        "slug": "relationships",
        "name": "Relationships",
        "description": "Relationships between agents, skills, and technologies including agent-skill mappings, skill-technology implementations, multi-hop chains, and cross-entity connections."
    }
]


def create_category_memory(client, category: Dict[str, Any]) -> bool:
    """Create a memory for a category."""
    slug = category["slug"]
    name = category["name"]
    description = category["description"]
    
    # Build memory text
    text = f"{name} category: {description} The {name} category groups related entities in the OrchestKit plugin structure."
    
    # Build metadata
    metadata = {
        "type": "category",
        "entity_type": "Category",
        "color_group": "category",
        "category": slug,
        "plugin_component": True,
        "name": name,
        "category_slug": slug,
        "shared": True  # Categories are shared knowledge across agents
    }
    
    try:
        result = client.add(
            messages=[{"role": "user", "content": text}],
            user_id=USER_ID,
            metadata=metadata,
            enable_graph=True
        )
        print(f"  ✓ Created: {name} ({slug})")
        return True
    except Exception as e:
        print(f"  ✗ Failed: {name}: {e}", file=sys.stderr)
        return False


def main():
    import argparse
    
    parser = argparse.ArgumentParser(description="Create Mem0 memories for categories")
    parser.add_argument("--dry-run", action="store_true", help="Show what would be created without making changes")
    parser.add_argument("--skip-existing", action="store_true", help="Skip categories that already have memories")
    args = parser.parse_args()
    
    try:
        client = get_mem0_client()
        
        print(f"Creating memories for {len(CATEGORIES)} categories\n")
        
        if args.dry_run:
            print("DRY RUN MODE - No changes will be made\n")
        
        # Check existing memories if skip-existing
        existing_categories = set()
        if args.skip_existing:
            print("Checking for existing category memories...")
            try:
                result = client.search(
                    query="category groups related",
                    filters={"user_id": USER_ID, "metadata.entity_type": "Category"},
                    limit=1000
                )
                for memory in result.get("results", []):
                    metadata = memory.get("metadata", {})
                    if "category_slug" in metadata:
                        existing_categories.add(metadata["category_slug"])
                    elif "category" in metadata:
                        existing_categories.add(metadata["category"])
                print(f"Found {len(existing_categories)} existing category memories\n")
            except Exception as e:
                print(f"Warning: Could not check existing memories: {e}\n")
        
        created_count = 0
        skipped_count = 0
        failed_count = 0
        
        for category in CATEGORIES:
            if args.skip_existing and category["slug"] in existing_categories:
                print(f"  ⊘ Skipped (exists): {category['name']}")
                skipped_count += 1
                continue
            
            if args.dry_run:
                print(f"  [DRY RUN] Would create: {category['name']} ({category['slug']})")
                created_count += 1
            else:
                if create_category_memory(client, category):
                    created_count += 1
                else:
                    failed_count += 1
        
        print(f"\n=== Summary ===")
        print(f"Created: {created_count}")
        print(f"Skipped: {skipped_count}")
        print(f"Failed: {failed_count}")
        print(f"Total: {len(CATEGORIES)}")
        
        if args.dry_run:
            print("\nRun without --dry-run to create memories")
        else:
            print("\n✓ Category memories creation complete!")
        
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        import traceback
        traceback.print_exc()
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Create Deep Multi-Hop Relationships in Mem0
Uses OrchestKit agents and skills to build comprehensive relationship chains
"""
import json
import re
import sys
from pathlib import Path

# Add mem0 scripts to path
SCRIPT_DIR = Path(__file__).parent
PROJECT_ROOT = SCRIPT_DIR.parent.parent.parent.parent
MEM0_SCRIPT = SCRIPT_DIR.parent / "crud" / "add-memory.py"
AGENTS_DIR = PROJECT_ROOT / "agents"
SKILLS_DIR = PROJECT_ROOT / "skills"

sys.path.insert(0, str(SCRIPT_DIR.parent / "lib"))
from mem0_client import get_mem0_client  # type: ignore  # noqa: E402

USER_ID = "orchestkit:all-agents"

def extract_agent_skills(agent_file: Path) -> list[str]:
    """Extract skills list from agent markdown file."""
    content = agent_file.read_text()
    skills = []
    in_skills = False
    
    for line in content.split('\n'):
        if line.strip().startswith('skills:'):
            in_skills = True
            continue
        if in_skills:
            if line.strip().startswith('- '):
                skill = line.strip()[2:].strip()
                skills.append(skill)
            elif line.strip() and not line.startswith(' ') and not line.startswith('\t'):
                break
    
    return skills

def get_skill_category(skill_name: str) -> str:
    """Determine skill category from skill name and directory."""
    skill_dir = SKILLS_DIR / skill_name
    if not skill_dir.exists():
        return "Unknown"
    
    skill_md = skill_dir / "SKILL.md"
    if skill_md.exists():
        content = skill_md.read_text()
        # Try to extract category from tags or description
        if 'tags:' in content:
            tags_match = re.search(r'tags:\s*\[(.*?)\]', content)
            if tags_match:
                tags = [t.strip().strip('"\'') for t in tags_match.group(1).split(',')]
                # Map tags to categories
                if any('ai' in t.lower() or 'llm' in t.lower() or 'rag' in t.lower() for t in tags):
                    return "AI/LLM Skills"
                if any('backend' in t.lower() or 'api' in t.lower() or 'fastapi' in t.lower() for t in tags):
                    return "Backend Skills"
                if any('frontend' in t.lower() or 'react' in t.lower() or 'ui' in t.lower() for t in tags):
                    return "Frontend Skills"
                if any('test' in t.lower() or 'testing' in t.lower() for t in tags):
                    return "Testing Skills"
                if any('security' in t.lower() or 'auth' in t.lower() or 'owasp' in t.lower() for t in tags):
                    return "Security Skills"
                if any('memory' in t.lower() or 'context' in t.lower() for t in tags):
                    return "Context Skills"
    
    return "Unknown"

def get_skill_technology(skill_name: str) -> str | None:
    """Determine which technology a skill implements."""
    tech_mapping = {
        'fastapi-advanced': 'FastAPI',
        'sqlalchemy-2-async': 'PostgreSQL',
        'react-server-components-framework': 'React 19',
        'langgraph-state': 'LangGraph',
        'langgraph-routing': 'LangGraph',
        'langgraph-parallel': 'LangGraph',
        'langgraph-checkpoints': 'LangGraph',
        'langgraph-supervisor': 'LangGraph',
        'pgvector-search': 'pgvector',
        'tanstack-query-advanced': 'TypeScript',
        'form-state-patterns': 'React 19',
    }
    return tech_mapping.get(skill_name)

def create_agent_skill_memories(client, agent_name: str, skills: list[str]):
    """Create memories linking agent to each skill with explicit relationships."""
    memories_created = []
    
    for skill in skills:
        category = get_skill_category(skill)
        technology = get_skill_technology(skill)
        
        # Build relationship text that explicitly mentions all entities
        text_parts = [
            f"{agent_name} agent uses {skill} skill",
        ]
        
        if category != "Unknown":
            text_parts.append(f"The {skill} skill belongs to {category} category")
        
        if technology:
            text_parts.append(f"The {skill} skill implements {technology} technology")
            text_parts.append(f"{technology} is a core technology used in OrchestKit plugin patterns")
        
        # Add context about what the skill does
        if 'api' in skill:
            text_parts.append(f"{skill} provides API design patterns")
        if 'database' in skill or 'sql' in skill:
            text_parts.append(f"{skill} provides database patterns")
        if 'react' in skill or 'frontend' in skill:
            text_parts.append(f"{skill} provides frontend patterns")
        if 'langgraph' in skill:
            text_parts.append(f"{skill} provides LangGraph agent orchestration patterns")
        
        memory_text = ". ".join(text_parts) + "."
        
        # Map category name to category slug
        category_slug = category.lower().replace(" ", "-").replace("/", "-") if category != "Unknown" else "unknown"
        
        metadata = {
            "type": "relationship",
            "entity_type": "Unknown",  # Relationship memories are connections
            "color_group": "skill",  # Default to skill color for relationships
            "category": category_slug,
            "plugin_component": True,
            "from": agent_name,
            "to": skill,
            "relation": "uses",
            "hop": 1,
            "agent": agent_name,
            "skill": skill
        }
        
        if category != "Unknown":
            metadata["category"] = category_slug
        if technology:
            metadata["technology"] = technology
            metadata["implements"] = technology
        
        try:
            result = client.add(
                messages=[{"role": "user", "content": memory_text}],
                user_id=USER_ID,
                metadata=metadata,
                enable_graph=True
            )
            memories_created.append({
                "agent": agent_name,
                "skill": skill,
                "result": result
            })
            print(f"✓ Created: {agent_name} → uses → {skill}")
        except Exception as e:
            print(f"✗ Failed: {agent_name} → {skill}: {e}", file=sys.stderr)
    
    return memories_created

def create_skill_technology_memories(client, skill_name: str, technology: str, category: str):
    """Create memories linking skill to technology."""
    text = (
        f"{skill_name} skill implements {technology} technology. "
        f"The {skill_name} skill belongs to {category} category. "
        f"{technology} is a core technology used in OrchestKit plugin patterns. "
        f"Skills that implement {technology} provide patterns and best practices for working with {technology}."
    )
    
    # Map category name to category slug
    category_slug = category.lower().replace(" ", "-").replace("/", "-")
    
    metadata = {
        "type": "relationship",
        "entity_type": "Skill",  # Skills implement technologies
        "color_group": "skill",
        "category": category_slug,
        "plugin_component": True,
        "from": skill_name,
        "to": technology,
        "relation": "implements",
        "hop": 2,
        "skill": skill_name,
        "technology": technology,
        "implements": technology
    }
    
    try:
        result = client.add(
            messages=[{"role": "user", "content": text}],
            user_id=USER_ID,
            metadata=metadata,
            enable_graph=True
        )
        print(f"✓ Created: {skill_name} → implements → {technology}")
        return result
    except Exception as e:
        print(f"✗ Failed: {skill_name} → {technology}: {e}", file=sys.stderr)
        return None

def create_multi_hop_chains(client):
    """Create explicit multi-hop relationship chains."""
    print("\n=== Creating Multi-Hop Chains ===\n")
    
    # Chain 1: backend-system-architect → fastapi-advanced → FastAPI → Python 3.11+
    text1 = (
        "backend-system-architect agent uses fastapi-advanced skill for async Python API development. "
        "The fastapi-advanced skill implements FastAPI technology which is a backend framework. "
        "FastAPI technology uses Python 3.11+ language for modern async features. "
        "This creates a 4-hop chain: agent → uses → skill → implements → technology → uses → language."
    )
    client.add(
        messages=[{"role": "user", "content": text1}],
        user_id=USER_ID,
        metadata={
            "type": "multi-hop",
            "entity_type": "Unknown",
            "color_group": "skill",
            "category": "relationships",
            "plugin_component": True,
            "chain": "agent→skill→technology→language",
            "hops": 4
        },
        enable_graph=True
    )
    print("✓ Created 4-hop chain: backend-system-architect → fastapi-advanced → FastAPI → Python 3.11+")
    
    # Chain 2: database-engineer → pgvector-search → pgvector → PostgreSQL
    text2 = (
        "database-engineer agent uses pgvector-search skill for hybrid search in RAG applications. "
        "The pgvector-search skill implements pgvector technology for vector similarity search. "
        "pgvector technology extends PostgreSQL database by adding vector search capabilities. "
        "This creates a 4-hop chain: agent → uses → skill → implements → technology → extends → database."
    )
    client.add(
        messages=[{"role": "user", "content": text2}],
        user_id=USER_ID,
        metadata={
            "type": "multi-hop",
            "entity_type": "Unknown",
            "color_group": "skill",
            "category": "relationships",
            "plugin_component": True,
            "chain": "agent→skill→technology→database",
            "hops": 4
        },
        enable_graph=True
    )
    print("✓ Created 4-hop chain: database-engineer → pgvector-search → pgvector → PostgreSQL")
    
    # Chain 3: frontend-ui-developer → react-server-components-framework → React 19 → TypeScript
    text3 = (
        "frontend-ui-developer agent uses react-server-components-framework skill for Next.js 16+ apps. "
        "The react-server-components-framework skill implements React 19 technology with Server Components. "
        "React 19 technology uses TypeScript for type safety in frontend development. "
        "This creates a 4-hop chain: agent → uses → skill → implements → technology → uses → language."
    )
    client.add(
        messages=[{"role": "user", "content": text3}],
        user_id=USER_ID,
        metadata={
            "type": "multi-hop",
            "entity_type": "Unknown",
            "color_group": "skill",
            "category": "relationships",
            "plugin_component": True,
            "chain": "agent→skill→technology→language",
            "hops": 4
        },
        enable_graph=True
    )
    print("✓ Created 4-hop chain: frontend-ui-developer → react-server-components-framework → React 19 → TypeScript")
    
    # Chain 4: llm-integrator → langgraph-state → LangGraph → multi-agent workflows
    text4 = (
        "llm-integrator agent uses langgraph-state skill for LangGraph state management. "
        "The langgraph-state skill implements LangGraph technology for agent orchestration. "
        "LangGraph technology enables multi-agent workflows with state persistence and routing. "
        "This creates a relationship chain connecting agent skills to orchestration technology."
    )
    client.add(
        messages=[{"role": "user", "content": text4}],
        user_id=USER_ID,
        metadata={
            "type": "multi-hop",
            "entity_type": "Unknown",
            "color_group": "skill",
            "category": "relationships",
            "plugin_component": True,
            "chain": "agent→skill→technology→pattern",
            "hops": 4
        },
        enable_graph=True
    )
    print("✓ Created 4-hop chain: llm-integrator → langgraph-state → LangGraph → multi-agent workflows")

def create_all_agent_skill_relationships(client):
    """Create relationships for all agents and their skills."""
    print("\n=== Phase 1: Creating All Agent-Skill Relationships ===\n")
    
    agent_files = list(AGENTS_DIR.glob("*.md"))
    agent_files.sort()
    
    total_relationships = 0
    failed_relationships = 0
    
    for idx, agent_file in enumerate(agent_files, 1):
        agent_name = agent_file.stem
        skills = extract_agent_skills(agent_file)
        
        if skills:
            print(f"[{idx}/{len(agent_files)}] Processing {agent_name} ({len(skills)} skills)...")
            try:
                memories = create_agent_skill_memories(client, agent_name, skills)
                total_relationships += len(memories)
            except Exception as e:
                print(f"  ✗ Error processing {agent_name}: {e}", file=sys.stderr)
                failed_relationships += len(skills)
        else:
            print(f"[{idx}/{len(agent_files)}] Skipping {agent_name} (no skills found)")
    
    print(f"\n✓ Phase 1 complete: {total_relationships} agent-skill relationships created")
    if failed_relationships > 0:
        print(f"  ⚠ {failed_relationships} relationships failed")
    
    return total_relationships


def create_all_skill_technology_relationships(client):
    """Create relationships for all skills and their technologies."""
    print("\n=== Phase 2: Creating All Skill-Technology Relationships ===\n")
    
    # Scan all skills to find technology mappings
    skill_dirs = [d for d in SKILLS_DIR.iterdir() if d.is_dir() and (d / "SKILL.md").exists()]
    
    created_count = 0
    failed_count = 0
    
    for skill_dir in skill_dirs:
        skill_name = skill_dir.name
        category = get_skill_category(skill_name)
        technology = get_skill_technology(skill_name)
        
        if technology:
            try:
                create_skill_technology_memories(client, skill_name, technology, category)
                created_count += 1
            except Exception as e:
                print(f"  ✗ Failed: {skill_name} → {technology}: {e}", file=sys.stderr)
                failed_count += 1
    
    print(f"\n✓ Phase 2 complete: {created_count} skill-technology relationships created")
    if failed_count > 0:
        print(f"  ⚠ {failed_count} relationships failed")
    
    return created_count


def create_technology_dependencies(client):
    """Create technology-to-technology dependency relationships."""
    print("\n=== Phase 3: Creating Technology Dependencies ===\n")
    
    # Technology dependency mappings
    dependencies = [
        ("pgvector", "PostgreSQL", "extends"),
        ("SQLAlchemy", "PostgreSQL", "uses"),
        ("Alembic", "SQLAlchemy", "uses"),
        ("FastAPI", "Python", "uses"),
        ("React 19", "TypeScript", "uses"),
        ("TanStack Query", "React 19", "uses"),
        ("Zustand", "React 19", "uses"),
        ("Zod", "TypeScript", "uses"),
        ("Pydantic", "Python", "uses"),
        ("Celery", "Redis", "uses"),
        ("LangGraph", "Python", "uses"),
    ]
    
    created_count = 0
    for tech_from, tech_to, rel_type in dependencies:
        text = (
            f"{tech_from} technology {rel_type} {tech_to} technology. "
            f"{tech_from} depends on {tech_to} for core functionality. "
            f"Both {tech_from} and {tech_to} are core technologies in OrchestKit plugin patterns."
        )
        
        metadata = {
            "type": "relationship",
            "entity_type": "Technology",
            "color_group": "technology",
            "category": "technologies",
            "plugin_component": True,
            "from": tech_from,
            "to": tech_to,
            "relation": rel_type,
            "hop": 1
        }
        
        try:
            client.add(
                messages=[{"role": "user", "content": text}],
                user_id=USER_ID,
                metadata=metadata,
                enable_graph=True
            )
            print(f"  ✓ Created: {tech_from} → {rel_type} → {tech_to}")
            created_count += 1
        except Exception as e:
            print(f"  ✗ Failed: {tech_from} → {tech_to}: {e}", file=sys.stderr)
    
    print(f"\n✓ Phase 3 complete: {created_count} technology dependencies created")
    return created_count


def create_category_entity_relationships(client):
    """Create category-to-entity belongs_to relationships."""
    print("\n=== Phase 4: Creating Category-Entity Relationships ===\n")
    
    # This would require querying existing memories and matching categories
    # For now, we'll create a few key examples
    category_entities = [
        ("agents", "backend-system-architect", "Agent"),
        ("backend-skills", "fastapi-advanced", "Skill"),
        ("frontend-skills", "react-server-components-framework", "Skill"),
        ("ai-llm-skills", "langgraph-state", "Skill"),
        ("technologies", "FastAPI", "Technology"),
    ]
    
    created_count = 0
    for category_slug, entity_name, entity_type in category_entities:
        text = (
            f"{entity_name} {entity_type.lower()} belongs to {category_slug} category. "
            f"The {category_slug} category contains {entity_type.lower()}s related to {category_slug.replace('-', ' ')}."
        )
        
        metadata = {
            "type": "relationship",
            "entity_type": entity_type,
            "color_group": entity_type.lower(),
            "category": category_slug,
            "plugin_component": True,
            "from": entity_name,
            "to": category_slug,
            "relation": "belongs_to",
            "hop": 1
        }
        
        try:
            client.add(
                messages=[{"role": "user", "content": text}],
                user_id=USER_ID,
                metadata=metadata,
                enable_graph=True
            )
            print(f"  ✓ Created: {entity_name} → belongs_to → {category_slug}")
            created_count += 1
        except Exception as e:
            print(f"  ✗ Failed: {entity_name} → {category_slug}: {e}", file=sys.stderr)
    
    print(f"\n✓ Phase 4 complete: {created_count} category-entity relationships created")
    return created_count


def main():
    import argparse
    
    parser = argparse.ArgumentParser(description="Create comprehensive relationships in Mem0")
    parser.add_argument("--phase", choices=["1", "2", "3", "4", "all"], default="all", help="Which phase to run")
    parser.add_argument("--dry-run", action="store_true", help="Show what would be created without making changes")
    parser.add_argument("--batch-size", type=int, default=10, help="Batch size for processing (to avoid rate limits)")
    args = parser.parse_args()
    
    print("=== Creating Deep Multi-Hop Relationships in Mem0 ===\n")
    
    if args.dry_run:
        print("DRY RUN MODE - No changes will be made\n")
        return
    
    try:
        client = get_mem0_client()
    except Exception as e:
        print(f"Error initializing Mem0 client: {e}", file=sys.stderr)
        sys.exit(1)
    
    total_created = 0
    
    if args.phase in ["1", "all"]:
        total_created += create_all_agent_skill_relationships(client)
    
    if args.phase in ["2", "all"]:
        total_created += create_all_skill_technology_relationships(client)
    
    if args.phase in ["3", "all"]:
        total_created += create_technology_dependencies(client)
    
    if args.phase in ["4", "all"]:
        total_created += create_category_entity_relationships(client)
        # Also create multi-hop chains
        print("\n=== Phase 5: Creating Multi-Hop Chains ===\n")
        create_multi_hop_chains(client)
        total_created += 4  # 4 multi-hop chains
    
    print(f"\n=== Summary ===")
    print(f"Total relationships created: {total_created}")
    print(f"\n✓ All relationships created successfully!")
    print("Note: Mem0 may take a few minutes to process and extract graph relationships")

if __name__ == "__main__":
    main()