empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/meta_workflows/cli_commands/memory_commands.py

@@ -1,182 +0,0 @@
-"""CLI Memory Commands.
-
-Memory Commands for meta-workflow system.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-
-from . import meta_workflow_app
-
-console = Console()
-
-
-@meta_workflow_app.command("search-memory")
-def search_memory(
-    query: str = typer.Argument(..., help="Search query for patterns"),
-    pattern_type: str | None = typer.Option(
-        None,
-        "--type",
-        "-t",
-        help="Filter by pattern type (e.g., 'meta_workflow_execution')",
-    ),
-    limit: int = typer.Option(
-        10,
-        "--limit",
-        "-l",
-        help="Maximum number of results to return",
-    ),
-    user_id: str = typer.Option(
-        "cli_user",
-        "--user-id",
-        "-u",
-        help="User ID for memory access",
-    ),
-):
-    """Search memory for patterns using keyword matching.
-
-    Searches long-term memory for patterns matching the query.
-    Uses relevance scoring: exact phrase (10 pts), keyword in content (2 pts),
-    keyword in metadata (1 pt).
-
-    Examples:
-        empathy meta-workflow search-memory "successful workflow"
-        empathy meta-workflow search-memory "test coverage" --type meta_workflow_execution
-        empathy meta-workflow search-memory "error" --limit 20
-    """
-    try:
-        from empathy_os.memory.unified import UnifiedMemory
-
-        console.print(f"\n[bold]Searching memory for:[/bold] '{query}'")
-        if pattern_type:
-            console.print(f"[dim]Pattern type: {pattern_type}[/dim]")
-        console.print()
-
-        # Initialize memory
-        memory = UnifiedMemory(user_id=user_id)
-
-        # Search
-        results = memory.search_patterns(
-            query=query,
-            pattern_type=pattern_type,
-            limit=limit,
-        )
-
-        if not results:
-            console.print("[yellow]No matching patterns found.[/yellow]\n")
-            return
-
-        # Display results
-        console.print(f"[green]Found {len(results)} matching pattern(s):[/green]\n")
-
-        for i, pattern in enumerate(results, 1):
-            panel = Panel(
-                f"[bold]Pattern ID:[/bold] {pattern.get('pattern_id', 'N/A')}\n"
-                f"[bold]Type:[/bold] {pattern.get('pattern_type', 'N/A')}\n"
-                f"[bold]Classification:[/bold] {pattern.get('classification', 'N/A')}\n\n"
-                f"[bold]Content:[/bold]\n{str(pattern.get('content', 'N/A'))[:200]}...\n\n"
-                f"[bold]Metadata:[/bold] {pattern.get('metadata', {})}",
-                title=f"Result {i}/{len(results)}",
-                border_style="blue",
-            )
-            console.print(panel)
-            console.print()
-
-    except ImportError:
-        console.print(
-            "[red]Error:[/red] UnifiedMemory not available. Ensure memory module is installed."
-        )
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(f"[red]Error:[/red] {e}")
-        raise typer.Exit(code=1)
-
-
-# =============================================================================
-# Session Context Commands
-# =============================================================================
-
-
-
-@meta_workflow_app.command("session-stats")
-def show_session_stats(
-    session_id: str | None = typer.Option(
-        None,
-        "--session-id",
-        "-s",
-        help="Session ID (optional, creates new if not specified)",
-    ),
-    user_id: str = typer.Option(
-        "cli_user",
-        "--user-id",
-        "-u",
-        help="User ID for session",
-    ),
-):
-    """Show session context statistics.
-
-    Displays information about user's session including:
-    - Recent form choices
-    - Templates used
-    - Choice counts
-
-    Examples:
-        empathy meta-workflow session-stats
-        empathy meta-workflow session-stats --session-id sess_123
-    """
-    try:
-        from empathy_os.memory.unified import UnifiedMemory
-        from empathy_os.meta_workflows.session_context import SessionContext
-
-        # Initialize memory and session
-        memory = UnifiedMemory(user_id=user_id)
-        session = SessionContext(
-            memory=memory,
-            session_id=session_id,
-        )
-
-        console.print("\n[bold]Session Statistics[/bold]")
-        console.print(f"[dim]Session ID: {session.session_id}[/dim]")
-        console.print(f"[dim]User ID: {session.user_id}[/dim]\n")
-
-        # Get stats
-        stats = session.get_session_stats()
-
-        # Display
-        table = Table(show_header=True)
-        table.add_column("Metric", style="cyan")
-        table.add_column("Value")
-
-        table.add_row("Total Choices", str(stats.get("choice_count", 0)))
-        table.add_row("Templates Used", str(len(stats.get("templates_used", []))))
-        table.add_row("Most Recent Choice", stats.get("most_recent_choice_timestamp", "N/A"))
-
-        console.print(table)
-        console.print()
-
-        # Show templates used
-        templates = stats.get("templates_used", [])
-        if templates:
-            console.print("[bold]Templates Used:[/bold]")
-            for template_id in templates:
-                console.print(f"  • {template_id}")
-            console.print()
-
-    except ImportError:
-        console.print(
-            "[red]Error:[/red] Session context not available. "
-            "Ensure memory and session modules are installed."
-        )
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(f"[red]Error:[/red] {e}")
-        raise typer.Exit(code=1)
-
-
-

empathy_os/meta_workflows/cli_commands/template_commands.py

@@ -1,354 +0,0 @@
-"""CLI Template Commands.
-
-Template Commands for meta-workflow system.
-
-Copyright 2025 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-from pathlib import Path
-
-import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.tree import Tree
-
-from empathy_os.config import _validate_file_path
-from empathy_os.meta_workflows import (
-    TemplateRegistry,
-)
-
-from . import meta_workflow_app
-
-console = Console()
-
-
-@meta_workflow_app.command("list-templates")
-def list_templates(
-    storage_dir: str = typer.Option(
-        ".empathy/meta_workflows/templates",
-        "--storage-dir",
-        "-d",
-        help="Templates storage directory",
-    ),
-):
-    """List all available workflow templates.
-
-    Shows template metadata including:
-    - Template ID and name
-    - Description
-    - Estimated cost range
-    - Number of questions and agent rules
-    """
-    try:
-        registry = TemplateRegistry(storage_dir=storage_dir)
-        template_ids = registry.list_templates()
-
-        if not template_ids:
-            console.print("[yellow]No templates found.[/yellow]")
-            console.print(f"\nLooking in: {storage_dir}")
-            console.print("\nCreate templates by running workflow workflow or")
-            console.print("placing template JSON files in the templates directory.")
-            return
-
-        # Count built-in vs user templates
-        builtin_count = sum(1 for t in template_ids if registry.is_builtin(t))
-        user_count = len(template_ids) - builtin_count
-
-        console.print(f"\n[bold]Available Templates[/bold] ({len(template_ids)} total)")
-        console.print(
-            f"  [cyan]📦 Built-in:[/cyan] {builtin_count}  [green]👤 User:[/green] {user_count}\n"
-        )
-
-        # Show migration hint for users coming from Crew workflows
-        if builtin_count > 0:
-            console.print(
-                "[dim]💡 Tip: Built-in templates replace deprecated Crew workflows.[/dim]"
-            )
-            console.print("[dim]   See: empathy meta-workflow migrate --help[/dim]\n")
-
-        for template_id in template_ids:
-            template = registry.load_template(template_id)
-
-            if template:
-                # Add badge for built-in templates
-                is_builtin = registry.is_builtin(template_id)
-                badge = "[cyan]📦 BUILT-IN[/cyan]" if is_builtin else "[green]👤 USER[/green]"
-
-                # Create info panel
-                info_lines = [
-                    f"[bold]{template.name}[/bold] {badge}",
-                    f"[dim]{template.description}[/dim]",
-                    "",
-                    f"ID: {template.template_id}",
-                    f"Version: {template.version}",
-                    f"Author: {template.author}",
-                    f"Tags: {', '.join(template.tags)}",
-                    "",
-                    f"Questions: {len(template.form_schema.questions)}",
-                    f"Agent Rules: {len(template.agent_composition_rules)}",
-                    "",
-                    f"Est. Cost: ${template.estimated_cost_range[0]:.2f}-${template.estimated_cost_range[1]:.2f}",
-                    f"Est. Duration: ~{template.estimated_duration_minutes} min",
-                ]
-
-                # Add quick start command
-                info_lines.append("")
-                info_lines.append(
-                    f"[bold]Quick Start:[/bold] empathy meta-workflow run {template_id}"
-                )
-
-                console.print(
-                    Panel("\n".join(info_lines), border_style="blue" if is_builtin else "green")
-                )
-                console.print()
-
-    except Exception as e:
-        console.print(f"[red]Error:[/red] {e}")
-        raise typer.Exit(code=1)
-
-
-
-@meta_workflow_app.command("inspect")
-def inspect_template(
-    template_id: str = typer.Argument(..., help="Template ID to inspect"),
-    storage_dir: str = typer.Option(
-        ".empathy/meta_workflows/templates",
-        "--storage-dir",
-        "-d",
-        help="Templates storage directory",
-    ),
-    show_rules: bool = typer.Option(
-        False,
-        "--show-rules",
-        "-r",
-        help="Show agent composition rules",
-    ),
-):
-    """Inspect a specific template in detail.
-
-    Shows comprehensive template information including:
-    - Form questions and types
-    - Agent composition rules (optional)
-    - Configuration mappings
-    """
-    try:
-        registry = TemplateRegistry(storage_dir=storage_dir)
-        template = registry.load_template(template_id)
-
-        if not template:
-            console.print(f"[red]Template not found:[/red] {template_id}")
-            raise typer.Exit(code=1)
-
-        # Header
-        console.print(f"\n[bold cyan]Template: {template.name}[/bold cyan]")
-        console.print(f"[dim]{template.description}[/dim]\n")
-
-        # Form Schema
-        console.print("[bold]Form Questions:[/bold]")
-        form_tree = Tree("📋 Questions")
-
-        for i, question in enumerate(template.form_schema.questions, 1):
-            question_text = f"[cyan]{question.text}[/cyan]"
-            q_node = form_tree.add(f"{i}. {question_text}")
-            q_node.add(f"ID: {question.id}")
-            q_node.add(f"Type: {question.type.value}")
-            if question.options:
-                options_str = ", ".join(question.options[:3])
-                if len(question.options) > 3:
-                    options_str += f", ... ({len(question.options) - 3} more)"
-                q_node.add(f"Options: {options_str}")
-            if question.required:
-                q_node.add("[yellow]Required[/yellow]")
-            if question.default:
-                q_node.add(f"Default: {question.default}")
-
-        console.print(form_tree)
-
-        # Agent Composition Rules (optional)
-        if show_rules:
-            console.print(
-                f"\n[bold]Agent Composition Rules:[/bold] ({len(template.agent_composition_rules)})\n"
-            )
-
-            for i, rule in enumerate(template.agent_composition_rules, 1):
-                rule_lines = [
-                    f"[bold cyan]{i}. {rule.role}[/bold cyan]",
-                    f"   Base Template: {rule.base_template}",
-                    f"   Tier Strategy: {rule.tier_strategy.value}",
-                    f"   Tools: {', '.join(rule.tools) if rule.tools else 'None'}",
-                ]
-
-                if rule.required_responses:
-                    rule_lines.append(f"   Required When: {rule.required_responses}")
-
-                if rule.config_mapping:
-                    rule_lines.append(f"   Config Mapping: {len(rule.config_mapping)} fields")
-
-                console.print("\n".join(rule_lines))
-                console.print()
-
-        # Summary
-        console.print("\n[bold]Summary:[/bold]")
-        console.print(f"  Questions: {len(template.form_schema.questions)}")
-        console.print(f"  Agent Rules: {len(template.agent_composition_rules)}")
-        console.print(
-            f"  Estimated Cost: ${template.estimated_cost_range[0]:.2f}-${template.estimated_cost_range[1]:.2f}"
-        )
-        console.print()
-
-    except Exception as e:
-        console.print(f"[red]Error:[/red] {e}")
-        raise typer.Exit(code=1)
-
-
-# =============================================================================
-# Plan Generation Commands (Claude Code Integration)
-# =============================================================================
-
-
-
-@meta_workflow_app.command("plan")
-def generate_plan_cmd(
-    template_id: str = typer.Argument(..., help="Template ID to generate plan for"),
-    output_format: str = typer.Option(
-        "markdown",
-        "--format",
-        "-f",
-        help="Output format: markdown, skill, or json",
-    ),
-    output_file: str = typer.Option(
-        None,
-        "--output",
-        "-o",
-        help="Output file path (default: stdout)",
-    ),
-    use_defaults: bool = typer.Option(
-        True,
-        "--use-defaults/--interactive",
-        help="Use default values or ask interactively",
-    ),
-    install_skill: bool = typer.Option(
-        False,
-        "--install",
-        "-i",
-        help="Install as Claude Code skill in .claude/commands/",
-    ),
-):
-    """Generate execution plan for Claude Code (no API costs).
-
-    This generates a plan that can be executed by Claude Code using your
-    Max subscription instead of making API calls.
-
-    Output formats:
-    - markdown: Human-readable plan to paste into Claude Code
-    - skill: Claude Code skill format for .claude/commands/
-    - json: Structured format for programmatic use
-
-    Examples:
-        empathy meta-workflow plan release-prep
-        empathy meta-workflow plan release-prep --format skill --install
-        empathy meta-workflow plan test-coverage-boost -o plan.md
-        empathy meta-workflow plan manage-docs --format json
-    """
-    try:
-        from empathy_os.meta_workflows.plan_generator import generate_plan
-
-        # Load template
-        console.print(f"\n[bold]Generating plan for:[/bold] {template_id}")
-        registry = TemplateRegistry()
-        template = registry.load_template(template_id)
-
-        if not template:
-            console.print(f"[red]Template not found:[/red] {template_id}")
-            raise typer.Exit(code=1)
-
-        # Collect responses if interactive
-        form_responses = None
-        if not use_defaults and template.form_schema.questions:
-            console.print("\n[bold]Configuration:[/bold]")
-            form_responses = {}
-            for question in template.form_schema.questions:
-                if question.options:
-                    # Multiple choice
-                    console.print(f"\n{question.text}")
-                    for i, opt in enumerate(question.options, 1):
-                        default_mark = " (default)" if opt == question.default else ""
-                        console.print(f"  {i}. {opt}{default_mark}")
-                    choice = typer.prompt("Choice", default="1")
-                    try:
-                        idx = int(choice) - 1
-                        form_responses[question.id] = question.options[idx]
-                    except (ValueError, IndexError):
-                        form_responses[question.id] = question.default or question.options[0]
-                else:
-                    # Yes/No or text
-                    default = question.default or "Yes"
-                    response = typer.prompt(question.text, default=default)
-                    form_responses[question.id] = response
-
-        # Generate plan
-        plan_content = generate_plan(
-            template_id=template_id,
-            form_responses=form_responses,
-            use_defaults=use_defaults,
-            output_format=output_format,
-        )
-
-        # Handle output
-        if install_skill:
-            # Install as Claude Code skill
-            skill_dir = Path(".claude/commands")
-            skill_dir.mkdir(parents=True, exist_ok=True)
-            skill_path = skill_dir / f"{template_id}.md"
-
-            # Convert to skill format if not already
-            if output_format != "skill":
-                plan_content = generate_plan(
-                    template_id=template_id,
-                    form_responses=form_responses,
-                    use_defaults=use_defaults,
-                    output_format="skill",
-                )
-
-            validated_skill_path = _validate_file_path(str(skill_path))
-            validated_skill_path.write_text(plan_content)
-            console.print(
-                f"\n[green]✓ Installed as Claude Code skill:[/green] {validated_skill_path}"
-            )
-            console.print(f"\nRun with: [bold]/project:{template_id}[/bold]")
-
-        elif output_file:
-            # Write to file
-            validated_output = _validate_file_path(output_file)
-            validated_output.write_text(plan_content)
-            console.print(f"\n[green]✓ Plan saved to:[/green] {validated_output}")
-
-        else:
-            # Print to stdout
-            console.print("\n" + "=" * 60)
-            console.print(plan_content)
-            console.print("=" * 60)
-
-        # Show usage hints
-        console.print("\n[bold]Usage Options:[/bold]")
-        console.print("1. Copy prompts into Claude Code conversation")
-        console.print("2. Install as skill with: --install")
-        console.print("3. Use with Claude Code Task tool")
-        console.print("\n[dim]Cost: $0 (uses your Max subscription)[/dim]")
-
-    except ImportError:
-        console.print("[red]Plan generator not available.[/red]")
-        console.print("This feature requires the plan_generator module.")
-        raise typer.Exit(code=1)
-    except Exception as e:
-        console.print(f"[red]Error generating plan:[/red] {e}")
-        raise typer.Exit(code=1)
-
-
-# =============================================================================
-# Execution Commands
-# =============================================================================
-
-
-