empathy-framework 3.2.3__py3-none-any.whl → 3.8.2__py3-none-any.whl

empathy_os/cli_unified.py

@@ -1,5 +1,4 @@
-"""
-Unified CLI for Empathy Framework
+"""Unified CLI for Empathy Framework
 
 A single entry point for all Empathy Framework commands using Typer.
 
@@ -60,8 +59,7 @@ def callback(
         help="Show version and exit",
     ),
 ):
-    """
-    Empathy Framework - Predictive AI-Developer Collaboration
+    """Empathy Framework - Predictive AI-Developer Collaboration
 
     The AI collaboration framework that predicts problems before they happen.
 
@@ -82,7 +80,6 @@ def callback(
         empathy scan .          Scan codebase for issues
         empathy inspect .       Deep inspection with SARIF output
     """
-    pass
 
 
 # =============================================================================
@@ -97,31 +94,33 @@ app.add_typer(memory_app, name="memory")
 def memory_status():
     """Check memory system status (Redis, patterns, stats)."""
     # Delegate to the existing CLI
-    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "status"])
+    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "status"], check=False)
 
 
 @memory_app.command("start")
 def memory_start():
     """Start Redis server for short-term memory."""
-    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "start"])
+    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "start"], check=False)
 
 
 @memory_app.command("stop")
 def memory_stop():
     """Stop Redis server."""
-    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "stop"])
+    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "stop"], check=False)
 
 
 @memory_app.command("stats")
 def memory_stats():
     """Show memory statistics."""
-    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "stats"])
+    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "stats"], check=False)
 
 
 @memory_app.command("patterns")
 def memory_patterns():
     """List stored patterns."""
-    subprocess.run([sys.executable, "-m", "empathy_os.memory.control_panel", "patterns", "--list"])
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.memory.control_panel", "patterns", "--list"], check=False
+    )
 
 
 # =============================================================================
@@ -136,7 +135,10 @@ app.add_typer(provider_app, name="provider")
 def provider_show(
     ctx: typer.Context,
     set_provider: str | None = typer.Option(
-        None, "--set", "-s", help="Set provider (anthropic, openai, ollama, hybrid)"
+        None,
+        "--set",
+        "-s",
+        help="Set provider (anthropic, openai, google, ollama, hybrid)",
     ),
     interactive: bool = typer.Option(False, "--interactive", "-i", help="Interactive setup wizard"),
     format_out: str = typer.Option("table", "--format", "-f", help="Output format (table, json)"),
@@ -153,7 +155,7 @@ def provider_show(
     if format_out != "table":
         args.extend(["-f", format_out])
 
-    subprocess.run(args)
+    subprocess.run(args, check=False)
 
 
 @provider_app.command("registry")
@@ -164,7 +166,7 @@ def provider_registry(
     args = [sys.executable, "-m", "empathy_os.models.cli", "registry"]
     if provider_filter:
         args.extend(["--provider", provider_filter])
-    subprocess.run(args)
+    subprocess.run(args, check=False)
 
 
 @provider_app.command("costs")
@@ -183,7 +185,8 @@ def provider_costs(
             str(input_tokens),
             "--output-tokens",
             str(output_tokens),
-        ]
+        ],
+        check=False,
     )
 
 
@@ -201,7 +204,7 @@ def provider_telemetry(
         args.append("--costs")
     if providers:
         args.append("--providers")
-    subprocess.run(args)
+    subprocess.run(args, check=False)
 
 
 # =============================================================================
@@ -211,9 +214,12 @@ def provider_telemetry(
 
 @app.command("scan")
 def scan(
-    path: Path = typer.Argument(Path("."), help="Path to scan"),
+    path: Path = typer.Argument(Path(), help="Path to scan"),
     format_out: str = typer.Option(
-        "text", "--format", "-f", help="Output format (text, json, sarif)"
+        "text",
+        "--format",
+        "-f",
+        help="Output format (text, json, sarif)",
     ),
     fix: bool = typer.Option(False, "--fix", help="Auto-fix safe issues"),
     staged: bool = typer.Option(False, "--staged", help="Only scan staged changes"),
@@ -227,7 +233,7 @@ def scan(
     if staged:
         args.append("--staged")
 
-    result = subprocess.run(args, capture_output=False)
+    result = subprocess.run(args, check=False, capture_output=False)
     if result.returncode != 0:
         console.print("[yellow]Note: empathy-scan may not be installed[/yellow]")
         console.print("Install with: pip install empathy-framework[software]")
@@ -240,9 +246,12 @@ def scan(
 
 @app.command("inspect")
 def inspect_cmd(
-    path: Path = typer.Argument(Path("."), help="Path to inspect"),
+    path: Path = typer.Argument(Path(), help="Path to inspect"),
     format_out: str = typer.Option(
-        "text", "--format", "-f", help="Output format (text, json, sarif)"
+        "text",
+        "--format",
+        "-f",
+        help="Output format (text, json, sarif)",
     ),
 ):
     """Deep inspection with code analysis."""
@@ -250,7 +259,7 @@ def inspect_cmd(
     if format_out != "text":
         args.extend(["--format", format_out])
 
-    result = subprocess.run(args, capture_output=False)
+    result = subprocess.run(args, check=False, capture_output=False)
     if result.returncode != 0:
         console.print("[yellow]Note: empathy-inspect may not be installed[/yellow]")
         console.print("Install with: pip install empathy-framework[software]")
@@ -264,11 +273,14 @@ def inspect_cmd(
 @app.command("sync-claude")
 def sync_claude(
     source: str = typer.Option(
-        "patterns", "--source", "-s", help="Source to sync (patterns, bugs)"
+        "patterns",
+        "--source",
+        "-s",
+        help="Source to sync (patterns, bugs)",
     ),
 ):
     """Sync patterns to Claude Code memory."""
-    subprocess.run(["empathy-sync-claude", "--source", source])
+    subprocess.run(["empathy-sync-claude", "--source", source], check=False)
 
 
 # =============================================================================
@@ -279,13 +291,24 @@ def sync_claude(
 @app.command("morning")
 def morning():
     """Start-of-day briefing with patterns, git context, and priorities."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "morning"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "morning"], check=False)
 
 
 @app.command("ship")
-def ship():
+def ship(
+    tests_only: bool = typer.Option(False, "--tests-only", help="Run tests only"),
+    security_only: bool = typer.Option(False, "--security-only", help="Run security checks only"),
+    skip_sync: bool = typer.Option(False, "--skip-sync", help="Skip Claude sync"),
+):
     """Pre-commit validation (lint, format, tests, security)."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "ship"])
+    args = [sys.executable, "-m", "empathy_os.cli", "ship"]
+    if tests_only:
+        args.append("--tests-only")
+    if security_only:
+        args.append("--security-only")
+    if skip_sync:
+        args.append("--skip-sync")
+    subprocess.run(args, check=False)
 
 
 @app.command("health")
@@ -299,13 +322,13 @@ def health(
         args.append("--deep")
     if fix:
         args.append("--fix")
-    subprocess.run(args)
+    subprocess.run(args, check=False)
 
 
 @app.command("fix-all")
 def fix_all():
     """Fix all lint and format issues."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "fix-all"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "fix-all"], check=False)
 
 
 @app.command("learn")
@@ -313,13 +336,15 @@ def learn(
     analyze: int = typer.Option(20, "--analyze", "-a", help="Number of commits to analyze"),
 ):
     """Learn patterns from commit history."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "learn", "--analyze", str(analyze)])
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.cli", "learn", "--analyze", str(analyze)], check=False
+    )
 
 
 @app.command("run")
 def run_repl():
     """Start interactive REPL mode."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "run"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "run"], check=False)
 
 
 # =============================================================================
@@ -333,18 +358,90 @@ app.add_typer(wizard_app, name="wizard")
 @wizard_app.command("list")
 def wizard_list():
     """List all available wizards."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "frameworks"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "frameworks"], check=False)
 
 
 @wizard_app.command("run")
 def wizard_run(
     name: str = typer.Argument(..., help="Wizard name to run"),
-    path: Path = typer.Option(Path("."), "--path", "-p", help="Path to analyze"),
+    path: Path = typer.Option(Path(), "--path", "-p", help="Path to analyze"),
 ):
     """Run a specific wizard on your codebase."""
     console.print(f"[yellow]Running wizard:[/yellow] {name} on {path}")
     # Delegate to empathy-scan with wizard filter
-    subprocess.run(["empathy-scan", str(path), "--wizards", name])
+    subprocess.run(["empathy-scan", str(path), "--wizards", name], check=False)
+
+
+@wizard_app.command("create")
+def wizard_create(
+    name: str = typer.Argument(..., help="Wizard name (snake_case)"),
+    domain: str = typer.Option(
+        ..., "--domain", "-d", help="Domain (healthcare, finance, software)"
+    ),
+    wizard_type: str = typer.Option(
+        "domain", "--type", "-t", help="Wizard type (domain, coach, ai)"
+    ),
+    methodology: str = typer.Option(
+        "pattern", "--methodology", "-m", help="Methodology (pattern, tdd)"
+    ),
+    patterns: str | None = typer.Option(
+        None, "--patterns", "-p", help="Comma-separated pattern IDs"
+    ),
+    interactive: bool = typer.Option(
+        False, "--interactive", "-i", help="Interactive pattern selection"
+    ),
+):
+    """Create a new wizard using Wizard Factory (12x faster)."""
+    cmd = [
+        sys.executable,
+        "-m",
+        "scaffolding",
+        "create",
+        name,
+        "--domain",
+        domain,
+        "--type",
+        wizard_type,
+        "--methodology",
+        methodology,
+    ]
+    if patterns:
+        cmd.extend(["--patterns", patterns])
+    if interactive:
+        cmd.append("--interactive")
+    subprocess.run(cmd, check=False)
+
+
+@wizard_app.command("list-patterns")
+def wizard_list_patterns():
+    """List all available wizard patterns."""
+    subprocess.run([sys.executable, "-m", "scaffolding", "list-patterns"], check=False)
+
+
+@wizard_app.command("generate-tests")
+def wizard_generate_tests(
+    wizard_id: str = typer.Argument(..., help="Wizard ID"),
+    patterns: str = typer.Option(..., "--patterns", "-p", help="Comma-separated pattern IDs"),
+    output: Path | None = typer.Option(None, "--output", "-o", help="Output directory"),
+):
+    """Generate tests for a wizard."""
+    cmd = [sys.executable, "-m", "test_generator", "generate", wizard_id, "--patterns", patterns]
+    if output:
+        cmd.extend(["--output", str(output)])
+    subprocess.run(cmd, check=False)
+
+
+@wizard_app.command("analyze")
+def wizard_analyze(
+    wizard_id: str = typer.Argument(..., help="Wizard ID"),
+    patterns: str = typer.Option(..., "--patterns", "-p", help="Wizard ID"),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON format"),
+):
+    """Analyze wizard risk and get coverage recommendations."""
+    cmd = [sys.executable, "-m", "test_generator", "analyze", wizard_id, "--patterns", patterns]
+    if json_output:
+        cmd.append("--json")
+    subprocess.run(cmd, check=False)
 
 
 # =============================================================================
@@ -358,16 +455,62 @@ app.add_typer(workflow_app, name="workflow")
 @workflow_app.command("list")
 def workflow_list():
     """List available multi-model workflows."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "workflow", "list"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "workflow", "list"], check=False)
 
 
 @workflow_app.command("run")
 def workflow_run(
     name: str = typer.Argument(..., help="Workflow name"),
-    path: Path = typer.Option(Path("."), "--path", "-p", help="Path to run on"),
+    path: Path = typer.Option(Path(), "--path", "-p", help="Path to run on"),
 ):
     """Run a multi-model workflow."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "workflow", "run", name, str(path)])
+    subprocess.run(
+        [sys.executable, "-m", "empathy_os.cli", "workflow", "run", name, str(path)], check=False
+    )
+
+
+@workflow_app.command("create")
+def workflow_create(
+    name: str = typer.Argument(..., help="Workflow name (kebab-case, e.g., bug-scanner)"),
+    description: str = typer.Option(None, "--description", "-d", help="Workflow description"),
+    patterns: str = typer.Option(None, "--patterns", "-p", help="Comma-separated pattern IDs"),
+    stages: str = typer.Option(None, "--stages", "-s", help="Comma-separated stage names"),
+    tier_map: str = typer.Option(
+        None, "--tier-map", "-t", help="Tier map (e.g., analyze:CHEAP,process:CAPABLE)"
+    ),
+    output: Path = typer.Option(None, "--output", "-o", help="Output directory"),
+):
+    """Create a new workflow using Workflow Factory (12x faster)."""
+    cmd = [sys.executable, "-m", "workflow_scaffolding", "create", name]
+    if description:
+        cmd.extend(["--description", description])
+    if patterns:
+        cmd.extend(["--patterns", patterns])
+    if stages:
+        cmd.extend(["--stages", stages])
+    if tier_map:
+        cmd.extend(["--tier-map", tier_map])
+    if output:
+        cmd.extend(["--output", str(output)])
+    subprocess.run(cmd, check=False)
+
+
+@workflow_app.command("list-patterns")
+def workflow_list_patterns():
+    """List available workflow patterns."""
+    subprocess.run([sys.executable, "-m", "workflow_scaffolding", "list-patterns"], check=False)
+
+
+@workflow_app.command("recommend")
+def workflow_recommend(
+    workflow_type: str = typer.Argument(
+        ..., help="Workflow type (code-analysis, simple, multi-agent, etc.)"
+    ),
+):
+    """Recommend patterns for a workflow type."""
+    subprocess.run(
+        [sys.executable, "-m", "workflow_scaffolding", "recommend", workflow_type], check=False
+    )
 
 
 # =============================================================================
@@ -408,37 +551,41 @@ def cheatsheet():
 [bold]Workflows[/bold]
   empathy workflow list     Show available workflows
   empathy workflow run <name>   Execute a workflow
+  empathy workflow create <name> -p <patterns>  Create workflow (12x faster)
+  empathy workflow list-patterns                List available patterns
 
 [bold]Wizards[/bold]
   empathy wizard list       Show available wizards
-  empathy wizard run <name> Execute a wizard""",
+  empathy wizard run <name> Execute a wizard
+  empathy wizard create <name> -d <domain>  Create wizard (12x faster)
+  empathy wizard list-patterns              List available patterns""",
             title="[bold blue]Empathy Framework Cheatsheet[/bold blue]",
-        )
+        ),
     )
 
 
 @app.command("dashboard")
 def dashboard():
     """Launch visual dashboard."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "dashboard"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "dashboard"], check=False)
 
 
 @app.command("costs")
 def costs():
     """View API cost tracking."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "costs"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "costs"], check=False)
 
 
 @app.command("init")
 def init():
     """Create a new configuration file."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "init"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "init"], check=False)
 
 
 @app.command("status")
 def status():
     """What needs attention now."""
-    subprocess.run([sys.executable, "-m", "empathy_os.cli", "status"])
+    subprocess.run([sys.executable, "-m", "empathy_os.cli", "status"], check=False)
 
 
 def main():

empathy_os/config/__init__.py

@@ -0,0 +1,63 @@
+"""Configuration management for Empathy Framework.
+
+This package provides:
+1. Original EmpathyConfig (backward compatible)
+2. XML enhancement configurations (new)
+
+Copyright 2026 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+# Import original config from parent module's config.py for backward compatibility
+import importlib.util
+import sys
+from pathlib import Path
+
+# Check if PyYAML is available
+try:
+    import yaml  # noqa: F401
+
+    YAML_AVAILABLE = True
+except ImportError:
+    YAML_AVAILABLE = False
+
+# Load the original config.py module directly
+config_py_path = Path(__file__).parent.parent / "config.py"
+spec = importlib.util.spec_from_file_location("empathy_os_config_legacy", config_py_path)
+if spec and spec.loader:
+    legacy_config = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(legacy_config)
+    EmpathyConfig = legacy_config.EmpathyConfig
+    load_config = legacy_config.load_config
+else:
+    # Fallback if import fails
+    EmpathyConfig = None
+    load_config = None
+
+# Import XML enhancement configs
+from empathy_os.config.xml_config import (  # noqa: E402
+    AdaptiveConfig,
+    EmpathyXMLConfig,
+    I18nConfig,
+    MetricsConfig,
+    OptimizationConfig,
+    XMLConfig,
+    get_config,
+    set_config,
+)
+
+__all__ = [
+    # Original config (backward compatible)
+    "EmpathyConfig",
+    "load_config",
+    "YAML_AVAILABLE",
+    # XML enhancement configs
+    "XMLConfig",
+    "OptimizationConfig",
+    "AdaptiveConfig",
+    "I18nConfig",
+    "MetricsConfig",
+    "EmpathyXMLConfig",
+    "get_config",
+    "set_config",
+]