emdash-cli 0.1.30__py3-none-any.whl → 0.1.46__py3-none-any.whl

emdash_cli/commands/agent/file_utils.py

@@ -0,0 +1,178 @@
+"""File utilities for the agent CLI.
+
+Handles @file reference expansion and fuzzy file finding.
+"""
+
+import fnmatch
+import os
+import re
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def fuzzy_find_files(query: str, limit: int = 10) -> list[Path]:
+    """Find files matching a fuzzy query.
+
+    Args:
+        query: File name or partial path to search for
+        limit: Maximum number of results
+
+    Returns:
+        List of matching file paths
+    """
+    cwd = Path.cwd()
+    matches = []
+
+    # Common directories to skip
+    skip_dirs = {'.git', 'node_modules', '__pycache__', '.venv', 'venv', 'dist', 'build', '.emdash'}
+
+    # Walk the directory tree (more control than glob for skipping dirs)
+    for root, dirs, files in os.walk(cwd):
+        # Skip unwanted directories
+        dirs[:] = [d for d in dirs if d not in skip_dirs and not d.startswith('.')]
+
+        rel_root = Path(root).relative_to(cwd)
+
+        for file in files:
+            # Skip hidden files
+            if file.startswith('.'):
+                continue
+
+            rel_path = rel_root / file if str(rel_root) != '.' else Path(file)
+            full_path = cwd / rel_path
+
+            # Check if query matches (case-insensitive)
+            path_str = str(rel_path).lower()
+            query_lower = query.lower()
+
+            if query_lower in path_str or fnmatch.fnmatch(path_str, f"*{query_lower}*"):
+                matches.append(full_path)
+
+                if len(matches) >= limit:
+                    return matches
+
+    return matches
+
+
+def select_file_interactive(matches: list[Path], query: str) -> Path | None:
+    """Show interactive file selection menu.
+
+    Args:
+        matches: List of matching file paths
+        query: Original query string
+
+    Returns:
+        Selected file path or None if cancelled
+    """
+    if not matches:
+        return None
+
+    if len(matches) == 1:
+        return matches[0]
+
+    cwd = Path.cwd()
+
+    # Print numbered list
+    console.print(f"\n[bold cyan]Select file for @{query}:[/bold cyan]\n")
+
+    for i, path in enumerate(matches):
+        try:
+            rel_path = path.relative_to(cwd)
+        except ValueError:
+            rel_path = path
+        console.print(f"  [bold]{i + 1}[/bold]) {rel_path}")
+
+    console.print(f"\n[dim]Enter number (1-{len(matches)}) or press Enter to cancel:[/dim]")
+
+    try:
+        from prompt_toolkit import PromptSession
+        selection_session = PromptSession()
+        choice = selection_session.prompt("").strip()
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(matches):
+                return matches[idx]
+    except (KeyboardInterrupt, EOFError):
+        pass
+
+    return None
+
+
+def expand_file_references(message: str) -> tuple[str, list[str]]:
+    """Expand @file references in a message to include file contents.
+
+    Supports:
+    - @file.txt - exact path (relative or absolute)
+    - @utils - fuzzy search for files containing "utils"
+    - @~/path/file.txt - home directory paths
+
+    Shows interactive selection if multiple files match.
+
+    Args:
+        message: User message potentially containing @file references
+
+    Returns:
+        Tuple of (expanded_message, list_of_included_files)
+    """
+    # Pattern to match @word (not followed by space immediately, at least 2 chars)
+    pattern = r'@([^\s@]{2,})'
+
+    files_included = []
+    file_contents = []
+    replacements = {}  # Store replacements to apply after iteration
+
+    # Find all @references
+    for match in re.finditer(pattern, message):
+        file_query = match.group(1)
+        original = match.group(0)
+
+        # Skip if already processed
+        if original in replacements:
+            continue
+
+        # Expand ~ to home directory
+        if file_query.startswith("~"):
+            file_query_expanded = os.path.expanduser(file_query)
+        else:
+            file_query_expanded = file_query
+
+        # Check if it's an exact path first
+        path = Path(file_query_expanded)
+        if not path.is_absolute():
+            path = Path.cwd() / path
+
+        resolved_path = None
+
+        if path.exists() and path.is_file():
+            # Exact match
+            resolved_path = path
+        else:
+            # Fuzzy search
+            matches = fuzzy_find_files(file_query)
+            if matches:
+                resolved_path = select_file_interactive(matches, file_query)
+
+        if resolved_path:
+            try:
+                content = resolved_path.read_text()
+                files_included.append(str(resolved_path))
+                file_contents.append(f"\n\n**File: {resolved_path.name}**\n```\n{content}\n```")
+                replacements[original] = ""  # Remove the @reference
+            except Exception:
+                pass  # Can't read file, leave as-is
+
+    # Apply replacements
+    expanded_message = message
+    for original, replacement in replacements.items():
+        expanded_message = expanded_message.replace(original, replacement)
+
+    expanded_message = expanded_message.strip()
+
+    # Append file contents to the message
+    if file_contents:
+        expanded_message = expanded_message + "\n" + "\n".join(file_contents)
+
+    return expanded_message, files_included

emdash_cli/commands/agent/handlers/__init__.py

@@ -0,0 +1,41 @@
+"""Slash command handlers for the agent CLI."""
+
+from .agents import handle_agents
+from .sessions import handle_session
+from .todos import handle_todos, handle_todo_add
+from .hooks import handle_hooks
+from .rules import handle_rules
+from .skills import handle_skills
+from .mcp import handle_mcp
+from .auth import handle_auth
+from .doctor import handle_doctor
+from .verify import handle_verify, handle_verify_loop
+from .setup import handle_setup
+from .misc import (
+    handle_status,
+    handle_pr,
+    handle_projectmd,
+    handle_research,
+    handle_context,
+)
+
+__all__ = [
+    "handle_agents",
+    "handle_session",
+    "handle_todos",
+    "handle_todo_add",
+    "handle_hooks",
+    "handle_rules",
+    "handle_skills",
+    "handle_mcp",
+    "handle_auth",
+    "handle_doctor",
+    "handle_verify",
+    "handle_verify_loop",
+    "handle_setup",
+    "handle_status",
+    "handle_pr",
+    "handle_projectmd",
+    "handle_research",
+    "handle_context",
+]

emdash_cli/commands/agent/handlers/agents.py

@@ -0,0 +1,421 @@
+"""Handler for /agents command."""
+
+import os
+import subprocess
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+
+from ..menus import show_agents_interactive_menu, prompt_agent_name, confirm_delete
+
+console = Console()
+
+
+def create_agent(name: str) -> bool:
+    """Create a new agent with the given name."""
+    agents_dir = Path.cwd() / ".emdash" / "agents"
+    agent_file = agents_dir / f"{name}.md"
+
+    if agent_file.exists():
+        console.print(f"[yellow]Agent '{name}' already exists[/yellow]")
+        return False
+
+    agents_dir.mkdir(parents=True, exist_ok=True)
+
+    template = f'''---
+description: Custom agent for specific tasks
+tools: [grep, glob, read_file, semantic_search]
+---
+
+# System Prompt
+
+You are a specialized assistant for {name.replace("-", " ")} tasks.
+
+## Your Mission
+
+Describe what this agent should accomplish:
+- Task 1
+- Task 2
+- Task 3
+
+## Approach
+
+1. **Step One**
+   - Details about the first step
+
+2. **Step Two**
+   - Details about the second step
+
+## Output Format
+
+Describe how the agent should format its responses.
+'''
+    agent_file.write_text(template)
+    console.print(f"[green]Created agent: {name}[/green]")
+    console.print(f"[dim]File: {agent_file}[/dim]")
+    return True
+
+
+def show_agent_details(name: str) -> None:
+    """Show detailed view of an agent."""
+    from emdash_core.agent.toolkits import get_custom_agent
+
+    builtin_agents = ["Explore", "Plan"]
+
+    console.print()
+    console.print("[dim]─" * 50 + "[/dim]")
+    console.print()
+    if name in builtin_agents:
+        console.print(f"[bold cyan]{name}[/bold cyan] [dim](built-in)[/dim]\n")
+        if name == "Explore":
+            console.print("[bold]Description:[/bold] Fast codebase exploration (read-only)")
+            console.print("[bold]Tools:[/bold] glob, grep, read_file, list_files, semantic_search")
+        elif name == "Plan":
+            console.print("[bold]Description:[/bold] Design implementation plans")
+            console.print("[bold]Tools:[/bold] glob, grep, read_file, list_files, semantic_search")
+        console.print("\n[dim]Built-in agents cannot be edited or deleted.[/dim]")
+    else:
+        agent = get_custom_agent(name, Path.cwd())
+        if agent:
+            console.print(f"[bold cyan]{agent.name}[/bold cyan] [dim](custom)[/dim]\n")
+
+            # Show description
+            if agent.description:
+                console.print(f"[bold]Description:[/bold] {agent.description}")
+
+            # Show model
+            if agent.model:
+                console.print(f"[bold]Model:[/bold] {agent.model}")
+
+            # Show tools
+            if agent.tools:
+                console.print(f"[bold]Tools:[/bold] {', '.join(agent.tools)}")
+
+            # Show MCP servers
+            if agent.mcp_servers:
+                console.print(f"\n[bold]MCP Servers:[/bold]")
+                for server in agent.mcp_servers:
+                    status = "[green]enabled[/green]" if server.enabled else "[dim]disabled[/dim]"
+                    console.print(f"  [cyan]{server.name}[/cyan] ({status})")
+                    console.print(f"    [dim]{server.command} {' '.join(server.args)}[/dim]")
+
+            # Show file path
+            if agent.file_path:
+                console.print(f"\n[bold]File:[/bold] {agent.file_path}")
+
+            # Show system prompt preview
+            if agent.system_prompt:
+                console.print(f"\n[bold]System Prompt Preview:[/bold]")
+                preview = agent.system_prompt[:300]
+                if len(agent.system_prompt) > 300:
+                    preview += "..."
+                console.print(Panel(preview, border_style="dim"))
+        else:
+            console.print(f"[yellow]Agent '{name}' not found[/yellow]")
+    console.print()
+    console.print("[dim]─" * 50 + "[/dim]")
+
+
+def delete_agent(name: str) -> bool:
+    """Delete a custom agent."""
+    agents_dir = Path.cwd() / ".emdash" / "agents"
+    agent_file = agents_dir / f"{name}.md"
+
+    if not agent_file.exists():
+        console.print(f"[yellow]Agent file not found: {agent_file}[/yellow]")
+        return False
+
+    if confirm_delete(name):
+        agent_file.unlink()
+        console.print(f"[green]Deleted agent: {name}[/green]")
+        return True
+    else:
+        console.print("[dim]Cancelled[/dim]")
+        return False
+
+
+def edit_agent(name: str) -> None:
+    """Open agent file in editor."""
+    agents_dir = Path.cwd() / ".emdash" / "agents"
+    agent_file = agents_dir / f"{name}.md"
+
+    if not agent_file.exists():
+        console.print(f"[yellow]Agent file not found: {agent_file}[/yellow]")
+        return
+
+    # Try to open in editor
+    editor = os.environ.get("EDITOR", "")
+    if not editor:
+        # Try common editors
+        for ed in ["code", "vim", "nano", "vi"]:
+            try:
+                subprocess.run(["which", ed], capture_output=True, check=True)
+                editor = ed
+                break
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                continue
+
+    if editor:
+        console.print(f"[dim]Opening {agent_file} in {editor}...[/dim]")
+        try:
+            subprocess.run([editor, str(agent_file)])
+        except Exception as e:
+            console.print(f"[red]Failed to open editor: {e}[/red]")
+            console.print(f"[dim]Edit manually: {agent_file}[/dim]")
+    else:
+        console.print(f"[yellow]No editor found. Edit manually:[/yellow]")
+        console.print(f"  {agent_file}")
+
+
+def chat_edit_agent(name: str, client, renderer, model, max_iterations, render_with_interrupt) -> None:
+    """Start a chat session to edit an agent with AI assistance."""
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.styles import Style
+
+    agents_dir = Path.cwd() / ".emdash" / "agents"
+    agent_file = agents_dir / f"{name}.md"
+
+    if not agent_file.exists():
+        console.print(f"[yellow]Agent file not found: {agent_file}[/yellow]")
+        return
+
+    # Read current content
+    content = agent_file.read_text()
+
+    console.print()
+    console.print(f"[bold cyan]Chat: Editing agent '{name}'[/bold cyan]")
+    console.print("[dim]What would you like to change? Type 'done' to finish, Ctrl+C to cancel[/dim]")
+    console.print()
+
+    chat_style = Style.from_dict({
+        "prompt": "#00cc66 bold",
+    })
+
+    ps = PromptSession(style=chat_style)
+    chat_session_id = None
+    first_message = True
+
+    # Chat loop
+    while True:
+        try:
+            user_input = ps.prompt([("class:prompt", "› ")]).strip()
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ("done", "quit", "exit", "q"):
+                console.print("[dim]Finished editing agent[/dim]")
+                break
+
+            # First message includes agent context
+            if first_message:
+                message_with_context = f"""I want to edit my custom agent "{name}".
+
+**File:** `{agent_file}`
+
+**Current content:**
+```markdown
+{content}
+```
+
+**My request:** {user_input}
+
+Please make the requested changes using the Edit tool."""
+                stream = client.agent_chat_stream(
+                    message=message_with_context,
+                    model=model,
+                    max_iterations=max_iterations,
+                    options={"mode": "code"},
+                )
+                first_message = False
+            elif chat_session_id:
+                stream = client.agent_continue_stream(
+                    chat_session_id, user_input
+                )
+            else:
+                stream = client.agent_chat_stream(
+                    message=user_input,
+                    model=model,
+                    max_iterations=max_iterations,
+                    options={"mode": "code"},
+                )
+
+            result = render_with_interrupt(renderer, stream)
+            if result and result.get("session_id"):
+                chat_session_id = result["session_id"]
+
+        except (KeyboardInterrupt, EOFError):
+            console.print()
+            console.print("[dim]Finished editing agent[/dim]")
+            break
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+
+
+def chat_create_agent(client, renderer, model, max_iterations, render_with_interrupt) -> str | None:
+    """Start a chat session to create a new agent with AI assistance.
+
+    Returns:
+        The name of the created agent, or None if cancelled.
+    """
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.styles import Style
+
+    agents_dir = Path.cwd() / ".emdash" / "agents"
+
+    console.print()
+    console.print("[bold cyan]Create New Agent[/bold cyan]")
+    console.print("[dim]Describe what agent you want to create. The AI will help you design it.[/dim]")
+    console.print("[dim]Type 'done' to finish, Ctrl+C to cancel[/dim]")
+    console.print()
+
+    chat_style = Style.from_dict({
+        "prompt": "#00cc66 bold",
+    })
+
+    ps = PromptSession(style=chat_style)
+    chat_session_id = None
+    first_message = True
+
+    # Ensure agents directory exists
+    agents_dir.mkdir(parents=True, exist_ok=True)
+
+    # Chat loop
+    while True:
+        try:
+            user_input = ps.prompt([("class:prompt", "› ")]).strip()
+
+            if not user_input:
+                continue
+
+            if user_input.lower() in ("done", "quit", "exit", "q"):
+                console.print("[dim]Finished[/dim]")
+                break
+
+            # First message includes context about agents
+            if first_message:
+                message_with_context = f"""I want to create a new custom agent for my project.
+
+**Agents directory:** `{agents_dir}`
+
+Agents are markdown files with YAML frontmatter that define specialized assistants with custom system prompts and tools.
+
+**Agent file format:**
+```markdown
+---
+description: Brief description of what this agent does
+model: claude-sonnet  # optional, defaults to main model
+tools: [grep, glob, read_file, edit_file, bash]  # tools this agent can use
+mcp_servers:  # optional, MCP servers for this agent
+  - name: server-name
+    command: npx
+    args: ["-y", "@modelcontextprotocol/server-name"]
+---
+
+# System Prompt
+
+You are a specialized assistant for [purpose].
+
+## Your Mission
+[What this agent should accomplish]
+
+## Approach
+[How this agent should work]
+
+## Output Format
+[How the agent should format responses]
+```
+
+**Available tools:** grep, glob, read_file, edit_file, write_file, bash, semantic_search, list_files, etc.
+
+**My request:** {user_input}
+
+Please help me design and create an agent. Ask me questions about what I need, then use the Write tool to create the file at `{agents_dir}/<agent-name>.md`."""
+                stream = client.agent_chat_stream(
+                    message=message_with_context,
+                    model=model,
+                    max_iterations=max_iterations,
+                    options={"mode": "code"},
+                )
+                first_message = False
+            elif chat_session_id:
+                stream = client.agent_continue_stream(
+                    chat_session_id, user_input
+                )
+            else:
+                stream = client.agent_chat_stream(
+                    message=user_input,
+                    model=model,
+                    max_iterations=max_iterations,
+                    options={"mode": "code"},
+                )
+
+            result = render_with_interrupt(renderer, stream)
+            if result and result.get("session_id"):
+                chat_session_id = result["session_id"]
+
+        except (KeyboardInterrupt, EOFError):
+            console.print()
+            console.print("[dim]Cancelled[/dim]")
+            break
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+
+    return None
+
+
+def handle_agents(args: str, client, renderer, model, max_iterations, render_with_interrupt) -> None:
+    """Handle /agents command."""
+    from prompt_toolkit import PromptSession
+
+    # Handle subcommands for backward compatibility
+    if args:
+        subparts = args.split(maxsplit=1)
+        subcommand = subparts[0].lower()
+        subargs = subparts[1] if len(subparts) > 1 else ""
+
+        if subcommand == "create" and subargs:
+            create_agent(subargs.strip().lower().replace(" ", "-"))
+        elif subcommand == "show" and subargs:
+            show_agent_details(subargs.strip())
+        elif subcommand == "delete" and subargs:
+            delete_agent(subargs.strip())
+        elif subcommand == "edit" and subargs:
+            edit_agent(subargs.strip())
+        else:
+            console.print("[yellow]Usage: /agents [create|show|delete|edit] <name>[/yellow]")
+            console.print("[dim]Or just /agents for interactive menu[/dim]")
+    else:
+        # Interactive menu
+        while True:
+            action, agent_name = show_agents_interactive_menu()
+
+            if action == "cancel":
+                break
+            elif action == "view":
+                show_agent_details(agent_name)
+                # After viewing, show options based on agent type
+                is_custom = agent_name not in ("Explore", "Plan")
+                try:
+                    if is_custom:
+                        console.print("[dim]'c' chat • 'e' edit • Enter back[/dim]", end="")
+                    else:
+                        console.print("[dim]Press Enter to go back...[/dim]", end="")
+                    ps = PromptSession()
+                    resp = ps.prompt(" ").strip().lower()
+                    if is_custom and resp == 'c':
+                        chat_edit_agent(agent_name, client, renderer, model, max_iterations, render_with_interrupt)
+                    elif is_custom and resp == 'e':
+                        edit_agent(agent_name)
+                    console.print()  # Add spacing before menu reappears
+                except (KeyboardInterrupt, EOFError):
+                    break
+            elif action == "create":
+                # Use AI-assisted creation
+                chat_create_agent(client, renderer, model, max_iterations, render_with_interrupt)
+            elif action == "delete":
+                delete_agent(agent_name)
+            elif action == "edit":
+                edit_agent(agent_name)
+                break  # Exit menu after editing