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

empathy_os/meta_workflows/pattern_learner.py

@@ -56,9 +56,7 @@ class PatternLearner:
                    If provided, insights will be stored in both files and memory
         """
         if executions_dir is None:
-            executions_dir = str(
-                Path.home() / ".empathy" / "meta_workflows" / "executions"
-            )
+            executions_dir = str(Path.home() / ".empathy" / "meta_workflows" / "executions")
         self.executions_dir = Path(executions_dir)
         self.memory = memory
 
@@ -90,9 +88,7 @@ class PatternLearner:
         results = []
         for run_id in run_ids:
             try:
-                result = load_execution_result(
-                    run_id, storage_dir=str(self.executions_dir)
-                )
+                result = load_execution_result(run_id, storage_dir=str(self.executions_dir))
                 if template_id is None or result.template_id == template_id:
                     results.append(result)
             except Exception as e:
@@ -312,9 +308,7 @@ class PatternLearner:
 
         return insights
 
-    def get_recommendations(
-        self, template_id: str, min_confidence: float = 0.7
-    ) -> list[str]:
+    def get_recommendations(self, template_id: str, min_confidence: float = 0.7) -> list[str]:
         """Get actionable recommendations for a template.
 
         Args:
@@ -324,9 +318,7 @@ class PatternLearner:
         Returns:
             List of recommendation strings
         """
-        insights = self.analyze_patterns(
-            template_id=template_id, min_confidence=min_confidence
-        )
+        insights = self.analyze_patterns(template_id=template_id, min_confidence=min_confidence)
 
         recommendations = []
 
@@ -347,9 +339,7 @@ class PatternLearner:
 
             elif insight.insight_type == "cost_analysis":
                 avg_cost = insight.data["average"]
-                recommendations.append(
-                    f"💰 Expected workflow cost: ${avg_cost:.2f}"
-                )
+                recommendations.append(f"💰 Expected workflow cost: ${avg_cost:.2f}")
 
             elif insight.insight_type == "failure_analysis":
                 role = insight.data["role"]
@@ -361,9 +351,7 @@ class PatternLearner:
 
         return recommendations
 
-    def generate_analytics_report(
-        self, template_id: str | None = None
-    ) -> dict[str, Any]:
+    def generate_analytics_report(self, template_id: str | None = None) -> dict[str, Any]:
         """Generate comprehensive analytics report.
 
         Args:
@@ -384,9 +372,7 @@ class PatternLearner:
         results = []
         for run_id in run_ids:
             try:
-                result = load_execution_result(
-                    run_id, storage_dir=str(self.executions_dir)
-                )
+                result = load_execution_result(run_id, storage_dir=str(self.executions_dir))
                 if template_id is None or result.template_id == template_id:
                     results.append(result)
             except Exception:
@@ -412,9 +398,7 @@ class PatternLearner:
                 insight_type: [i.to_dict() for i in insights_list]
                 for insight_type, insights_list in insights_by_type.items()
             },
-            "recommendations": self.get_recommendations(template_id)
-            if template_id
-            else [],
+            "recommendations": self.get_recommendations(template_id) if template_id else [],
         }
 
         return report
@@ -465,7 +449,7 @@ class PatternLearner:
             # Create searchable content
             content = f"""Meta-workflow execution: {result.template_id}
 Run ID: {result.run_id}
-Status: {'SUCCESS' if result.success else 'FAILED'}
+Status: {"SUCCESS" if result.success else "FAILED"}
 Agents created: {len(result.agents_created)}
 Total cost: ${result.total_cost:.2f}
 Duration: {result.total_duration:.1f}s
@@ -574,9 +558,7 @@ Form Responses:
 
                     # Load full result from files
                     try:
-                        result = load_execution_result(
-                            run_id, storage_dir=str(self.executions_dir)
-                        )
+                        result = load_execution_result(run_id, storage_dir=str(self.executions_dir))
                         results.append(result)
                     except FileNotFoundError:
                         logger.warning(f"Result file not found for run_id: {run_id}")
@@ -670,9 +652,9 @@ Form Responses:
 
             # Generate memory-enhanced recommendations
             if similar_executions:
-                success_rate = sum(
-                    1 for e in similar_executions if e.success
-                ) / len(similar_executions)
+                success_rate = sum(1 for e in similar_executions if e.success) / len(
+                    similar_executions
+                )
 
                 if success_rate >= 0.8:
                     base_recs.insert(

empathy_os/meta_workflows/plan_generator.py

@@ -147,9 +147,7 @@ class PlanGenerator:
                 AgentStep(
                     order=order,
                     role=rule.role,
-                    tier_recommendation=self.TIER_TO_MODEL.get(
-                        rule.tier_strategy, "sonnet"
-                    ),
+                    tier_recommendation=self.TIER_TO_MODEL.get(rule.tier_strategy, "sonnet"),
                     tools=rule.tools,
                     prompt=prompt,
                     success_criteria=rule.success_criteria,
@@ -204,7 +202,7 @@ Configuration:
 Success Criteria:
 {criteria}
 
-Tools available: {', '.join(rule.tools)}
+Tools available: {", ".join(rule.tools)}
 
 Provide a structured report with findings, issues by severity, and recommendations.
 """
@@ -256,32 +254,36 @@ What risks exist? What's the recommended path forward?
         lines.extend(["", "---", "", "## Execution Steps", ""])
 
         for step in plan.steps:
-            lines.extend([
-                f"### Step {step.order}: {step.role}",
-                "",
-                f"**Tier Recommendation**: {step.tier_recommendation}",
-                f"**Tools**: {', '.join(step.tools)}",
-                "",
-                "**Prompt:**",
-                "```",
-                step.prompt,
-                "```",
-                "",
-                "**Success Criteria:**",
-            ])
+            lines.extend(
+                [
+                    f"### Step {step.order}: {step.role}",
+                    "",
+                    f"**Tier Recommendation**: {step.tier_recommendation}",
+                    f"**Tools**: {', '.join(step.tools)}",
+                    "",
+                    "**Prompt:**",
+                    "```",
+                    step.prompt,
+                    "```",
+                    "",
+                    "**Success Criteria:**",
+                ]
+            )
             for criterion in step.success_criteria:
                 lines.append(f"- [ ] {criterion}")
             lines.extend(["", "---", ""])
 
-        lines.extend([
-            "## Synthesis",
-            "",
-            "After all steps complete, run this synthesis:",
-            "",
-            "```",
-            plan.synthesis_prompt,
-            "```",
-        ])
+        lines.extend(
+            [
+                "## Synthesis",
+                "",
+                "After all steps complete, run this synthesis:",
+                "",
+                "```",
+                plan.synthesis_prompt,
+                "```",
+            ]
+        )
 
         return "\n".join(lines)
 
@@ -292,11 +294,13 @@ What risks exist? What's the recommended path forward?
         """
         steps_text = []
         for step in plan.steps:
-            steps_text.append(f"""
+            steps_text.append(
+                f"""
 ### {step.role}
 Use the Task tool with subagent_type="Explore" to:
 {step.prompt}
-""")
+"""
+            )
 
         return f"""# {plan.template_name}
 
@@ -353,24 +357,28 @@ def generate_plan(
         return generator.to_claude_code_skill(plan)
     elif output_format == "json":
         import json
-        return json.dumps({
-            "template_id": plan.template_id,
-            "template_name": plan.template_name,
-            "generated_at": plan.generated_at,
-            "form_responses": plan.form_responses,
-            "steps": [
-                {
-                    "order": s.order,
-                    "role": s.role,
-                    "tier_recommendation": s.tier_recommendation,
-                    "tools": s.tools,
-                    "prompt": s.prompt,
-                    "success_criteria": s.success_criteria,
-                    "config": s.config,
-                }
-                for s in plan.steps
-            ],
-            "synthesis_prompt": plan.synthesis_prompt,
-        }, indent=2)
+
+        return json.dumps(
+            {
+                "template_id": plan.template_id,
+                "template_name": plan.template_name,
+                "generated_at": plan.generated_at,
+                "form_responses": plan.form_responses,
+                "steps": [
+                    {
+                        "order": s.order,
+                        "role": s.role,
+                        "tier_recommendation": s.tier_recommendation,
+                        "tools": s.tools,
+                        "prompt": s.prompt,
+                        "success_criteria": s.success_criteria,
+                        "config": s.config,
+                    }
+                    for s in plan.steps
+                ],
+                "synthesis_prompt": plan.synthesis_prompt,
+            },
+            indent=2,
+        )
     else:
         raise ValueError(f"Unknown format: {output_format}")

empathy_os/meta_workflows/session_context.py

@@ -109,8 +109,7 @@ class SessionContext:
             self.memory.stash(key, value, ttl_seconds=ttl or self.default_ttl)
 
             logger.debug(
-                f"Recorded choice: template={template_id}, "
-                f"question={question_id}, choice={choice}"
+                f"Recorded choice: template={template_id}, question={question_id}, choice={choice}"
             )
             return True
 
@@ -336,7 +335,7 @@ class SessionContext:
         """
         try:
             # Basic validation - could be enhanced
-            if hasattr(question, 'options') and question.options:
+            if hasattr(question, "options") and question.options:
                 # Check if choice is in options (only if options are defined)
                 if isinstance(choice, list):
                     # Multi-select - all choices must be in options

empathy_os/meta_workflows/workflow.py

@@ -119,9 +119,7 @@ class MetaWorkflow:
 
         # Set up storage
         if storage_dir is None:
-            storage_dir = str(
-                Path.home() / ".empathy" / "meta_workflows" / "executions"
-            )
+            storage_dir = str(Path.home() / ".empathy" / "meta_workflows" / "executions")
         self.storage_dir = Path(storage_dir)
         self.storage_dir.mkdir(parents=True, exist_ok=True)
 
@@ -229,8 +227,7 @@ class MetaWorkflow:
                 run_id=run_id,
                 template_id=self.template.template_id,
                 timestamp=datetime.now().isoformat(),
-                form_responses=form_response
-                or FormResponse(template_id=self.template.template_id),
+                form_responses=form_response or FormResponse(template_id=self.template.template_id),
                 total_cost=0.0,
                 total_duration=time.time() - start_time,
                 success=False,
@@ -245,9 +242,7 @@ class MetaWorkflow:
 
             raise ValueError(f"Meta-workflow execution failed: {e}") from e
 
-    def _execute_agents_mock(
-        self, agents: list[AgentSpec]
-    ) -> list[AgentExecutionResult]:
+    def _execute_agents_mock(self, agents: list[AgentSpec]) -> list[AgentExecutionResult]:
         """Execute agents with mock execution (for MVP).
 
         Args:
@@ -330,9 +325,7 @@ class MetaWorkflow:
             logger.info(f"Executing agent: {agent.role} ({agent.tier_strategy.value})")
 
             try:
-                result = self._execute_single_agent_with_escalation(
-                    agent, router, tracker
-                )
+                result = self._execute_single_agent_with_escalation(agent, router, tracker)
                 results.append(result)
 
                 logger.info(
@@ -408,20 +401,14 @@ class MetaWorkflow:
                 return tier_result
 
             # Failed - try next tier
-            logger.debug(
-                f"Tier {tier.value} did not meet success criteria, "
-                f"attempting escalation"
-            )
+            logger.debug(f"Tier {tier.value} did not meet success criteria, attempting escalation")
             result = tier_result
 
         # All tiers exhausted - return final result (failed)
         if result:
             result.cost = total_cost
             result.duration = time.time() - start_time
-            logger.warning(
-                f"Agent {agent.role} failed at all tiers "
-                f"(cost: ${total_cost:.4f})"
-            )
+            logger.warning(f"Agent {agent.role} failed at all tiers (cost: ${total_cost:.4f})")
             return result
 
         # Should never reach here
@@ -587,9 +574,7 @@ class MetaWorkflow:
             instructions = base_template.default_instructions
         else:
             # Fallback if template not found - use role-based generic prompt
-            logger.warning(
-                f"Template {agent.base_template} not found, using generic prompt"
-            )
+            logger.warning(f"Template {agent.base_template} not found, using generic prompt")
             instructions = self._get_generic_instructions(agent.role)
 
         # Build prompt
@@ -614,9 +599,7 @@ class MetaWorkflow:
 
         return "\n".join(prompt_parts)
 
-    def _execute_llm_call(
-        self, prompt: str, model_config: Any, tier: ModelTier
-    ) -> dict[str, Any]:
+    def _execute_llm_call(self, prompt: str, model_config: Any, tier: ModelTier) -> dict[str, Any]:
         """Execute real LLM call via Anthropic or other providers.
 
         Uses the Anthropic client for Claude models, with fallback to
@@ -652,9 +635,7 @@ class MetaWorkflow:
             response = client.messages.create(
                 model=model_config.model_id,
                 max_tokens=2048,
-                messages=[
-                    {"role": "user", "content": prompt}
-                ],
+                messages=[{"role": "user", "content": prompt}],
             )
 
             # Extract response data
@@ -663,10 +644,9 @@ class MetaWorkflow:
             completion_tokens = response.usage.output_tokens
 
             # Calculate cost
-            cost = (
-                (prompt_tokens / 1000) * model_config.cost_per_1k_input
-                + (completion_tokens / 1000) * model_config.cost_per_1k_output
-            )
+            cost = (prompt_tokens / 1000) * model_config.cost_per_1k_input + (
+                completion_tokens / 1000
+            ) * model_config.cost_per_1k_output
 
             return {
                 "cost": cost,
@@ -703,9 +683,7 @@ class MetaWorkflow:
                 },
             }
 
-    def _simulate_llm_call(
-        self, prompt: str, model_config: Any, tier: ModelTier
-    ) -> dict[str, Any]:
+    def _simulate_llm_call(self, prompt: str, model_config: Any, tier: ModelTier) -> dict[str, Any]:
         """Simulate LLM call with realistic cost/token estimates.
 
         Used as fallback when real LLM execution is not available
@@ -726,10 +704,9 @@ class MetaWorkflow:
         completion_tokens = 500  # Assume moderate response
 
         # Calculate cost
-        cost = (
-            (prompt_tokens / 1000) * model_config.cost_per_1k_input
-            + (completion_tokens / 1000) * model_config.cost_per_1k_output
-        )
+        cost = (prompt_tokens / 1000) * model_config.cost_per_1k_input + (
+            completion_tokens / 1000
+        ) * model_config.cost_per_1k_output
 
         # Simulate success rate based on tier
         # cheap: 80%, capable: 95%, premium: 99%
@@ -756,9 +733,7 @@ class MetaWorkflow:
             },
         }
 
-    def _evaluate_success_criteria(
-        self, result: AgentExecutionResult, agent: AgentSpec
-    ) -> bool:
+    def _evaluate_success_criteria(self, result: AgentExecutionResult, agent: AgentSpec) -> bool:
         """Evaluate if agent result meets success criteria.
 
         Args:
@@ -779,9 +754,7 @@ class MetaWorkflow:
         # success_criteria is a list of descriptive strings (e.g., ["code reviewed", "tests pass"])
         # These are informational criteria - if result.success is True, we consider the criteria met
         # The criteria serve as documentation of what success means for this agent
-        logger.debug(
-            f"Agent succeeded with criteria: {agent.success_criteria}"
-        )
+        logger.debug(f"Agent succeeded with criteria: {agent.success_criteria}")
         return True
 
     def _save_execution(self, result: MetaWorkflowResult) -> Path:
@@ -883,9 +856,7 @@ class MetaWorkflow:
         lines.append("## Summary")
         lines.append("")
         lines.append(f"- **Agents Created**: {len(result.agents_created)}")
-        lines.append(
-            f"- **Agents Executed**: {len(result.agent_results)}"
-        )
+        lines.append(f"- **Agents Executed**: {len(result.agent_results)}")
         lines.append(f"- **Total Cost**: ${result.total_cost:.2f}")
         lines.append(f"- **Total Duration**: {result.total_duration:.1f}s")
         lines.append("")
@@ -918,9 +889,7 @@ class MetaWorkflow:
         for i, agent_result in enumerate(result.agent_results, 1):
             lines.append(f"### {i}. {agent_result.role}")
             lines.append("")
-            lines.append(
-                f"- **Status**: {'✅ Success' if agent_result.success else '❌ Failed'}"
-            )
+            lines.append(f"- **Status**: {'✅ Success' if agent_result.success else '❌ Failed'}")
             lines.append(f"- **Tier Used**: {agent_result.tier_used}")
             lines.append(f"- **Cost**: ${agent_result.cost:.2f}")
             lines.append(f"- **Duration**: {agent_result.duration:.1f}s")

empathy_os/models/cli.py

@@ -541,7 +541,7 @@ Examples:
   %(prog)s provider                     Show current provider config
   %(prog)s provider --set anthropic     Set Anthropic as primary
   %(prog)s provider --set hybrid        Enable hybrid mode
-  %(prog)s provider --interactive       Interactive setup wizard
+  %(prog)s provider --interactive       Interactive setup workflow
         """,
     )
 
@@ -600,7 +600,7 @@ Examples:
         "--interactive",
         "-i",
         action="store_true",
-        help="Interactive configuration wizard",
+        help="Interactive configuration workflow",
     )
     prov_parser.add_argument("--format", "-f", choices=["table", "json"], default="table")
 

empathy_os/models/tasks.py

@@ -3,7 +3,6 @@
 Provides a unified vocabulary for task types across:
 - empathy_llm_toolkit.routing.ModelRouter
 - src/empathy_os/workflows.WorkflowBase
-- empathy_software_plugin.wizards.MultiModelWizard
 
 This module defines:
 - TaskType enum with canonical task names
@@ -184,7 +183,7 @@ REALTIME_REQUIRED_TASKS: frozenset[str] = frozenset(
         "interactive_debug",
         "live_coding",
         "user_query",
-        "wizard_step",
+        "workflow_step",
         # Urgent Actions
         "critical_fix",
         "security_incident",

empathy_os/models/telemetry.py

@@ -1053,7 +1053,10 @@ class TelemetryStore:
                 continue
             if not stale_only and not failed_only:
                 # Return all files needing attention (stale OR failed OR no_tests)
-                if record.last_test_result not in ("failed", "error", "no_tests") and not record.is_stale:
+                if (
+                    record.last_test_result not in ("failed", "error", "no_tests")
+                    and not record.is_stale
+                ):
                     continue
             results.append(record)
 

empathy_os/models/token_estimator.py

@@ -210,7 +210,9 @@ def estimate_workflow_cost(
                             try:
                                 filepath = os.path.join(root, file)
                                 validated_filepath = _validate_file_path(filepath)
-                                with open(validated_filepath, encoding="utf-8", errors="ignore") as f:
+                                with open(
+                                    validated_filepath, encoding="utf-8", errors="ignore"
+                                ) as f:
                                     total_chars += len(f.read())
                             except (ValueError, OSError):
                                 pass