empathy-framework 4.6.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

empathy_os/routing/classifier.py

@@ -1,7 +1,7 @@
 """LLM-based Request Classifier
 
 Uses a cheap model (Haiku) to classify developer requests
-and route them to appropriate wizard(s).
+and route them to appropriate workflow(s).
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -12,15 +12,15 @@ import os
 from dataclasses import dataclass, field
 from typing import Any
 
-from .wizard_registry import WizardRegistry
+from .workflow_registry import WorkflowRegistry
 
 
 @dataclass
 class ClassificationResult:
     """Result of classifying a developer request."""
 
-    primary_wizard: str
-    secondary_wizards: list[str] = field(default_factory=list)
+    primary_workflow: str
+    secondary_workflows: list[str] = field(default_factory=list)
     confidence: float = 0.0
     reasoning: str = ""
     suggested_chain: list[str] = field(default_factory=list)
@@ -28,7 +28,7 @@ class ClassificationResult:
 
 
 class HaikuClassifier:
-    """Uses Claude Haiku to classify requests to wizards.
+    """Uses Claude Haiku to classify requests to workflows.
 
     Why Haiku:
     - Cheapest tier model
@@ -46,7 +46,7 @@ class HaikuClassifier:
         """
         self._api_key = api_key or os.getenv("ANTHROPIC_API_KEY")
         self._client = None
-        self._registry = WizardRegistry()
+        self._registry = WorkflowRegistry()
 
     def _get_client(self):
         """Lazy-load the Anthropic client."""
@@ -63,41 +63,41 @@ class HaikuClassifier:
         self,
         request: str,
         context: dict[str, Any] | None = None,
-        available_wizards: dict[str, str] | None = None,
+        available_workflows: dict[str, str] | None = None,
     ) -> ClassificationResult:
-        """Classify a developer request and determine which wizard(s) to invoke.
+        """Classify a developer request and determine which workflow(s) to invoke.
 
         Args:
             request: The developer's natural language request
             context: Optional context (current file, project type, etc.)
-            available_wizards: Override for available wizard descriptions
+            available_workflows: Override for available workflow descriptions
 
         Returns:
-            ClassificationResult with primary and secondary wizard recommendations
+            ClassificationResult with primary and secondary workflow recommendations
 
         """
-        if available_wizards is None:
-            available_wizards = self._registry.get_descriptions_for_classification()
+        if available_workflows is None:
+            available_workflows = self._registry.get_descriptions_for_classification()
 
         # Build classification prompt
-        wizard_list = "\n".join(f"- {name}: {desc}" for name, desc in available_wizards.items())
+        workflow_list = "\n".join(f"- {name}: {desc}" for name, desc in available_workflows.items())
 
         context_str = ""
         if context:
             context_str = f"\n\nContext:\n{json.dumps(context, indent=2)}"
 
-        system_prompt = """You are a request router that classifies requests to the appropriate wizard.
+        system_prompt = """You are a request router that classifies requests to the appropriate workflow.
 
 Analyze the request and determine:
-1. The PRIMARY wizard that best handles this request
-2. Any SECONDARY wizards that could provide additional value
+1. The PRIMARY workflow that best handles this request
+2. Any SECONDARY workflows that could provide additional value
 3. Your confidence level (0.0 - 1.0)
 4. Brief reasoning for your choice
 
 Respond in JSON format:
 {
-    "primary_wizard": "wizard-name",
-    "secondary_wizards": ["wizard-name-2"],
+    "primary_workflow": "workflow-name",
+    "secondary_workflows": ["workflow-name-2"],
     "confidence": 0.85,
     "reasoning": "Brief explanation",
     "extracted_context": {
@@ -106,8 +106,8 @@ Respond in JSON format:
     }
 }"""
 
-        user_prompt = f"""Available wizards:
-{wizard_list}
+        user_prompt = f"""Available workflows:
+{workflow_list}
 
 Developer request: "{request}"{context_str}
 
@@ -136,8 +136,8 @@ Classify this request."""
 
                     data = json.loads(content.strip())
                     return ClassificationResult(
-                        primary_wizard=data.get("primary_wizard", "code-review"),
-                        secondary_wizards=data.get("secondary_wizards", []),
+                        primary_workflow=data.get("primary_workflow", "code-review"),
+                        secondary_workflows=data.get("secondary_workflows", []),
                         confidence=data.get("confidence", 0.5),
                         reasoning=data.get("reasoning", ""),
                         extracted_context=data.get("extracted_context", {}),
@@ -149,22 +149,22 @@ Classify this request."""
                 print(f"LLM classification error: {e}")
 
         # Fallback to keyword-based classification
-        return self._keyword_classify(request, available_wizards)
+        return self._keyword_classify(request, available_workflows)
 
     def _keyword_classify(
         self,
         request: str,
-        available_wizards: dict[str, str],
+        available_workflows: dict[str, str],
     ) -> ClassificationResult:
         """Fallback keyword-based classification."""
         request_lower = request.lower()
 
-        # Score each wizard based on keyword matches
+        # Score each workflow based on keyword matches
         scores: dict[str, float] = {}
 
-        for wizard in self._registry.list_all():
+        for workflow in self._registry.list_all():
             score = 0.0
-            for keyword in wizard.keywords:
+            for keyword in workflow.keywords:
                 if keyword in request_lower:
                     score += 1.0
                     # Exact word match bonus
@@ -172,25 +172,25 @@ Classify this request."""
                         score += 0.5
 
             if score > 0:
-                scores[wizard.name] = score
+                scores[workflow.name] = score
 
         if not scores:
             # Default to code-review
             return ClassificationResult(
-                primary_wizard="code-review",
+                primary_workflow="code-review",
                 confidence=0.3,
                 reasoning="No keyword matches, defaulting to code-review",
             )
 
         # Sort by score
-        sorted_wizards = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-        primary = sorted_wizards[0][0]
-        primary_score = sorted_wizards[0][1]
+        sorted_workflows = sorted(scores.items(), key=lambda x: x[1], reverse=True)
+        primary = sorted_workflows[0][0]
+        primary_score = sorted_workflows[0][1]
 
         # Get secondary if significantly different
         secondary = []
-        if len(sorted_wizards) > 1:
-            for name, score in sorted_wizards[1:3]:
+        if len(sorted_workflows) > 1:
+            for name, score in sorted_workflows[1:3]:
                 if score >= primary_score * 0.5:
                     secondary.append(name)
 
@@ -199,8 +199,8 @@ Classify this request."""
         confidence = min(primary_score / max_possible, 1.0)
 
         return ClassificationResult(
-            primary_wizard=primary,
-            secondary_wizards=secondary,
+            primary_workflow=primary,
+            secondary_workflows=secondary,
             confidence=confidence,
             reasoning=f"Keyword match score: {primary_score}",
         )

empathy_os/routing/smart_router.py

@@ -1,7 +1,7 @@
 """Smart Router
 
 Intelligent dispatcher that analyzes developer input and routes
-to the appropriate wizard(s) using LLM classification.
+to the appropriate workflow(s) using LLM classification.
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
@@ -11,15 +11,15 @@ from dataclasses import dataclass, field
 from typing import Any
 
 from .classifier import ClassificationResult, HaikuClassifier
-from .wizard_registry import WizardInfo, WizardRegistry
+from .workflow_registry import WorkflowInfo, WorkflowRegistry
 
 
 @dataclass
 class RoutingDecision:
     """Decision from the smart router."""
 
-    primary_wizard: str
-    secondary_wizards: list[str] = field(default_factory=list)
+    primary_workflow: str
+    secondary_workflows: list[str] = field(default_factory=list)
     confidence: float = 0.0
     reasoning: str = ""
     suggested_chain: list[str] = field(default_factory=list)
@@ -31,17 +31,17 @@ class RoutingDecision:
 
 
 class SmartRouter:
-    """Routes developer requests to appropriate wizard(s).
+    """Routes developer requests to appropriate workflow(s).
 
     Uses LLM classification (Haiku) to understand natural language
-    requests and route them to the best wizard(s).
+    requests and route them to the best workflow(s).
 
     Usage:
         router = SmartRouter()
 
         # Async routing (preferred - uses LLM)
         decision = await router.route("Fix the security issue in auth.py")
-        print(f"Primary: {decision.primary_wizard}")
+        print(f"Primary: {decision.primary_workflow}")
         print(f"Confidence: {decision.confidence}")
 
         # Sync routing (keyword fallback)
@@ -55,7 +55,7 @@ class SmartRouter:
             api_key: Optional Anthropic API key for LLM classification
 
         """
-        self._registry = WizardRegistry()
+        self._registry = WorkflowRegistry()
         self._classifier = HaikuClassifier(api_key=api_key)
 
     async def route(
@@ -63,7 +63,7 @@ class SmartRouter:
         request: str,
         context: dict[str, Any] | None = None,
     ) -> RoutingDecision:
-        """Route a request to the appropriate wizard(s).
+        """Route a request to the appropriate workflow(s).
 
         Uses LLM classification for accurate natural language understanding.
 
@@ -72,7 +72,7 @@ class SmartRouter:
             context: Optional context (current file, project info, etc.)
 
         Returns:
-            RoutingDecision with wizard recommendations
+            RoutingDecision with workflow recommendations
 
         """
         # Classify the request
@@ -81,15 +81,15 @@ class SmartRouter:
             context=context,
         )
 
-        # Build suggested chain based on wizard triggers
+        # Build suggested chain based on workflow triggers
         suggested_chain = self._build_chain(classification)
 
         # Merge extracted context
         merged_context = {**(context or {}), **classification.extracted_context}
 
         return RoutingDecision(
-            primary_wizard=classification.primary_wizard,
-            secondary_wizards=classification.secondary_wizards,
+            primary_workflow=classification.primary_workflow,
+            secondary_workflows=classification.secondary_workflows,
             confidence=classification.confidence,
             reasoning=classification.reasoning,
             suggested_chain=suggested_chain,
@@ -112,7 +112,7 @@ class SmartRouter:
             context: Optional context
 
         Returns:
-            RoutingDecision with wizard recommendations
+            RoutingDecision with workflow recommendations
 
         """
         classification = self._classifier.classify_sync(
@@ -123,8 +123,8 @@ class SmartRouter:
         suggested_chain = self._build_chain(classification)
 
         return RoutingDecision(
-            primary_wizard=classification.primary_wizard,
-            secondary_wizards=classification.secondary_wizards,
+            primary_workflow=classification.primary_workflow,
+            secondary_workflows=classification.secondary_workflows,
             confidence=classification.confidence,
             reasoning=classification.reasoning,
             suggested_chain=suggested_chain,
@@ -134,39 +134,39 @@ class SmartRouter:
         )
 
     def _build_chain(self, classification: ClassificationResult) -> list[str]:
-        """Build suggested wizard chain based on triggers."""
-        chain = [classification.primary_wizard]
+        """Build suggested workflow chain based on triggers."""
+        chain = [classification.primary_workflow]
 
-        # Add secondary wizards to chain
-        for secondary in classification.secondary_wizards:
+        # Add secondary workflows to chain
+        for secondary in classification.secondary_workflows:
             if secondary not in chain:
                 chain.append(secondary)
 
-        # Check for auto-chain triggers from primary wizard
-        triggers = self._registry.get_chain_triggers(classification.primary_wizard)
+        # Check for auto-chain triggers from primary workflow
+        triggers = self._registry.get_chain_triggers(classification.primary_workflow)
         for trigger in triggers:
-            next_wizard = trigger.get("next")
-            if next_wizard and next_wizard not in chain:
-                chain.append(next_wizard)
+            next_workflow = trigger.get("next")
+            if next_workflow and next_workflow not in chain:
+                chain.append(next_workflow)
 
         return chain
 
-    def get_wizard_info(self, name: str) -> WizardInfo | None:
-        """Get information about a specific wizard."""
+    def get_workflow_info(self, name: str) -> WorkflowInfo | None:
+        """Get information about a specific workflow."""
         return self._registry.get(name)
 
-    def list_wizards(self) -> list[WizardInfo]:
-        """List all available wizards."""
+    def list_workflows(self) -> list[WorkflowInfo]:
+        """List all available workflows."""
         return self._registry.list_all()
 
     def suggest_for_file(self, file_path: str) -> list[str]:
-        """Suggest wizards based on file type.
+        """Suggest workflows based on file type.
 
         Args:
             file_path: Path to the file
 
         Returns:
-            List of suggested wizard names
+            List of suggested workflow names
 
         """
         suggestions = []
@@ -175,9 +175,9 @@ class SmartRouter:
         ext = "." + file_path.rsplit(".", 1)[-1] if "." in file_path else ""
         filename = file_path.rsplit("/", 1)[-1]
 
-        for wizard in self._registry.list_all():
-            if ext in wizard.handles_file_types or filename in wizard.handles_file_types:
-                suggestions.append(wizard.name)
+        for workflow in self._registry.list_all():
+            if ext in workflow.handles_file_types or filename in workflow.handles_file_types:
+                suggestions.append(workflow.name)
 
         # Default suggestions if no matches
         if not suggestions:
@@ -186,19 +186,19 @@ class SmartRouter:
         return suggestions
 
     def suggest_for_error(self, error_type: str) -> list[str]:
-        """Suggest wizards based on error type.
+        """Suggest workflows based on error type.
 
         Args:
             error_type: Type of error (e.g., "TypeError", "SecurityError")
 
         Returns:
-            List of suggested wizard names
+            List of suggested workflow names
 
         """
         error_lower = error_type.lower()
 
-        # Map error types to wizards
-        error_wizard_map = {
+        # Map error types to workflows
+        error_workflow_map = {
             "security": ["security-audit", "code-review"],
             "type": ["code-review", "bug-predict"],
             "null": ["bug-predict", "test-gen"],
@@ -211,9 +211,9 @@ class SmartRouter:
             "test": ["test-gen", "bug-predict"],
         }
 
-        for keyword, wizards in error_wizard_map.items():
+        for keyword, workflows in error_workflow_map.items():
             if keyword in error_lower:
-                return wizards
+                return workflows
 
         return ["bug-predict", "code-review"]
 

empathy_os/routing/{wizard_registry.py → workflow_registry.py}

@@ -1,6 +1,6 @@
-"""Wizard Registry
+"""Workflow Registry
 
-Central registry of available wizards with their descriptions,
+Central registry of available workflows with their descriptions,
 capabilities, and auto-chain rules.
 
 Copyright 2025 Smart AI Memory, LLC
@@ -13,8 +13,8 @@ from typing import Any
 
 
 @dataclass
-class WizardInfo:
-    """Information about a registered wizard."""
+class WorkflowInfo:
+    """Information about a registered workflow."""
 
     name: str
     description: str
@@ -29,15 +29,15 @@ class WizardInfo:
     auto_chain: bool = False
     chain_triggers: list[dict[str, Any]] = field(default_factory=list)
 
-    # Optional wizard class or factory
-    wizard_class: type | None = None
+    # Optional workflow class or factory
+    workflow_class: type | None = None
     factory: Callable[..., Any] | None = None
 
 
-# Default wizard registry
-WIZARD_REGISTRY: dict[str, WizardInfo] = {
+# Default workflow registry
+WORKFLOW_REGISTRY: dict[str, WorkflowInfo] = {
     # Workflows (cost-optimized pipelines)
-    "security-audit": WizardInfo(
+    "security-audit": WorkflowInfo(
         name="security-audit",
         description="Analyze code for security vulnerabilities, injection risks, compliance",
         keywords=[
@@ -65,7 +65,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
             {"condition": "vulnerability_type == 'injection'", "next": "code-review"},
         ],
     ),
-    "code-review": WizardInfo(
+    "code-review": WorkflowInfo(
         name="code-review",
         description="Review code for quality, best practices, maintainability, and bugs",
         keywords=[
@@ -89,7 +89,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
             {"condition": "has_complexity_issues", "next": "refactor-plan"},
         ],
     ),
-    "bug-predict": WizardInfo(
+    "bug-predict": WorkflowInfo(
         name="bug-predict",
         description="Predict potential bugs based on code patterns and historical data",
         keywords=[
@@ -112,7 +112,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
             {"condition": "risk_score > 0.7", "next": "test-gen"},
         ],
     ),
-    "perf-audit": WizardInfo(
+    "perf-audit": WorkflowInfo(
         name="perf-audit",
         description="Analyze code for performance issues, bottlenecks, optimizations",
         keywords=[
@@ -136,7 +136,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
             {"condition": "hotspot_count > 5", "next": "refactor-plan"},
         ],
     ),
-    "refactor-plan": WizardInfo(
+    "refactor-plan": WorkflowInfo(
         name="refactor-plan",
         description="Plan code refactoring to improve structure, reduce complexity",
         keywords=[
@@ -153,7 +153,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
         primary_domain="architecture",
         auto_chain=False,  # Require approval for refactoring
     ),
-    "test-gen": WizardInfo(
+    "test-gen": WorkflowInfo(
         name="test-gen",
         description="Generate test cases and improve test coverage",
         keywords=[
@@ -175,7 +175,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
             {"condition": "coverage_low", "next": "bug-predict"},
         ],
     ),
-    "doc-gen": WizardInfo(
+    "doc-gen": WorkflowInfo(
         name="doc-gen",
         description="Generate documentation from code including API docs, READMEs, and guides",
         keywords=[
@@ -192,7 +192,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
         primary_domain="documentation",
         auto_chain=False,
     ),
-    "dependency-check": WizardInfo(
+    "dependency-check": WorkflowInfo(
         name="dependency-check",
         description="Audit dependencies for vulnerabilities, updates, and license issues",
         keywords=[
@@ -214,7 +214,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
             {"condition": "critical_vuln_count > 0", "next": "security-audit"},
         ],
     ),
-    "release-prep": WizardInfo(
+    "release-prep": WorkflowInfo(
         name="release-prep",
         description="Pre-release quality gate with health checks, security scan, and changelog",
         keywords=[
@@ -230,7 +230,7 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
         primary_domain="release",
         auto_chain=False,  # Always require approval
     ),
-    "research": WizardInfo(
+    "research": WorkflowInfo(
         name="research",
         description="Research and synthesize information from multiple sources",
         keywords=[
@@ -249,59 +249,59 @@ WIZARD_REGISTRY: dict[str, WizardInfo] = {
 }
 
 
-class WizardRegistry:
-    """Registry for managing available wizards.
+class WorkflowRegistry:
+    """Registry for managing available workflows.
 
     Usage:
-        registry = WizardRegistry()
+        registry = WorkflowRegistry()
         info = registry.get("security-audit")
-        all_wizards = registry.list_all()
+        all_workflows = registry.list_all()
     """
 
     def __init__(self):
-        """Initialize with default wizards."""
-        self._wizards: dict[str, WizardInfo] = dict(WIZARD_REGISTRY)
+        """Initialize with default workflows."""
+        self._workflows: dict[str, WorkflowInfo] = dict(WORKFLOW_REGISTRY)
 
-    def register(self, info: WizardInfo) -> None:
-        """Register a new wizard."""
-        self._wizards[info.name] = info
+    def register(self, info: WorkflowInfo) -> None:
+        """Register a new workflow."""
+        self._workflows[info.name] = info
 
-    def get(self, name: str) -> WizardInfo | None:
-        """Get wizard info by name."""
-        return self._wizards.get(name)
+    def get(self, name: str) -> WorkflowInfo | None:
+        """Get workflow info by name."""
+        return self._workflows.get(name)
 
-    def list_all(self) -> list[WizardInfo]:
-        """List all registered wizards."""
-        return list(self._wizards.values())
+    def list_all(self) -> list[WorkflowInfo]:
+        """List all registered workflows."""
+        return list(self._workflows.values())
 
-    def find_by_domain(self, domain: str) -> list[WizardInfo]:
-        """Find wizards by primary domain."""
-        return [w for w in self._wizards.values() if w.primary_domain == domain]
+    def find_by_domain(self, domain: str) -> list[WorkflowInfo]:
+        """Find workflows by primary domain."""
+        return [w for w in self._workflows.values() if w.primary_domain == domain]
 
-    def find_by_keyword(self, keyword: str) -> list[WizardInfo]:
-        """Find wizards that handle a keyword."""
+    def find_by_keyword(self, keyword: str) -> list[WorkflowInfo]:
+        """Find workflows that handle a keyword."""
         keyword = keyword.lower()
         return [
-            w for w in self._wizards.values() if any(keyword in kw.lower() for kw in w.keywords)
+            w for w in self._workflows.values() if any(keyword in kw.lower() for kw in w.keywords)
         ]
 
     def get_descriptions_for_classification(self) -> dict[str, str]:
-        """Get wizard name to description mapping for LLM classification."""
+        """Get workflow name to description mapping for LLM classification."""
         return {
             name: f"{info.description} (domain: {info.primary_domain})"
-            for name, info in self._wizards.items()
+            for name, info in self._workflows.items()
         }
 
-    def get_chain_triggers(self, wizard_name: str) -> list[dict[str, Any]]:
-        """Get auto-chain triggers for a wizard."""
-        info = self._wizards.get(wizard_name)
+    def get_chain_triggers(self, workflow_name: str) -> list[dict[str, Any]]:
+        """Get auto-chain triggers for a workflow."""
+        info = self._workflows.get(workflow_name)
         if info and info.auto_chain:
             return info.chain_triggers
         return []
 
     def unregister(self, name: str) -> bool:
-        """Remove a wizard from the registry."""
-        if name in self._wizards:
-            del self._wizards[name]
+        """Remove a workflow from the registry."""
+        if name in self._workflows:
+            del self._workflows[name]
             return True
         return False

empathy_os/scaffolding/__init__.py

@@ -1,24 +1,24 @@
-"""Methodology Scaffolding for Wizard Factory.
+"""Methodology Scaffolding for Workflow Factory.
 
-Provides CLI tools and methodologies for creating new wizards quickly
+Provides CLI tools and methodologies for creating new workflows quickly
 using proven patterns.
 
 Methodologies:
-- Pattern-Compose: Select patterns, compose wizard (Recommended)
-- TDD-First: Write tests first, implement wizard
+- Pattern-Compose: Select patterns, compose workflow (Recommended)
+- TDD-First: Write tests first, implement workflow
 - Prototype-Refine: Quick prototype, then refactor
 - Risk-Driven: Focus on high-risk paths first
 - Empathy-Centered: Design for user experience
 
 Usage:
-    # Create wizard using Pattern-Compose (recommended)
-    python -m scaffolding create my_wizard --domain healthcare
+    # Create workflow using Pattern-Compose (recommended)
+    python -m scaffolding create my_workflow --domain healthcare
 
     # Create with specific methodology
-    python -m scaffolding create my_wizard --methodology tdd
+    python -m scaffolding create my_workflow --methodology tdd
 
     # Interactive mode
-    python -m scaffolding create my_wizard --interactive
+    python -m scaffolding create my_workflow --interactive
 
 Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9

empathy_os/scaffolding/__main__.py

@@ -1,7 +1,7 @@
 """Scaffolding module entry point.
 
 Usage:
-    python -m scaffolding create my_wizard --domain healthcare
+    python -m scaffolding create my_workflow --domain healthcare
     python -m scaffolding list-patterns
 
 Copyright 2025 Smart AI Memory, LLC