emdash-core 0.1.25__py3-none-any.whl → 0.1.33__py3-none-any.whl

emdash_core/api/agent.py

@@ -31,6 +31,61 @@ def _ensure_emdash_importable():
     pass  # emdash_core is already in the package
 
 
+def _run_sdk_agent(
+    message: str,
+    model: str,
+    sse_handler: SSEHandler,
+    session_id: str,
+    emitter,
+    plan_mode: bool = False,
+):
+    """Run the agent using Anthropic Agent SDK.
+
+    This function is called when use_sdk=True and model is a Claude model.
+    It uses the SDKAgentRunner which provides native support for
+    Skills, MCP, and extended thinking.
+    """
+    import asyncio
+    from ..agent.runner import SDKAgentRunner
+
+    # Get working directory from config
+    config = get_config()
+    cwd = str(config.repo_root) if config.repo_root else str(Path.cwd())
+
+    # Create SDK runner
+    runner = SDKAgentRunner(
+        model=model,
+        cwd=cwd,
+        emitter=emitter,
+        plan_mode=plan_mode,
+    )
+
+    # Store session state
+    _sessions[session_id] = {
+        "runner": runner,
+        "message_count": 1,
+        "model": model,
+        "plan_mode": plan_mode,
+        "is_sdk": True,
+    }
+
+    # Run async agent in sync context
+    async def run_async():
+        response_text = ""
+        async for event in runner.run(message):
+            if event.get("type") == "text":
+                response_text += event.get("content", "")
+        return response_text
+
+    # Run the async code
+    try:
+        response = asyncio.run(run_async())
+        return response
+    except Exception as e:
+        sse_handler.emit(EventType.ERROR, {"error": str(e)})
+        raise
+
+
 def _run_agent_sync(
     message: str,
     model: str,
@@ -38,19 +93,38 @@ def _run_agent_sync(
     sse_handler: SSEHandler,
     session_id: str,
     images: list = None,
+    plan_mode: bool = False,
+    use_sdk: bool = None,
 ):
     """Run the agent synchronously (in thread pool).
 
     This function runs in a background thread and emits events
     to the SSE handler for streaming to the client.
+
+    For Claude models with use_sdk=True, uses the Anthropic Agent SDK.
+    For other models, uses the standard AgentRunner with OpenAI-compatible API.
     """
     try:
         _ensure_emdash_importable()
 
         # Import agent components from emdash_core
-        from ..agent.runner import AgentRunner
+        from ..agent.runner import AgentRunner, is_claude_model
+        from ..agent.toolkit import AgentToolkit
         from ..agent.events import AgentEventEmitter
 
+        # Determine if we should use SDK
+        # Auto-detect based on model if not explicitly set
+        if use_sdk is None:
+            import os
+            # Check env var for SDK preference
+            sdk_enabled = os.environ.get("EMDASH_USE_SDK", "auto").lower()
+            if sdk_enabled == "true":
+                use_sdk = True
+            elif sdk_enabled == "false":
+                use_sdk = False
+            else:  # "auto"
+                use_sdk = is_claude_model(model)
+
         # Create an emitter that forwards to SSE handler
         class SSEBridgeHandler:
             """Bridges AgentEventEmitter to SSEHandler."""
@@ -66,7 +140,32 @@ def _run_agent_sync(
         emitter = AgentEventEmitter(agent_name="Emdash Code")
         emitter.add_handler(SSEBridgeHandler(sse_handler))
 
+        # Use SDK for Claude models if enabled
+        if use_sdk and is_claude_model(model):
+            return _run_sdk_agent(
+                message=message,
+                model=model,
+                sse_handler=sse_handler,
+                session_id=session_id,
+                emitter=emitter,
+                plan_mode=plan_mode,
+            )
+
+        # Standard path: use AgentRunner with OpenAI-compatible API
+        # Create toolkit with plan_mode if requested
+        # When in plan mode, generate a plan file path so write_to_file is available
+        plan_file_path = None
+        if plan_mode:
+            from pathlib import Path
+            repo_root = Path.cwd()
+            plan_file_path = str(repo_root / ".emdash" / "plan.md")
+            # Ensure .emdash directory exists
+            (repo_root / ".emdash").mkdir(exist_ok=True)
+
+        toolkit = AgentToolkit(plan_mode=plan_mode, plan_file_path=plan_file_path)
+
         runner = AgentRunner(
+            toolkit=toolkit,
             model=model,
             verbose=True,
             max_iterations=max_iterations,
@@ -78,6 +177,7 @@ def _run_agent_sync(
             "runner": runner,
             "message_count": 1,
             "model": model,
+            "plan_mode": plan_mode,
         }
 
         # Convert image data if provided
@@ -114,6 +214,7 @@ async def _run_agent_async(
     # Get model from request or config
     model = request.model or config.default_model
     max_iterations = request.options.max_iterations
+    plan_mode = request.options.mode == AgentMode.PLAN
 
     # Emit session start
     sse_handler.emit(EventType.SESSION_START, {
@@ -121,6 +222,7 @@ async def _run_agent_async(
         "model": model,
         "session_id": session_id,
         "query": request.message,
+        "mode": request.options.mode.value,
     })
 
     loop = asyncio.get_event_loop()
@@ -136,6 +238,7 @@ async def _run_agent_async(
             sse_handler,
             session_id,
             request.images,
+            plan_mode,
         )
 
         # Emit session end
@@ -306,3 +409,454 @@ async def delete_session(session_id: str):
         del _sessions[session_id]
         return {"deleted": True}
     raise HTTPException(status_code=404, detail="Session not found")
+
+
+@router.get("/chat/{session_id}/plan")
+async def get_pending_plan(session_id: str):
+    """Get the pending plan for a session, if any.
+
+    Returns 404 if session not found, 204 if no pending plan.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    runner = session.get("runner")
+
+    if not runner:
+        raise HTTPException(status_code=400, detail="Session has no active runner")
+
+    pending_plan = runner.get_pending_plan()
+    if not pending_plan:
+        return {"has_plan": False, "plan": None}
+
+    return {
+        "has_plan": True,
+        "session_id": session_id,
+        "plan": pending_plan,
+    }
+
+
+@router.post("/chat/{session_id}/plan/approve")
+async def approve_plan(session_id: str):
+    """Approve the pending plan and transition to code mode.
+
+    Returns SSE stream for the implementation phase.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    runner = session.get("runner")
+
+    if not runner:
+        raise HTTPException(status_code=400, detail="Session has no active runner")
+
+    if not runner.has_pending_plan():
+        raise HTTPException(status_code=400, detail="No pending plan to approve")
+
+    # Create SSE handler for streaming the implementation
+    sse_handler = SSEHandler(agent_name="Emdash Code")
+
+    async def _run_approval():
+        loop = asyncio.get_event_loop()
+
+        try:
+            # Wire up SSE handler
+            from ..agent.events import AgentEventEmitter
+
+            class SSEBridgeHandler:
+                def __init__(self, sse_handler: SSEHandler):
+                    self._sse = sse_handler
+
+                def handle(self, event):
+                    self._sse.handle(event)
+
+            emitter = AgentEventEmitter(agent_name="Emdash Code")
+            emitter.add_handler(SSEBridgeHandler(sse_handler))
+            runner.emitter = emitter
+
+            sse_handler.emit(EventType.SESSION_START, {
+                "agent_name": "Emdash Code",
+                "model": session.get("model", "unknown"),
+                "session_id": session_id,
+                "query": "Plan approved - implementing...",
+                "plan_approved": True,
+            })
+
+            # Reset cycle state for new mode
+            from ..agent.tools.modes import ModeState
+            ModeState.get_instance().reset_cycle()
+
+            # Approve and run implementation
+            await loop.run_in_executor(
+                _executor,
+                runner.approve_plan,
+            )
+
+            session["plan_mode"] = False  # Now in code mode
+
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": True,
+                "session_id": session_id,
+            })
+
+        except Exception as e:
+            sse_handler.emit(EventType.ERROR, {"message": str(e)})
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": False,
+                "error": str(e),
+                "session_id": session_id,
+            })
+
+        finally:
+            sse_handler.close()
+
+    asyncio.create_task(_run_approval())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Session-ID": session_id,
+        },
+    )
+
+
+@router.post("/chat/{session_id}/plan/reject")
+async def reject_plan(session_id: str, feedback: str = ""):
+    """Reject the pending plan with feedback.
+
+    Returns SSE stream for the revised planning phase.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    runner = session.get("runner")
+
+    if not runner:
+        raise HTTPException(status_code=400, detail="Session has no active runner")
+
+    if not runner.has_pending_plan():
+        raise HTTPException(status_code=400, detail="No pending plan to reject")
+
+    sse_handler = SSEHandler(agent_name="Emdash Code")
+
+    async def _run_rejection():
+        loop = asyncio.get_event_loop()
+
+        try:
+            from ..agent.events import AgentEventEmitter
+
+            class SSEBridgeHandler:
+                def __init__(self, sse_handler: SSEHandler):
+                    self._sse = sse_handler
+
+                def handle(self, event):
+                    self._sse.handle(event)
+
+            emitter = AgentEventEmitter(agent_name="Emdash Code")
+            emitter.add_handler(SSEBridgeHandler(sse_handler))
+            runner.emitter = emitter
+
+            sse_handler.emit(EventType.SESSION_START, {
+                "agent_name": "Emdash Code",
+                "model": session.get("model", "unknown"),
+                "session_id": session_id,
+                "query": f"Plan rejected - revising... {feedback}",
+                "plan_rejected": True,
+            })
+
+            # Reset cycle state for revision
+            from ..agent.tools.modes import ModeState
+            ModeState.get_instance().reset_cycle()
+
+            # Reject and continue planning
+            await loop.run_in_executor(
+                _executor,
+                lambda: runner.reject_plan(feedback),
+            )
+
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": True,
+                "session_id": session_id,
+            })
+
+        except Exception as e:
+            sse_handler.emit(EventType.ERROR, {"message": str(e)})
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": False,
+                "error": str(e),
+                "session_id": session_id,
+            })
+
+        finally:
+            sse_handler.close()
+
+    asyncio.create_task(_run_rejection())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Session-ID": session_id,
+        },
+    )
+
+
+@router.post("/chat/{session_id}/planmode/approve")
+async def approve_plan_mode(session_id: str):
+    """Approve entering plan mode.
+
+    Called when user approves the agent's request to enter plan mode.
+    Returns SSE stream for the planning phase.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    runner = session.get("runner")
+
+    if not runner:
+        raise HTTPException(status_code=400, detail="Session has no active runner")
+
+    # Check if plan mode was actually requested
+    from ..agent.tools.modes import ModeState
+    state = ModeState.get_instance()
+    if not state.plan_mode_requested:
+        raise HTTPException(status_code=400, detail="No pending plan mode request")
+
+    sse_handler = SSEHandler(agent_name="Emdash Code")
+
+    async def _run_approval():
+        loop = asyncio.get_event_loop()
+
+        try:
+            from ..agent.events import AgentEventEmitter
+
+            class SSEBridgeHandler:
+                def __init__(self, sse_handler: SSEHandler):
+                    self._sse = sse_handler
+
+                def handle(self, event):
+                    self._sse.handle(event)
+
+            emitter = AgentEventEmitter(agent_name="Emdash Code")
+            emitter.add_handler(SSEBridgeHandler(sse_handler))
+            runner.emitter = emitter
+
+            sse_handler.emit(EventType.SESSION_START, {
+                "agent_name": "Emdash Code",
+                "model": session.get("model", "unknown"),
+                "session_id": session_id,
+                "query": "Plan mode approved - entering plan mode...",
+                "plan_mode_approved": True,
+            })
+
+            # Approve and enter plan mode
+            await loop.run_in_executor(
+                _executor,
+                runner.approve_plan_mode,
+            )
+
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": True,
+                "session_id": session_id,
+            })
+
+        except Exception as e:
+            sse_handler.emit(EventType.ERROR, {"message": str(e)})
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": False,
+                "error": str(e),
+                "session_id": session_id,
+            })
+
+        finally:
+            sse_handler.close()
+
+    asyncio.create_task(_run_approval())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Session-ID": session_id,
+        },
+    )
+
+
+@router.post("/chat/{session_id}/clarification/answer")
+async def answer_clarification(session_id: str, answer: str):
+    """Answer a pending clarification question.
+
+    Called when the user responds to a clarification question asked by the agent
+    via ask_followup_question tool. This resumes the agent with the user's answer.
+
+    Args:
+        session_id: The session ID
+        answer: The user's answer to the clarification question
+
+    Returns:
+        SSE stream for the agent's continued execution
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    runner = session.get("runner")
+
+    if not runner:
+        raise HTTPException(status_code=400, detail="Session has no active runner")
+
+    sse_handler = SSEHandler(agent_name="Emdash Code")
+
+    async def _run_answer():
+        loop = asyncio.get_event_loop()
+
+        try:
+            from ..agent.events import AgentEventEmitter
+
+            class SSEBridgeHandler:
+                def __init__(self, sse_handler: SSEHandler):
+                    self._sse = sse_handler
+
+                def handle(self, event):
+                    self._sse.handle(event)
+
+            emitter = AgentEventEmitter(agent_name="Emdash Code")
+            emitter.add_handler(SSEBridgeHandler(sse_handler))
+            runner.emitter = emitter
+
+            sse_handler.emit(EventType.SESSION_START, {
+                "agent_name": "Emdash Code",
+                "model": session.get("model", "unknown"),
+                "session_id": session_id,
+                "query": f"Clarification answered: {answer[:100]}...",
+                "clarification_answered": True,
+            })
+
+            # Answer the clarification and resume the agent
+            await loop.run_in_executor(
+                _executor,
+                lambda: runner.answer_clarification(answer),
+            )
+
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": True,
+                "session_id": session_id,
+            })
+
+        except Exception as e:
+            sse_handler.emit(EventType.ERROR, {"message": str(e)})
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": False,
+                "error": str(e),
+                "session_id": session_id,
+            })
+
+        finally:
+            sse_handler.close()
+
+    asyncio.create_task(_run_answer())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Session-ID": session_id,
+        },
+    )
+
+
+@router.post("/chat/{session_id}/planmode/reject")
+async def reject_plan_mode(session_id: str, feedback: str = ""):
+    """Reject entering plan mode.
+
+    Called when user rejects the agent's request to enter plan mode.
+    Returns SSE stream for continued code mode execution.
+    """
+    if session_id not in _sessions:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    session = _sessions[session_id]
+    runner = session.get("runner")
+
+    if not runner:
+        raise HTTPException(status_code=400, detail="Session has no active runner")
+
+    # Check if plan mode was actually requested
+    from ..agent.tools.modes import ModeState
+    state = ModeState.get_instance()
+    if not state.plan_mode_requested:
+        raise HTTPException(status_code=400, detail="No pending plan mode request")
+
+    sse_handler = SSEHandler(agent_name="Emdash Code")
+
+    async def _run_rejection():
+        loop = asyncio.get_event_loop()
+
+        try:
+            from ..agent.events import AgentEventEmitter
+
+            class SSEBridgeHandler:
+                def __init__(self, sse_handler: SSEHandler):
+                    self._sse = sse_handler
+
+                def handle(self, event):
+                    self._sse.handle(event)
+
+            emitter = AgentEventEmitter(agent_name="Emdash Code")
+            emitter.add_handler(SSEBridgeHandler(sse_handler))
+            runner.emitter = emitter
+
+            sse_handler.emit(EventType.SESSION_START, {
+                "agent_name": "Emdash Code",
+                "model": session.get("model", "unknown"),
+                "session_id": session_id,
+                "query": f"Plan mode rejected - continuing in code mode... {feedback}",
+                "plan_mode_rejected": True,
+            })
+
+            # Reject and stay in code mode
+            await loop.run_in_executor(
+                _executor,
+                lambda: runner.reject_plan_mode(feedback),
+            )
+
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": True,
+                "session_id": session_id,
+            })
+
+        except Exception as e:
+            sse_handler.emit(EventType.ERROR, {"message": str(e)})
+            sse_handler.emit(EventType.SESSION_END, {
+                "success": False,
+                "error": str(e),
+                "session_id": session_id,
+            })
+
+        finally:
+            sse_handler.close()
+
+    asyncio.create_task(_run_rejection())
+
+    return StreamingResponse(
+        sse_handler,
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Session-ID": session_id,
+        },
+    )

emdash_core/skills/frontend-design/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: frontend-design
+description: Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.
+user_invocable: true
+tools: []
+---
+
+# Frontend Design
+
+This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+
+The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+
+## Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+## Frontend Aesthetics Guidelines
+
+Focus on:
+
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+## What to Avoid
+
+NEVER use generic AI-generated aesthetics like:
+- Overused font families (Inter, Roboto, Arial, system fonts)
+- Cliched color schemes (particularly purple gradients on white backgrounds)
+- Predictable layouts and component patterns
+- Cookie-cutter design that lacks context-specific character
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+## Implementation Complexity
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+
+Remember: Claude is capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.

emdash_core/sse/stream.py

@@ -16,6 +16,10 @@ class EventType(str, Enum):
     TOOL_START = "tool_start"
     TOOL_RESULT = "tool_result"
 
+    # Sub-agent lifecycle
+    SUBAGENT_START = "subagent_start"
+    SUBAGENT_END = "subagent_end"
+
     # Agent thinking/progress
     THINKING = "thinking"
     PROGRESS = "progress"

{emdash_core-0.1.25.dist-info → emdash_core-0.1.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emdash-core
-Version: 0.1.25
+Version: 0.1.33
 Summary: EmDash Core - FastAPI server for code intelligence
 Author: Em Dash Team
 Requires-Python: >=3.10,<4.0
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: astroid (>=3.0.1,<4.0.0)
 Requires-Dist: beautifulsoup4 (>=4.12.0)
+Requires-Dist: claude-agent-sdk (>=0.1.19)
 Requires-Dist: duckduckgo-search (>=6.0.0)
 Requires-Dist: fastapi (>=0.109.0)
 Requires-Dist: gitpython (>=3.1.40,<4.0.0)