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

empathy_os/socratic/embeddings.py

@@ -149,7 +149,7 @@ class TFIDFEmbeddingProvider(EmbeddingProvider):
         """Tokenize text into words."""
         # Simple tokenization: lowercase, split on non-alphanumeric
         text = text.lower()
-        tokens = re.findall(r'\b[a-z][a-z0-9_]*\b', text)
+        tokens = re.findall(r"\b[a-z][a-z0-9_]*\b", text)
         return tokens
 
     def _compute_tf(self, tokens: list[str]) -> dict[str, float]:
@@ -255,6 +255,7 @@ class AnthropicEmbeddingProvider(EmbeddingProvider):
         if self._client is None and self.api_key:
             try:
                 import anthropic
+
                 self._client = anthropic.Anthropic(api_key=self.api_key)
             except ImportError:
                 logger.warning("anthropic package not installed")
@@ -268,13 +269,13 @@ class AnthropicEmbeddingProvider(EmbeddingProvider):
             fallback = TFIDFEmbeddingProvider(dimension=self._dimension)
             return fallback.embed(text)
 
-        aspects = self.ASPECTS[:self._dimension]
+        aspects = self.ASPECTS[: self._dimension]
         prompt = f"""Rate how relevant this goal is to each aspect on a scale of 0.0 to 1.0.
 
 Goal: "{text}"
 
 Aspects to rate:
-{chr(10).join(f'{i+1}. {aspect}' for i, aspect in enumerate(aspects))}
+{chr(10).join(f"{i + 1}. {aspect}" for i, aspect in enumerate(aspects))}
 
 Respond with ONLY a JSON array of numbers, one per aspect, in order.
 Example: [0.8, 0.2, 0.5, ...]"""
@@ -290,7 +291,7 @@ Example: [0.8, 0.2, 0.5, ...]"""
             # Parse JSON array
             scores = json.loads(content.strip())
             if isinstance(scores, list) and len(scores) >= self._dimension:
-                return [float(s) for s in scores[:self._dimension]]
+                return [float(s) for s in scores[: self._dimension]]
 
         except Exception as e:
             logger.warning(f"Anthropic embedding failed: {e}")
@@ -331,6 +332,7 @@ class SentenceTransformerProvider(EmbeddingProvider):
         if self._model is None:
             try:
                 from sentence_transformers import SentenceTransformer
+
                 self._model = SentenceTransformer(self.model_name)
                 self._dimension = self._model.get_sentence_embedding_dimension()
             except ImportError:
@@ -677,15 +679,17 @@ class SemanticGoalMatcher:
         formatted = []
         for result in results:
             if result.goal.success_score >= min_success_score:
-                formatted.append({
-                    "goal_id": result.goal.goal_id,
-                    "goal_text": result.goal.goal_text,
-                    "similarity": round(result.similarity, 3),
-                    "workflow_id": result.goal.workflow_id,
-                    "domains": result.goal.domains,
-                    "success_score": result.goal.success_score,
-                    "metadata": result.goal.metadata,
-                })
+                formatted.append(
+                    {
+                        "goal_id": result.goal.goal_id,
+                        "goal_text": result.goal.goal_text,
+                        "similarity": round(result.similarity, 3),
+                        "workflow_id": result.goal.workflow_id,
+                        "domains": result.goal.domains,
+                        "success_score": result.goal.success_score,
+                        "metadata": result.goal.metadata,
+                    }
+                )
 
             if len(formatted) >= top_k:
                 break

empathy_os/socratic/engine.py

@@ -144,9 +144,32 @@ def extract_keywords(goal: str) -> list[str]:
     """Extract important keywords from goal."""
     # Remove common words
     stop_words = {
-        "i", "want", "to", "the", "a", "an", "my", "our", "for", "with",
-        "that", "this", "is", "are", "be", "will", "would", "could",
-        "should", "can", "help", "me", "us", "please", "need", "like",
+        "i",
+        "want",
+        "to",
+        "the",
+        "a",
+        "an",
+        "my",
+        "our",
+        "for",
+        "with",
+        "that",
+        "this",
+        "is",
+        "are",
+        "be",
+        "will",
+        "would",
+        "could",
+        "should",
+        "can",
+        "help",
+        "me",
+        "us",
+        "please",
+        "need",
+        "like",
     }
 
     # Extract words
@@ -162,7 +185,10 @@ def identify_ambiguities(goal: str, domain: str) -> list[str]:
     ambiguities = []
 
     # Check for missing specifics
-    if not any(lang in goal.lower() for lang in ["python", "javascript", "typescript", "java", "go", "rust"]):
+    if not any(
+        lang in goal.lower()
+        for lang in ["python", "javascript", "typescript", "java", "go", "rust"]
+    ):
         ambiguities.append("Programming language not specified")
 
     # Check for vague scope
@@ -223,50 +249,78 @@ def generate_initial_questions(
 
     # Domain-specific questions
     if goal_analysis.domain == "code_review":
-        fields.append(FormField(
-            id="review_scope",
-            field_type=FieldType.SINGLE_SELECT,
-            label="What scope of review do you need?",
-            options=[
-                FieldOption("pr", "Pull Request/Diff", description="Review specific changes", recommended=True),
-                FieldOption("file", "Single File", description="Deep review of one file"),
-                FieldOption("directory", "Directory/Module", description="Review entire module"),
-                FieldOption("project", "Full Project", description="Comprehensive codebase review"),
-            ],
-            validation=FieldValidation(required=True),
-            category="scope",
-        ))
+        fields.append(
+            FormField(
+                id="review_scope",
+                field_type=FieldType.SINGLE_SELECT,
+                label="What scope of review do you need?",
+                options=[
+                    FieldOption(
+                        "pr",
+                        "Pull Request/Diff",
+                        description="Review specific changes",
+                        recommended=True,
+                    ),
+                    FieldOption("file", "Single File", description="Deep review of one file"),
+                    FieldOption(
+                        "directory", "Directory/Module", description="Review entire module"
+                    ),
+                    FieldOption(
+                        "project", "Full Project", description="Comprehensive codebase review"
+                    ),
+                ],
+                validation=FieldValidation(required=True),
+                category="scope",
+            )
+        )
 
     if goal_analysis.domain == "security":
-        fields.append(FormField(
-            id="security_focus",
-            field_type=FieldType.MULTI_SELECT,
-            label="What security aspects are most important?",
-            options=[
-                FieldOption("owasp", "OWASP Top 10", description="Common web vulnerabilities"),
-                FieldOption("injection", "Injection Attacks", description="SQL, command, XSS"),
-                FieldOption("auth", "Authentication/Authorization", description="Access control issues"),
-                FieldOption("crypto", "Cryptography", description="Encryption, hashing, secrets"),
-                FieldOption("deps", "Dependencies", description="Vulnerable dependencies"),
-            ],
-            validation=FieldValidation(required=True),
-            category="security",
-        ))
+        fields.append(
+            FormField(
+                id="security_focus",
+                field_type=FieldType.MULTI_SELECT,
+                label="What security aspects are most important?",
+                options=[
+                    FieldOption("owasp", "OWASP Top 10", description="Common web vulnerabilities"),
+                    FieldOption("injection", "Injection Attacks", description="SQL, command, XSS"),
+                    FieldOption(
+                        "auth", "Authentication/Authorization", description="Access control issues"
+                    ),
+                    FieldOption(
+                        "crypto", "Cryptography", description="Encryption, hashing, secrets"
+                    ),
+                    FieldOption("deps", "Dependencies", description="Vulnerable dependencies"),
+                ],
+                validation=FieldValidation(required=True),
+                category="security",
+            )
+        )
 
     if goal_analysis.domain == "testing":
-        fields.append(FormField(
-            id="test_type",
-            field_type=FieldType.MULTI_SELECT,
-            label="What types of tests do you need?",
-            options=[
-                FieldOption("unit", "Unit Tests", description="Test individual functions", recommended=True),
-                FieldOption("integration", "Integration Tests", description="Test component interactions"),
-                FieldOption("e2e", "End-to-End Tests", description="Test full user flows"),
-                FieldOption("edge", "Edge Cases", description="Test boundary conditions"),
-            ],
-            validation=FieldValidation(required=True),
-            category="testing",
-        ))
+        fields.append(
+            FormField(
+                id="test_type",
+                field_type=FieldType.MULTI_SELECT,
+                label="What types of tests do you need?",
+                options=[
+                    FieldOption(
+                        "unit",
+                        "Unit Tests",
+                        description="Test individual functions",
+                        recommended=True,
+                    ),
+                    FieldOption(
+                        "integration",
+                        "Integration Tests",
+                        description="Test component interactions",
+                    ),
+                    FieldOption("e2e", "End-to-End Tests", description="Test full user flows"),
+                    FieldOption("edge", "Edge Cases", description="Test boundary conditions"),
+                ],
+                validation=FieldValidation(required=True),
+                category="testing",
+            )
+        )
 
     # Automation level (always relevant)
     fields.append(create_automation_level_field())
@@ -280,7 +334,7 @@ def generate_initial_questions(
     return Form(
         id=f"round_{session.current_round + 1}",
         title="Help Us Understand Your Needs",
-        description=f"Based on your goal: \"{goal_analysis.raw_goal[:100]}...\"",
+        description=f'Based on your goal: "{goal_analysis.raw_goal[:100]}..."',
         fields=fields,
         round_number=session.current_round + 1,
         progress=0.3,
@@ -305,14 +359,16 @@ def generate_followup_questions(
 
     # If no must-haves, ask for priorities
     if not reqs.must_have:
-        fields.append(FormField(
-            id="priorities",
-            field_type=FieldType.TEXT_AREA,
-            label="What are your top 3 priorities for this workflow?",
-            help_text="Be as specific as possible about what success looks like.",
-            validation=FieldValidation(required=True, min_length=20),
-            category="priorities",
-        ))
+        fields.append(
+            FormField(
+                id="priorities",
+                field_type=FieldType.TEXT_AREA,
+                label="What are your top 3 priorities for this workflow?",
+                help_text="Be as specific as possible about what success looks like.",
+                validation=FieldValidation(required=True, min_length=20),
+                category="priorities",
+            )
+        )
 
     # If technical constraints missing
     if not reqs.technical_constraints.get("languages"):
@@ -320,18 +376,28 @@ def generate_followup_questions(
 
     # Domain-specific follow-ups
     if session.goal_analysis and session.goal_analysis.domain == "code_review":
-        if "review_depth" not in [r.get("id") for r in session.question_rounds[-1]["questions"]] if session.question_rounds else True:
-            fields.append(FormField(
-                id="review_depth",
-                field_type=FieldType.SINGLE_SELECT,
-                label="How thorough should the review be?",
-                options=[
-                    FieldOption("quick", "Quick Scan", description="Fast, surface-level review"),
-                    FieldOption("standard", "Standard", description="Balanced depth", recommended=True),
-                    FieldOption("deep", "Deep Dive", description="Thorough, detailed analysis"),
-                ],
-                category="depth",
-            ))
+        if (
+            "review_depth" not in [r.get("id") for r in session.question_rounds[-1]["questions"]]
+            if session.question_rounds
+            else True
+        ):
+            fields.append(
+                FormField(
+                    id="review_depth",
+                    field_type=FieldType.SINGLE_SELECT,
+                    label="How thorough should the review be?",
+                    options=[
+                        FieldOption(
+                            "quick", "Quick Scan", description="Fast, surface-level review"
+                        ),
+                        FieldOption(
+                            "standard", "Standard", description="Balanced depth", recommended=True
+                        ),
+                        FieldOption("deep", "Deep Dive", description="Thorough, detailed analysis"),
+                    ],
+                    category="depth",
+                )
+            )
 
     if not fields:
         return None
@@ -513,10 +579,7 @@ class SocraticWorkflowBuilder:
         current_form = self.get_next_questions(session)
         questions_data = []
         if current_form:
-            questions_data = [
-                {"id": f.id, "label": f.label}
-                for f in current_form.fields
-            ]
+            questions_data = [{"id": f.id, "label": f.label} for f in current_form.fields]
 
         session.add_question_round(questions_data, answers)
 
@@ -725,5 +788,7 @@ class SocraticWorkflowBuilder:
             "rounds_completed": session.current_round,
             "requirements_completeness": session.requirements.completeness_score(),
             "ready_to_generate": self.is_ready_to_generate(session),
-            "ambiguities_remaining": len(session.goal_analysis.ambiguities) if session.goal_analysis else 0,
+            "ambiguities_remaining": (
+                len(session.goal_analysis.ambiguities) if session.goal_analysis else 0
+            ),
         }

empathy_os/socratic/explainer.py

@@ -206,29 +206,37 @@ class WorkflowExplainer:
         sections: list[dict[str, str]] = []
 
         # Overview section
-        sections.append({
-            "heading": "Overview",
-            "content": self._explain_overview(blueprint),
-        })
+        sections.append(
+            {
+                "heading": "Overview",
+                "content": self._explain_overview(blueprint),
+            }
+        )
 
         # Agents section
-        sections.append({
-            "heading": "Agents Involved",
-            "content": self._explain_agents(blueprint.agents),
-        })
+        sections.append(
+            {
+                "heading": "Agents Involved",
+                "content": self._explain_agents(blueprint.agents),
+            }
+        )
 
         # Process section
-        sections.append({
-            "heading": "How It Works",
-            "content": self._explain_process(blueprint.stages, blueprint.agents),
-        })
+        sections.append(
+            {
+                "heading": "How It Works",
+                "content": self._explain_process(blueprint.stages, blueprint.agents),
+            }
+        )
 
         # Success criteria section (if provided)
         if success_criteria:
-            sections.append({
-                "heading": "Success Metrics",
-                "content": self._explain_success_criteria(success_criteria),
-            })
+            sections.append(
+                {
+                    "heading": "Success Metrics",
+                    "content": self._explain_success_criteria(success_criteria),
+                }
+            )
 
         # Summary
         summary = self._generate_summary(blueprint)
@@ -256,22 +264,28 @@ class WorkflowExplainer:
         role_desc = ROLE_DESCRIPTIONS.get(self.audience, {}).get(
             agent.role, "performs automated tasks"
         )
-        sections.append({
-            "heading": "Role",
-            "content": f"This agent {role_desc}.",
-        })
+        sections.append(
+            {
+                "heading": "Role",
+                "content": f"This agent {role_desc}.",
+            }
+        )
 
         # Capabilities section
-        sections.append({
-            "heading": "Capabilities",
-            "content": self._explain_tools(agent.tools),
-        })
+        sections.append(
+            {
+                "heading": "Capabilities",
+                "content": self._explain_tools(agent.tools),
+            }
+        )
 
         # How it helps section
-        sections.append({
-            "heading": "How It Helps",
-            "content": self._explain_agent_value(agent),
-        })
+        sections.append(
+            {
+                "heading": "How It Helps",
+                "content": self._explain_agent_value(agent),
+            }
+        )
 
         summary = f"{agent.name} is a {agent.role.value} agent that {agent.goal.lower()}"
 
@@ -298,7 +312,9 @@ class WorkflowExplainer:
                 f"Target domain: {blueprint.domain}."
             )
         else:
-            generated_at = blueprint.generated_at.strftime('%Y-%m-%d') if blueprint.generated_at else 'N/A'
+            generated_at = (
+                blueprint.generated_at.strftime("%Y-%m-%d") if blueprint.generated_at else "N/A"
+            )
             return (
                 f"Multi-agent workflow with {len(blueprint.agents)} agents, "
                 f"{len(blueprint.stages)} stages. "
@@ -317,15 +333,15 @@ class WorkflowExplainer:
         for agent_blueprint in agents:
             # Access the AgentSpec via .spec
             spec = agent_blueprint.spec
-            role_desc = ROLE_DESCRIPTIONS.get(self.audience, {}).get(
-                spec.role, "works on the task"
-            )
+            role_desc = ROLE_DESCRIPTIONS.get(self.audience, {}).get(spec.role, "works on the task")
 
             if self.detail_level == DetailLevel.BRIEF:
                 lines.append(f"• {spec.name}: {role_desc}")
             else:
                 tool_count = len(spec.tools)
-                tool_str = f" ({tool_count} tools)" if self.detail_level == DetailLevel.DETAILED else ""
+                tool_str = (
+                    f" ({tool_count} tools)" if self.detail_level == DetailLevel.DETAILED else ""
+                )
                 lines.append(f"• **{spec.name}**{tool_str}: {spec.goal}")
 
         return "\n".join(lines)
@@ -341,11 +357,7 @@ class WorkflowExplainer:
         lines = []
 
         for i, stage in enumerate(stages, 1):
-            agent_names = [
-                agent_lookup[aid].name
-                for aid in stage.agent_ids
-                if aid in agent_lookup
-            ]
+            agent_names = [agent_lookup[aid].name for aid in stage.agent_ids if aid in agent_lookup]
 
             if self.audience == AudienceLevel.BEGINNER:
                 if stage.parallel:
@@ -358,9 +370,7 @@ class WorkflowExplainer:
                     )
             else:
                 parallel_str = " (parallel)" if stage.parallel else ""
-                lines.append(
-                    f"{i}. **{stage.name}**{parallel_str}: {', '.join(agent_names)}"
-                )
+                lines.append(f"{i}. **{stage.name}**{parallel_str}: {', '.join(agent_names)}")
 
             if self.detail_level == DetailLevel.DETAILED and stage.depends_on:
                 lines.append(f"   Depends on: {', '.join(stage.depends_on)}")
@@ -384,7 +394,7 @@ class WorkflowExplainer:
 
         lines = ["This agent can:"]
         for tool in tools:
-            tool_id = tool.id if hasattr(tool, 'id') else str(tool)
+            tool_id = tool.id if hasattr(tool, "id") else str(tool)
             explanation = tool_explanations.get(tool_id, f"use {tool_id}")
             lines.append(f"• {explanation}")
 
@@ -418,7 +428,9 @@ class WorkflowExplainer:
             if self.audience == AudienceLevel.BEGINNER:
                 lines.append(f"• {metric.name}: {metric.description}")
             else:
-                target = f" (target: {metric.target_value})" if metric.target_value is not None else ""
+                target = (
+                    f" (target: {metric.target_value})" if metric.target_value is not None else ""
+                )
                 lines.append(f"• **{metric.name}**{target}: {metric.description}")
 
         return "\n".join(lines)
@@ -438,7 +450,10 @@ class WorkflowExplainer:
                 f"to deliver results efficiently and consistently."
             )
         else:
-            return blueprint.description or f"A {len(blueprint.stages)}-stage workflow for {blueprint.domain}."
+            return (
+                blueprint.description
+                or f"A {len(blueprint.stages)}-stage workflow for {blueprint.domain}."
+            )
 
     def generate_narrative(self, blueprint: WorkflowBlueprint) -> str:
         """Generate a narrative story-like explanation.
@@ -473,22 +488,16 @@ class WorkflowExplainer:
             lines.append(f"### Step {i}: {stage.name}")
             lines.append("")
 
-            agents_in_stage = [
-                agent_lookup[aid] for aid in stage.agent_ids if aid in agent_lookup
-            ]
+            agents_in_stage = [agent_lookup[aid] for aid in stage.agent_ids if aid in agent_lookup]
 
             if stage.parallel and len(agents_in_stage) > 1:
                 lines.append("Working in parallel:")
                 for agent in agents_in_stage:
-                    role_desc = ROLE_DESCRIPTIONS.get(self.audience, {}).get(
-                        agent.role, "works"
-                    )
+                    role_desc = ROLE_DESCRIPTIONS.get(self.audience, {}).get(agent.role, "works")
                     lines.append(f"- **{agent.name}** {role_desc}")
             else:
                 for agent in agents_in_stage:
-                    role_desc = ROLE_DESCRIPTIONS.get(self.audience, {}).get(
-                        agent.role, "works"
-                    )
+                    role_desc = ROLE_DESCRIPTIONS.get(self.audience, {}).get(agent.role, "works")
                     lines.append(f"**{agent.name}** {role_desc}.")
 
             lines.append("")
@@ -542,6 +551,7 @@ Format as markdown with clear sections."""
         if self._client is None and self.api_key:
             try:
                 import anthropic
+
                 self._client = anthropic.Anthropic(api_key=self.api_key)
             except ImportError:
                 pass
@@ -571,13 +581,11 @@ Format as markdown with clear sections."""
 
         # Format workflow info for prompt
         agents_str = "\n".join(
-            f"- {a.name} ({a.role.value}): {a.description}"
-            for a in blueprint.agents
+            f"- {a.name} ({a.role.value}): {a.description}" for a in blueprint.agents
         )
 
         stages_str = "\n".join(
-            f"- {s.name}: {', '.join(s.agent_ids)}"
-            + (" (parallel)" if s.parallel else "")
+            f"- {s.name}: {', '.join(s.agent_ids)}" + (" (parallel)" if s.parallel else "")
             for s in blueprint.stages
         )
 
@@ -645,9 +653,10 @@ def explain_workflow(
         elif format == OutputFormat.TEXT:
             # Simple markdown to text conversion
             import re
-            text = re.sub(r'#{1,6}\s+', '', markdown)  # Remove headers
-            text = re.sub(r'\*\*([^*]+)\*\*', r'\1', text)  # Remove bold
-            text = re.sub(r'\*([^*]+)\*', r'\1', text)  # Remove italic
+
+            text = re.sub(r"#{1,6}\s+", "", markdown)  # Remove headers
+            text = re.sub(r"\*\*([^*]+)\*\*", r"\1", text)  # Remove bold
+            text = re.sub(r"\*([^*]+)\*", r"\1", text)  # Remove italic
             return text
         elif format == OutputFormat.HTML:
             # Simple markdown to HTML
@@ -667,6 +676,7 @@ def explain_workflow(
         return explanation.to_html()
     elif format == OutputFormat.JSON:
         import json
+
         return json.dumps(explanation.to_dict(), indent=2)
     else:
         return explanation.to_markdown()