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

emdash_cli/commands/agent/handlers/misc.py

@@ -0,0 +1,200 @@
+"""Handlers for miscellaneous slash commands."""
+
+from datetime import datetime
+from pathlib import Path
+
+from rich.console import Console
+
+console = Console()
+
+
+def handle_status(client) -> None:
+    """Handle /status command.
+
+    Args:
+        client: EmdashClient instance
+    """
+    console.print("\n[bold cyan]Status[/bold cyan]\n")
+
+    # Index status
+    console.print("[bold]Index Status[/bold]")
+    try:
+        status = client.index_status(str(Path.cwd()))
+        is_indexed = status.get("is_indexed", False)
+        console.print(f"  Indexed: {'[green]Yes[/green]' if is_indexed else '[yellow]No[/yellow]'}")
+
+        if is_indexed:
+            console.print(f"  Files: {status.get('file_count', 0)}")
+            console.print(f"  Functions: {status.get('function_count', 0)}")
+            console.print(f"  Classes: {status.get('class_count', 0)}")
+            console.print(f"  Communities: {status.get('community_count', 0)}")
+            if status.get("last_indexed"):
+                console.print(f"  Last indexed: {status.get('last_indexed')}")
+            if status.get("last_commit"):
+                console.print(f"  Last commit: {status.get('last_commit')}")
+    except Exception as e:
+        console.print(f"  [red]Error fetching index status: {e}[/red]")
+
+    console.print()
+
+    # PROJECT.md status
+    console.print("[bold]PROJECT.md Status[/bold]")
+    projectmd_path = Path.cwd() / "PROJECT.md"
+    if projectmd_path.exists():
+        stat = projectmd_path.stat()
+        modified_time = datetime.fromtimestamp(stat.st_mtime)
+        size_kb = stat.st_size / 1024
+        console.print(f"  Exists: [green]Yes[/green]")
+        console.print(f"  Path: {projectmd_path}")
+        console.print(f"  Size: {size_kb:.1f} KB")
+        console.print(f"  Last modified: {modified_time.strftime('%Y-%m-%d %H:%M:%S')}")
+    else:
+        console.print(f"  Exists: [yellow]No[/yellow]")
+        console.print("[dim]  Run /projectmd to generate it[/dim]")
+
+    console.print()
+
+
+def handle_pr(args: str, run_slash_command_task, client, renderer, model, max_iterations) -> None:
+    """Handle /pr command.
+
+    Args:
+        args: PR URL or number
+        run_slash_command_task: Function to run slash command tasks
+        client: EmdashClient instance
+        renderer: SSERenderer instance
+        model: Current model
+        max_iterations: Max iterations
+    """
+    if not args:
+        console.print("[yellow]Usage: /pr <pr-url-or-number>[/yellow]")
+        console.print("[dim]Example: /pr 123 or /pr https://github.com/org/repo/pull/123[/dim]")
+    else:
+        console.print(f"[cyan]Reviewing PR: {args}[/cyan]")
+        run_slash_command_task(
+            client, renderer, model, max_iterations,
+            f"Review this pull request and provide feedback: {args}",
+            {"mode": "code"}
+        )
+
+
+def handle_projectmd(run_slash_command_task, client, renderer, model, max_iterations) -> None:
+    """Handle /projectmd command.
+
+    Args:
+        run_slash_command_task: Function to run slash command tasks
+        client: EmdashClient instance
+        renderer: SSERenderer instance
+        model: Current model
+        max_iterations: Max iterations
+    """
+    console.print("[cyan]Generating PROJECT.md...[/cyan]")
+    run_slash_command_task(
+        client, renderer, model, max_iterations,
+        "Analyze this codebase and generate a comprehensive PROJECT.md file that describes the architecture, main components, how to get started, and key design decisions.",
+        {"mode": "code"}
+    )
+
+
+def handle_research(args: str, run_slash_command_task, client, renderer, model) -> None:
+    """Handle /research command.
+
+    Args:
+        args: Research goal
+        run_slash_command_task: Function to run slash command tasks
+        client: EmdashClient instance
+        renderer: SSERenderer instance
+        model: Current model
+    """
+    if not args:
+        console.print("[yellow]Usage: /research <goal>[/yellow]")
+        console.print("[dim]Example: /research How does authentication work in this codebase?[/dim]")
+    else:
+        console.print(f"[cyan]Researching: {args}[/cyan]")
+        run_slash_command_task(
+            client, renderer, model, 50,  # More iterations for research
+            f"Conduct deep research on: {args}\n\nExplore the codebase thoroughly, analyze relevant code, and provide a comprehensive answer with references to specific files and functions.",
+            {"mode": "plan"}  # Use plan mode for research
+        )
+
+
+def handle_context(renderer) -> None:
+    """Handle /context command.
+
+    Args:
+        renderer: SSERenderer instance with _last_context_frame attribute
+    """
+    context_data = getattr(renderer, '_last_context_frame', None)
+    if not context_data:
+        console.print("\n[dim]No context frame available yet. Run a query first.[/dim]\n")
+    else:
+        adding = context_data.get("adding") or {}
+        reading = context_data.get("reading") or {}
+
+        # Get stats
+        step_count = adding.get("step_count", 0)
+        entities_found = adding.get("entities_found", 0)
+        context_tokens = adding.get("context_tokens", 0)
+        context_breakdown = adding.get("context_breakdown", {})
+
+        console.print()
+        console.print("[bold cyan]Context Frame[/bold cyan]")
+        console.print()
+
+        # Show total context
+        if context_tokens > 0:
+            console.print(f"[bold]Total:[/bold] {context_tokens:,} tokens")
+
+        # Show breakdown
+        if context_breakdown:
+            console.print(f"\n[bold]Breakdown:[/bold]")
+            for key, tokens in context_breakdown.items():
+                if tokens > 0:
+                    console.print(f"  {key}: {tokens:,}")
+
+        # Show stats
+        if step_count > 0 or entities_found > 0:
+            console.print(f"\n[bold]Stats:[/bold]")
+            if step_count > 0:
+                console.print(f"  Steps: {step_count}")
+            if entities_found > 0:
+                console.print(f"  Entities: {entities_found}")
+
+        # Show reranking query
+        query = reading.get("query")
+        if query:
+            console.print(f"\n[bold]Reranking Query:[/bold]")
+            console.print(f"  [yellow]{query}[/yellow]")
+
+        # Show reranked items
+        items = reading.get("items", [])
+        if items:
+            console.print(f"\n[bold]Reranked Items ({len(items)}):[/bold]")
+            for i, item in enumerate(items, 1):
+                name = item.get("name", "?")
+                item_type = item.get("type", "?")
+                score = item.get("score")
+                file_path = item.get("file", "")
+                description = item.get("description", "")
+                touch_count = item.get("touch_count", 0)
+                neighbors = item.get("neighbors", [])
+
+                score_str = f"[cyan]{score:.3f}[/cyan]" if score is not None else "[dim]n/a[/dim]"
+                touch_str = f"[magenta]×{touch_count}[/magenta]" if touch_count > 1 else ""
+
+                console.print(f"\n  [bold white]{i}.[/bold white] [dim]{item_type}[/dim] [bold]{name}[/bold]")
+                console.print(f"     Score: {score_str} {touch_str}")
+                if file_path:
+                    console.print(f"     File: [dim]{file_path}[/dim]")
+                if description:
+                    desc_preview = description[:100] + "..." if len(description) > 100 else description
+                    console.print(f"     Desc: [dim]{desc_preview}[/dim]")
+                if neighbors:
+                    console.print(f"     Neighbors: [dim]{', '.join(neighbors)}[/dim]")
+        else:
+            debug_info = reading.get("debug", "")
+            if debug_info:
+                console.print(f"\n[dim]No reranked items: {debug_info}[/dim]")
+            else:
+                console.print(f"\n[dim]No reranked items yet. Items appear after exploration (file reads, searches).[/dim]")
+        console.print()

emdash_cli/commands/agent/handlers/rules.py

@@ -0,0 +1,394 @@
+"""Handler for /rules command."""
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def get_rules_dir() -> Path:
+    """Get the rules directory path."""
+    return Path.cwd() / ".emdash" / "rules"
+
+
+def list_rules() -> list[dict]:
+    """List all rules files.
+
+    Returns:
+        List of dicts with name, file_path, and preview
+    """
+    rules_dir = get_rules_dir()
+    rules = []
+
+    if not rules_dir.exists():
+        return rules
+
+    for md_file in sorted(rules_dir.glob("*.md")):
+        try:
+            content = md_file.read_text().strip()
+            # Get first non-empty line as preview
+            lines = [l for l in content.split("\n") if l.strip()]
+            preview = lines[0][:60] + "..." if lines and len(lines[0]) > 60 else (lines[0] if lines else "")
+            # Remove markdown heading prefix
+            if preview.startswith("#"):
+                preview = preview.lstrip("#").strip()
+
+            rules.append({
+                "name": md_file.stem,
+                "file_path": str(md_file),
+                "preview": preview,
+            })
+        except Exception:
+            rules.append({
+                "name": md_file.stem,
+                "file_path": str(md_file),
+                "preview": "(error reading file)",
+            })
+
+    return rules
+
+
+def show_rules_interactive_menu() -> tuple[str, str]:
+    """Show interactive rules menu.
+
+    Returns:
+        Tuple of (action, rule_name) where action is one of:
+        - 'view': View rule details
+        - 'create': Create new rule
+        - 'delete': Delete rule
+        - 'cancel': User cancelled
+    """
+    from prompt_toolkit import Application
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.layout import Layout, HSplit, Window, FormattedTextControl
+    from prompt_toolkit.styles import Style
+
+    rules = list_rules()
+
+    # Build menu items: (name, preview, is_action)
+    menu_items = []
+
+    for rule in rules:
+        menu_items.append((rule["name"], rule["preview"], False))
+
+    # Add action items at the bottom
+    menu_items.append(("+ Create New Rule", "Create a new rule with AI assistance", True))
+
+    if not menu_items:
+        menu_items.append(("+ Create New Rule", "Create a new rule with AI assistance", True))
+
+    selected_index = [0]
+    result = [("cancel", "")]
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    def move_up(event):
+        selected_index[0] = (selected_index[0] - 1) % len(menu_items)
+
+    @kb.add("down")
+    @kb.add("j")
+    def move_down(event):
+        selected_index[0] = (selected_index[0] + 1) % len(menu_items)
+
+    @kb.add("enter")
+    def select(event):
+        item = menu_items[selected_index[0]]
+        name, preview, is_action = item
+        if is_action:
+            if "Create" in name:
+                result[0] = ("create", "")
+        else:
+            result[0] = ("view", name)
+        event.app.exit()
+
+    @kb.add("d")
+    def delete_rule(event):
+        item = menu_items[selected_index[0]]
+        name, preview, is_action = item
+        if not is_action:
+            result[0] = ("delete", name)
+            event.app.exit()
+
+    @kb.add("n")
+    def new_rule(event):
+        result[0] = ("create", "")
+        event.app.exit()
+
+    @kb.add("c-c")
+    @kb.add("escape")
+    @kb.add("q")
+    def cancel(event):
+        result[0] = ("cancel", "")
+        event.app.exit()
+
+    def get_formatted_menu():
+        lines = [("class:title", "Rules\n\n")]
+
+        if not rules:
+            lines.append(("class:dim", "No rules defined yet.\n\n"))
+
+        for i, (name, preview, is_action) in enumerate(menu_items):
+            is_selected = i == selected_index[0]
+            prefix = "❯ " if is_selected else "  "
+
+            if is_action:
+                if is_selected:
+                    lines.append(("class:action-selected", f"{prefix}{name}\n"))
+                else:
+                    lines.append(("class:action", f"{prefix}{name}\n"))
+            else:
+                if is_selected:
+                    lines.append(("class:rule-selected", f"{prefix}{name}"))
+                    lines.append(("class:preview-selected", f" - {preview}\n"))
+                else:
+                    lines.append(("class:rule", f"{prefix}{name}"))
+                    lines.append(("class:preview", f" - {preview}\n"))
+
+        lines.append(("class:hint", "\n↑/↓ navigate • Enter view • n new • d delete • q quit"))
+        return lines
+
+    style = Style.from_dict({
+        "title": "#00ccff bold",
+        "dim": "#666666",
+        "rule": "#00ccff",
+        "rule-selected": "#00cc66 bold",
+        "action": "#ffcc00",
+        "action-selected": "#ffcc00 bold",
+        "preview": "#666666",
+        "preview-selected": "#00cc66",
+        "hint": "#888888 italic",
+    })
+
+    height = len(menu_items) + 5  # items + title + hint + padding
+
+    layout = Layout(
+        HSplit([
+            Window(
+                FormattedTextControl(get_formatted_menu),
+                height=height,
+            ),
+        ])
+    )
+
+    app = Application(
+        layout=layout,
+        key_bindings=kb,
+        style=style,
+        full_screen=False,
+    )
+
+    console.print()
+
+    try:
+        app.run()
+    except (KeyboardInterrupt, EOFError):
+        result[0] = ("cancel", "")
+
+    # Clear menu visually with separator
+    console.print()
+
+    return result[0]
+
+
+def show_rule_details(name: str) -> None:
+    """Show detailed view of a rule."""
+    rules_dir = get_rules_dir()
+    rule_file = rules_dir / f"{name}.md"
+
+    console.print()
+    console.print("[dim]─" * 50 + "[/dim]")
+    console.print()
+
+    if rule_file.exists():
+        try:
+            content = rule_file.read_text()
+            console.print(f"[bold cyan]{name}[/bold cyan]\n")
+            console.print(f"[bold]File:[/bold] {rule_file}\n")
+            console.print(Panel(content, border_style="dim"))
+        except Exception as e:
+            console.print(f"[red]Error reading rule: {e}[/red]")
+    else:
+        console.print(f"[yellow]Rule '{name}' not found[/yellow]")
+
+    console.print()
+    console.print("[dim]─" * 50 + "[/dim]")
+
+
+def confirm_delete(rule_name: str) -> bool:
+    """Confirm rule deletion."""
+    from prompt_toolkit import PromptSession
+
+    console.print()
+    console.print(f"[yellow]Delete rule '{rule_name}'?[/yellow]")
+    console.print("[dim]This will remove the rule file. Type 'yes' to confirm.[/dim]")
+
+    try:
+        session = PromptSession()
+        response = session.prompt("Confirm > ").strip().lower()
+        return response in ("yes", "y")
+    except (KeyboardInterrupt, EOFError):
+        return False
+
+
+def delete_rule(name: str) -> bool:
+    """Delete a rule file."""
+    rules_dir = get_rules_dir()
+    rule_file = rules_dir / f"{name}.md"
+
+    if not rule_file.exists():
+        console.print(f"[yellow]Rule file not found: {rule_file}[/yellow]")
+        return False
+
+    if confirm_delete(name):
+        rule_file.unlink()
+        console.print(f"[green]Deleted rule: {name}[/green]")
+        return True
+    else:
+        console.print("[dim]Cancelled[/dim]")
+        return False
+
+
+def chat_create_rule(client, renderer, model, max_iterations, render_with_interrupt) -> None:
+    """Start a chat session to create a new rule with AI assistance."""
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.styles import Style
+
+    rules_dir = get_rules_dir()
+
+    console.print()
+    console.print("[bold cyan]Create New Rule[/bold cyan]")
+    console.print("[dim]Describe what rule you want to create. The AI will help you write 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 rules directory exists
+    rules_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 rules
+            if first_message:
+                message_with_context = f"""I want to create a new rule file for my project.
+
+**Rules directory:** `{rules_dir}`
+
+Rules are markdown files that define guidelines for the AI agent. They are stored in `.emdash/rules/` and get injected into the agent's system prompt.
+
+Example rule file:
+```markdown
+# Code Style Guidelines
+
+- Use meaningful variable names
+- Keep functions small and focused
+- Add comments for complex logic
+```
+
+**My request:** {user_input}
+
+Please help me create a rule file. Ask me questions if needed to understand what rules I want, then use the Write tool to create the file at `{rules_dir}/<rule-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]")
+
+
+def handle_rules(args: str, client, renderer, model, max_iterations, render_with_interrupt) -> None:
+    """Handle /rules command."""
+    from prompt_toolkit import PromptSession
+
+    # Handle subcommands
+    if args:
+        subparts = args.split(maxsplit=1)
+        subcommand = subparts[0].lower()
+        subargs = subparts[1] if len(subparts) > 1 else ""
+
+        if subcommand == "list":
+            rules = list_rules()
+            if rules:
+                console.print("\n[bold cyan]Rules[/bold cyan]\n")
+                for rule in rules:
+                    console.print(f"  [cyan]{rule['name']}[/cyan] - {rule['preview']}")
+                console.print()
+            else:
+                console.print("\n[dim]No rules defined yet.[/dim]")
+                console.print(f"[dim]Rules directory: {get_rules_dir()}[/dim]\n")
+        elif subcommand == "show" and subargs:
+            show_rule_details(subargs.strip())
+        elif subcommand == "delete" and subargs:
+            delete_rule(subargs.strip())
+        elif subcommand == "add" or subcommand == "create" or subcommand == "new":
+            chat_create_rule(client, renderer, model, max_iterations, render_with_interrupt)
+        else:
+            console.print("[yellow]Usage: /rules [list|show|add|delete] [name][/yellow]")
+            console.print("[dim]Or just /rules for interactive menu[/dim]")
+    else:
+        # Interactive menu
+        while True:
+            action, rule_name = show_rules_interactive_menu()
+
+            if action == "cancel":
+                break
+            elif action == "view":
+                show_rule_details(rule_name)
+                # After viewing, show options
+                try:
+                    console.print("[dim]'d' delete • Enter back[/dim]", end="")
+                    ps = PromptSession()
+                    resp = ps.prompt(" ").strip().lower()
+                    if resp == 'd':
+                        delete_rule(rule_name)
+                    console.print()
+                except (KeyboardInterrupt, EOFError):
+                    break
+            elif action == "create":
+                chat_create_rule(client, renderer, model, max_iterations, render_with_interrupt)
+                # Refresh menu after creating
+            elif action == "delete":
+                delete_rule(rule_name)