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

emdash_core/agent/mcp/config.py

@@ -65,6 +65,14 @@ class MCPServerConfig:
                 # Default to .emdash/index/kuzu_db in cwd
                 default_path = Path.cwd() / ".emdash" / "index" / "kuzu_db"
                 return str(default_path)
+            # Check for cclsp config path - use emdash config default
+            if var_name == "CCLSP_CONFIG_PATH":
+                env_val = os.getenv(var_name)
+                if env_val:
+                    return env_val
+                # Default to .emdash/cclsp.json in cwd
+                default_path = Path.cwd() / ".emdash" / "cclsp.json"
+                return str(default_path)
             # Fall back to environment variable
             return os.getenv(var_name, "")
 
@@ -244,6 +252,8 @@ def get_default_mcp_servers() -> dict[str, MCPServerConfig]:
     """
     # Check if graph MCP is enabled via env flag
     enable_graph_mcp = os.getenv("ENABLE_GRAPH_MCP", "false").lower() == "true"
+    # Check if LSP is enabled via env flag (disabled by default)
+    enable_cclsp = os.getenv("USE_LSP", "false").lower() == "true"
 
     return {
         "github": MCPServerConfig(
@@ -266,6 +276,16 @@ def get_default_mcp_servers() -> dict[str, MCPServerConfig]:
             enabled=enable_graph_mcp,
             timeout=30,
         ),
+        "cclsp": MCPServerConfig(
+            name="cclsp",
+            command="npx",
+            args=["cclsp@latest"],
+            env={
+                "CCLSP_CONFIG_PATH": "${CCLSP_CONFIG_PATH}",
+            },
+            enabled=enable_cclsp,  # Disabled by default, enable with USE_LSP=true
+            timeout=60,  # LSP operations can take longer
+        ),
     }
 
 
@@ -297,6 +317,62 @@ def ensure_mcp_config(path: Path) -> MCPConfigFile:
         MCPConfigFile (loaded or newly created)
     """
     if path.exists():
-        return MCPConfigFile.load(path)
+        config = MCPConfigFile.load(path)
     else:
-        return create_default_mcp_config(path)
+        config = create_default_mcp_config(path)
+
+    # Ensure cclsp.json config exists if cclsp is enabled
+    if config.servers.get("cclsp") and config.servers["cclsp"].enabled:
+        cclsp_config_path = path.parent / "cclsp.json"
+        ensure_cclsp_config(cclsp_config_path)
+
+    return config
+
+
+def get_default_cclsp_config() -> dict:
+    """Get the default cclsp configuration for TypeScript/React projects.
+
+    Returns:
+        Dictionary with cclsp configuration
+    """
+    return {
+        "servers": [
+            {
+                "extensions": ["ts", "tsx", "js", "jsx"],
+                "command": ["npx", "typescript-language-server", "--stdio"],
+                "rootDir": ".",
+            },
+            {
+                "extensions": ["py", "pyi"],
+                "command": ["pylsp"],
+                "rootDir": ".",
+            },
+        ]
+    }
+
+
+def create_cclsp_config(path: Path) -> None:
+    """Create a default cclsp configuration file.
+
+    Args:
+        path: Path to save the cclsp.json file
+    """
+    config = get_default_cclsp_config()
+
+    # Ensure directory exists
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(path, "w") as f:
+        json.dump(config, f, indent=2)
+
+    log.info(f"Created default cclsp config at {path}")
+
+
+def ensure_cclsp_config(path: Path) -> None:
+    """Ensure cclsp config exists, creating default if needed.
+
+    Args:
+        path: Path to the cclsp.json file
+    """
+    if not path.exists():
+        create_cclsp_config(path)

emdash_core/agent/prompts/main_agent.py

@@ -10,6 +10,8 @@ from .workflow import (
     OUTPUT_GUIDELINES,
     PARALLEL_EXECUTION,
     TODO_LIST_GUIDANCE,
+    VERIFICATION_AND_CRITIQUE,
+    ACTION_NOT_ANNOUNCEMENT,
 )
 
 # Base system prompt template with placeholder for tools
@@ -20,7 +22,7 @@ _BASE_PROMPT = """You are a code exploration and implementation assistant. You o
 
 # Main agent system prompt - same for both code and plan modes
 # Main agent is always an orchestrator that delegates to subagents
-BASE_SYSTEM_PROMPT = _BASE_PROMPT + WORKFLOW_PATTERNS + PARALLEL_EXECUTION + EXPLORATION_STRATEGY + TODO_LIST_GUIDANCE + OUTPUT_GUIDELINES
+BASE_SYSTEM_PROMPT = _BASE_PROMPT + WORKFLOW_PATTERNS + PARALLEL_EXECUTION + EXPLORATION_STRATEGY + TODO_LIST_GUIDANCE + ACTION_NOT_ANNOUNCEMENT + VERIFICATION_AND_CRITIQUE + OUTPUT_GUIDELINES
 
 # Legacy aliases
 CODE_MODE_PROMPT = BASE_SYSTEM_PROMPT
@@ -37,12 +39,22 @@ def build_system_prompt(toolkit) -> str:
         Complete system prompt string
     """
     tools_section = build_tools_section(toolkit)
+    agents_section = build_agents_section(toolkit)
     skills_section = build_skills_section()
     rules_section = build_rules_section()
+    session_section = build_session_context_section(toolkit)
 
     # Main agent always uses the same prompt - it orchestrates and delegates
     prompt = BASE_SYSTEM_PROMPT.format(tools_section=tools_section)
 
+    # Add session context section first (repo, branch, status)
+    if session_section:
+        prompt += "\n" + session_section
+
+    # Add agents section so main agent knows what agents are available
+    if agents_section:
+        prompt += "\n" + agents_section
+
     # Add rules section if there are rules defined
     if rules_section:
         prompt += "\n" + rules_section
@@ -54,6 +66,51 @@ def build_system_prompt(toolkit) -> str:
     return prompt
 
 
+def build_session_context_section(toolkit) -> str:
+    """Build the session context section with repo, branch, and git status.
+
+    Args:
+        toolkit: The agent toolkit (to access repo_root)
+
+    Returns:
+        Formatted string with session context, or empty string if not in a git repo
+    """
+    from ...utils.git import (
+        get_repo_name,
+        get_current_branch,
+        get_git_status_summary,
+    )
+
+    repo_root = getattr(toolkit, '_repo_root', None)
+    if not repo_root:
+        return ""
+
+    repo_name = get_repo_name(repo_root)
+    branch = get_current_branch(repo_root)
+    status = get_git_status_summary(repo_root)
+
+    # Only include if we have at least some git info
+    if not any([repo_name, branch, status]):
+        return ""
+
+    lines = [
+        "## Session Context",
+        "",
+    ]
+
+    if repo_name:
+        lines.append(f"- **Repository**: {repo_name}")
+    if branch:
+        lines.append(f"- **Branch**: {branch}")
+    if status:
+        lines.append(f"- **Git Status**: {status}")
+
+    lines.append(f"- **Working Directory**: {repo_root}")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
 def build_rules_section() -> str:
     """Build the rules section of the system prompt.
 
@@ -80,6 +137,36 @@ def build_skills_section() -> str:
     return registry.get_skills_for_prompt()
 
 
+def build_agents_section(toolkit) -> str:
+    """Build the agents section describing available sub-agents.
+
+    Args:
+        toolkit: The agent toolkit (to access repo_root)
+
+    Returns:
+        Formatted string with agent descriptions, or empty string if none
+    """
+    from ..toolkits import get_agents_with_descriptions
+
+    repo_root = getattr(toolkit, '_repo_root', None)
+    agents = get_agents_with_descriptions(repo_root)
+
+    if not agents:
+        return ""
+
+    lines = [
+        "## Available Agents",
+        "",
+        "Use the `task` tool to delegate work to these specialized agents:",
+        "",
+    ]
+
+    for agent in agents:
+        lines.append(f"- **{agent['name']}**: {agent['description']}")
+
+    return "\n".join(lines)
+
+
 def build_tools_section(toolkit) -> str:
     """Build the tools section of the system prompt from registered tools.
 

emdash_core/agent/prompts/plan_mode.py

@@ -62,21 +62,45 @@ Even for new features, explore first to understand:
 - Where similar features exist
 - What conventions to follow
 
-Use these tools directly:
+**Direct Tools (for targeted queries):**
 - `glob` - Find files by pattern (e.g., `glob(pattern="**/*.py")`)
 - `grep` - Search file contents (e.g., `grep(pattern="class User", path="src/")`)
 - `read_file` - Read specific files
 - `semantic_search` - Find conceptually related code
 
-For deep parallel exploration, you can spawn Explore agents:
+**Parallel Explore Agents (for complex tasks):**
+For non-trivial tasks, launch up to 3 Explore agents IN PARALLEL to speed up exploration:
+
 ```python
+# Launch multiple agents in a SINGLE response for parallel execution
 task(
     subagent_type="Explore",
     prompt="Find all authentication-related files and patterns",
     description="Explore auth patterns"
 )
+task(
+    subagent_type="Explore",
+    prompt="Find all API endpoint definitions and routing",
+    description="Explore API routes"
+)
+task(
+    subagent_type="Explore",
+    prompt="Find all database models and schemas",
+    description="Explore data models"
+)
 ```
 
+**When to use parallel agents:**
+- Task touches multiple subsystems (auth, API, database, etc.)
+- Codebase is large or unfamiliar
+- Requirements span multiple domains
+- You need to understand architectural patterns quickly
+
+**When to use direct tools:**
+- Simple, targeted queries ("find the User class")
+- You already know where to look
+- Quick file reads or pattern matches
+
 ### Phase 2: CLARIFY (Only After Exploring)
 If requirements are still unclear AFTER exploration, ask focused questions.
 
@@ -94,6 +118,27 @@ Consider:
 - Edge cases and error handling
 - Verification/testing strategy
 
+**For complex architectural decisions**, you can launch a Plan agent:
+
+```python
+task(
+    subagent_type="Plan",
+    prompt="Design the authentication system architecture considering: existing patterns found in auth/, session management in services/session.py, and the need for OAuth2 support",
+    description="Design auth architecture"
+)
+```
+
+**When to use Plan agents:**
+- Multiple valid architectural approaches exist
+- Trade-offs need careful analysis
+- Design impacts multiple subsystems
+- You need expert-level design recommendations
+
+**When to synthesize directly:**
+- Implementation is straightforward
+- Clear patterns exist to follow
+- Single file or localized changes
+
 ### Phase 4: REVIEW
 Before finalizing, verify the plan is complete and actionable.
 
@@ -124,52 +169,27 @@ exit_plan()
 
 ## PLAN FILE FORMAT
 
-Your plan must be written to `{plan_file_path}` and include:
+Your plan must be written to `{plan_file_path}`. Use **compact formatting** - no blank lines between headers and content:
 
 ```markdown
-# Implementation Plan: <Title>
-
+# <Title>
 ## Summary
-<1-2 sentence overview of what will be implemented>
-
+<1-2 sentence overview>
 ## Approach
-<High-level strategy - describe WHAT changes, not HOW (no code)>
-
-### For Bug Fixes:
-- Root cause analysis
-- Fix location and strategy
-- Regression prevention
-
-### For New Features:
-- Architecture decisions
-- Component breakdown
-- Integration points
-
-### For Refactors:
-- Current state problems
-- Target state benefits
-- Migration strategy
-
-## Implementation Steps
+<High-level strategy - WHAT changes, not HOW>
+- For bugs: root cause, fix location, regression prevention
+- For features: architecture, components, integration points
+- For refactors: current problems, target benefits, migration
+## Steps
 1. <Step 1 - what to do, which file>
 2. <Step 2 - what to do, which file>
-...
-
 ## Critical Files
-List the 3-5 most important files with brief justification:
-
 | File | Purpose |
 |------|---------|
-| `path/to/file1.py` | <why this file is critical> |
-| `path/to/file2.py` | <why this file is critical> |
-...
-
+| `path/to/file.py` | <why critical> |
 ## Verification
-- [ ] <Specific test or check to verify correctness>
-- [ ] <Another verification step>
-...
-
-## Risks & Considerations
+- [ ] <Test or check to verify>
+## Risks
 - <Potential issue and mitigation>
 ```
 
@@ -179,8 +199,8 @@ List the 3-5 most important files with brief justification:
 
 ```
 ┌─────────────────┐
-│   1. EXPLORE    │ ◄─── Use tools directly: glob, grep, read_file
-│  (your tools)   │
+│   1. EXPLORE    │ ◄─── Direct tools OR up to 3 Explore agents in parallel
+│ (tools/agents)  │
 └────────┬────────┘
          │ Codebase understood
          ▼
@@ -191,8 +211,8 @@ List the 3-5 most important files with brief justification:
          │ Requirements clear
          ▼
 ┌─────────────────┐
-│    3. DESIGN    │ ◄─── Synthesize findings into approach
-│ (your analysis) │
+│    3. DESIGN    │ ◄─── Direct synthesis OR Plan agent for complex decisions
+│(analysis/agent) │
 └────────┬────────┘
          │ Design complete
          ▼
@@ -247,8 +267,9 @@ Only call `exit_plan` when ALL of these are true:
 ## CORRECT BEHAVIOR
 
 - Use `ask_followup_question` for clarifying requirements
-- Use your tools directly (glob, grep, read_file) for exploration
-- Use `task(subagent_type="Explore", ...)` only for deep parallel exploration
+- Use your tools directly (glob, grep, read_file) for simple, targeted exploration
+- Use `task(subagent_type="Explore", ...)` for complex tasks - launch up to 3 in parallel
+- Use `task(subagent_type="Plan", ...)` for complex architectural decisions
 - Write plan to `{plan_file_path}` before exiting
 - Use `exit_plan` to request plan approval
 - Focus on WHAT to change, not HOW (no code snippets)

emdash_core/agent/prompts/subagents.py

@@ -178,12 +178,19 @@ SUBAGENT_PROMPTS = {
     "Research": RESEARCH_PROMPT,
 }
 
+# Built-in agent descriptions (for main agent's system prompt)
+BUILTIN_AGENTS = {
+    "Explore": "Fast codebase exploration - searches files, reads code, finds patterns",
+    "Plan": "Designs implementation plans - analyzes architecture, writes to .emdash/plans/",
+}
+
 
-def get_subagent_prompt(subagent_type: str) -> str:
+def get_subagent_prompt(subagent_type: str, repo_root=None) -> str:
     """Get the system prompt for a sub-agent type.
 
     Args:
-        subagent_type: Type of agent (e.g., "Explore", "Plan")
+        subagent_type: Type of agent (e.g., "Explore", "Plan", or custom agent name)
+        repo_root: Repository root for finding custom agents
 
     Returns:
         System prompt string
@@ -191,9 +198,90 @@ def get_subagent_prompt(subagent_type: str) -> str:
     Raises:
         ValueError: If agent type is not known
     """
-    if subagent_type not in SUBAGENT_PROMPTS:
-        available = list(SUBAGENT_PROMPTS.keys())
-        raise ValueError(
-            f"Unknown agent type: {subagent_type}. Available: {available}"
-        )
-    return SUBAGENT_PROMPTS[subagent_type]
+    from pathlib import Path
+
+    # Check built-in agents first
+    if subagent_type in SUBAGENT_PROMPTS:
+        return SUBAGENT_PROMPTS[subagent_type]
+
+    # Check custom agents
+    from ..toolkits import get_custom_agent
+    custom_agent = get_custom_agent(subagent_type, repo_root)
+    if custom_agent:
+        prompt_parts = [custom_agent.system_prompt]
+
+        # Inject rules if specified
+        if custom_agent.rules:
+            rules_content = _load_rules_by_names(custom_agent.rules, repo_root)
+            if rules_content:
+                prompt_parts.append(f"\n\n## Rules\n\n{rules_content}")
+
+        # Inject skills if specified
+        if custom_agent.skills:
+            skills_content = _load_skills_by_names(custom_agent.skills, repo_root)
+            if skills_content:
+                prompt_parts.append(f"\n\n## Skills\n\n{skills_content}")
+
+        return "".join(prompt_parts)
+
+    # Not found
+    available = list(SUBAGENT_PROMPTS.keys())
+    raise ValueError(
+        f"Unknown agent type: {subagent_type}. Available: {available}"
+    )
+
+
+def _load_rules_by_names(rule_names: list[str], repo_root=None) -> str:
+    """Load specific rules by name.
+
+    Args:
+        rule_names: List of rule names to load
+        repo_root: Repository root
+
+    Returns:
+        Combined rules content
+    """
+    from pathlib import Path
+
+    rules_dir = (repo_root or Path.cwd()) / ".emdash" / "rules"
+    if not rules_dir.exists():
+        return ""
+
+    parts = []
+    for name in rule_names:
+        rule_file = rules_dir / f"{name}.md"
+        if rule_file.exists():
+            try:
+                content = rule_file.read_text().strip()
+                if content:
+                    parts.append(content)
+            except Exception:
+                pass
+
+    return "\n\n---\n\n".join(parts)
+
+
+def _load_skills_by_names(skill_names: list[str], repo_root=None) -> str:
+    """Load specific skills by name and return their instructions.
+
+    Args:
+        skill_names: List of skill names to load
+        repo_root: Repository root
+
+    Returns:
+        Combined skills instructions
+    """
+    from pathlib import Path
+    from ..skills import SkillRegistry
+
+    skills_dir = (repo_root or Path.cwd()) / ".emdash" / "skills"
+    registry = SkillRegistry.get_instance()
+    registry.load_skills(skills_dir)
+
+    parts = []
+    for name in skill_names:
+        skill = registry.get_skill(name)
+        if skill and skill.instructions:
+            parts.append(f"### {skill.name}\n\n{skill.instructions}")
+
+    return "\n\n".join(parts)