codegraph-cli 2.0.0__py3-none-any.whl

codegraph_cli/cli.py

@@ -0,0 +1,330 @@
+"""Typer-based CLI for CodeGraph local code intelligence."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from . import __version__, config
+from .cli_chat import chat_app
+from .cli_setup import setup as setup_wizard, set_llm, unset_llm, show_llm
+from .cli_v2 import v2_app
+from .graph_export import export_dot, export_html
+from .orchestrator import MCPOrchestrator
+from .storage import GraphStore, ProjectManager
+
+app = typer.Typer(
+    help="🧠 CodeGraph CLI — AI-powered code intelligence & multi-agent assistant.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# Register v2 commands
+app.add_typer(v2_app, name="v2")
+
+# Register chat commands
+app.add_typer(chat_app, name="chat")
+
+# Register setup wizard as direct command
+app.command("setup")(setup_wizard)
+
+# Register LLM management commands
+app.command("set-llm")(set_llm)
+app.command("unset-llm")(unset_llm)
+app.command("show-llm")(show_llm)
+
+
+def version_callback(value: bool):
+    """Print version and exit."""
+    if value:
+        typer.echo(f"CodeGraph CLI v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        callback=version_callback,
+        is_eager=True,
+    )
+):
+    """CodeGraph CLI: Local-first code intelligence with AI-powered impact analysis."""
+    pass
+
+
+def _project_name_from_path(project_path: Path) -> str:
+    return project_path.resolve().name.replace(" ", "_")
+
+
+def _open_current_store(pm: ProjectManager) -> GraphStore:
+    project = pm.get_current_project()
+    if not project:
+        raise typer.BadParameter("No project loaded. Use 'cg load-project <name>' or run 'cg index <path>'.")
+    project_dir = pm.project_dir(project)
+    if not project_dir.exists():
+        raise typer.BadParameter(f"Loaded project '{project}' does not exist in memory.")
+    return GraphStore(project_dir)
+
+
+@app.command("index")
+def index_project(
+    project_path: Path = typer.Argument(..., exists=True, file_okay=False, help="Path to source project."),
+    project_name: Optional[str] = typer.Option(None, "--name", "-n", help="Explicit memory name for project."),
+    llm_model: str = typer.Option("qwen2.5-coder:7b", help="Local LLM model name for reasoning operations."),
+    llm_provider: str = typer.Option("ollama", help="LLM provider: ollama, groq, openai, anthropic."),
+    llm_api_key: Optional[str] = typer.Option(None, help="API key for cloud LLM providers."),
+):
+    """Parse and index a project into local semantic memory."""
+    from datetime import datetime
+    
+    pm = ProjectManager()
+    resolved_path = project_path.resolve()
+    name = project_name or _project_name_from_path(resolved_path)
+    project_dir = pm.create_or_get_project(name)
+
+    store = GraphStore(project_dir)
+    orchestrator = MCPOrchestrator(
+        store,
+        llm_model=llm_model,
+        llm_provider=llm_provider,
+        llm_api_key=llm_api_key,
+    )
+    stats = orchestrator.index(resolved_path)
+    
+    # Store project metadata including source path
+    store.set_metadata({
+        **store.get_metadata(),
+        "project_name": name,
+        "source_path": str(resolved_path),
+        "indexed_at": datetime.now().isoformat()
+    })
+    
+    pm.set_current_project(name)
+    store.close()
+
+    typer.echo(f"Indexed '{resolved_path}' as project '{name}'.")
+    typer.echo(f"Nodes: {stats['nodes']} | Edges: {stats['edges']}")
+
+
+@app.command("list-projects")
+def list_projects():
+    """List all persisted project memories."""
+    pm = ProjectManager()
+    projects = pm.list_projects()
+    current = pm.get_current_project()
+
+    if not projects:
+        typer.echo("No projects indexed yet.")
+        raise typer.Exit(code=0)
+
+    for p in projects:
+        marker = "*" if p == current else " "
+        typer.echo(f"{marker} {p}")
+
+
+@app.command("load-project")
+def load_project(project_name: str = typer.Argument(..., help="Name of project memory to load.")):
+    """Switch active project memory."""
+    pm = ProjectManager()
+    if project_name not in pm.list_projects():
+        raise typer.BadParameter(f"Project '{project_name}' not found.")
+    pm.set_current_project(project_name)
+    typer.echo(f"Loaded project '{project_name}'.")
+
+
+@app.command("unload-project")
+def unload_project():
+    """Unload active project memory without deleting data."""
+    pm = ProjectManager()
+    pm.unload_project()
+    typer.echo("Unloaded active project.")
+
+
+@app.command("delete-project")
+def delete_project(project_name: str = typer.Argument(..., help="Project memory to delete.")):
+    """Delete persisted project memory."""
+    pm = ProjectManager()
+    deleted = pm.delete_project(project_name)
+    if not deleted:
+        raise typer.BadParameter(f"Project '{project_name}' not found.")
+    if pm.get_current_project() == project_name:
+        pm.unload_project()
+    typer.echo(f"Deleted project '{project_name}'.")
+
+
+@app.command("merge-projects")
+def merge_projects(
+    source_project: str = typer.Argument(..., help="Project to merge from."),
+    target_project: str = typer.Argument(..., help="Project to merge into."),
+):
+    """Merge one project memory into another."""
+    pm = ProjectManager()
+    if source_project not in pm.list_projects() or target_project not in pm.list_projects():
+        raise typer.BadParameter("Both source and target projects must exist.")
+
+    source_store = GraphStore(pm.project_dir(source_project))
+    target_store = GraphStore(pm.project_dir(target_project))
+    target_store.merge_from(source_store, source_project)
+    source_store.close()
+    target_store.close()
+
+    typer.echo(f"Merged '{source_project}' into '{target_project}'.")
+
+
+@app.command("search")
+def search(
+    query: str = typer.Argument(..., help="Semantic query for code discovery."),
+    top_k: int = typer.Option(5, min=1, max=30, help="Maximum number of matches."),
+):
+    """Run semantic search across currently loaded project memory."""
+    pm = ProjectManager()
+    store = _open_current_store(pm)
+    orchestrator = MCPOrchestrator(store)
+    results = orchestrator.search(query, top_k=top_k)
+
+    if not results:
+        typer.echo("No semantic matches found.")
+        store.close()
+        raise typer.Exit(code=0)
+
+    for item in results:
+        typer.echo(f"[{item.node_type}] {item.qualname}  score={item.score:.3f}")
+        typer.echo(f"  {item.file_path}:{item.start_line}-{item.end_line}")
+        snippet = item.snippet.strip().splitlines()
+        if snippet:
+            typer.echo(f"  {snippet[0][:120]}")
+
+    store.close()
+
+
+@app.command("impact")
+def impact(
+    symbol: str = typer.Argument(..., help="Function/class/module symbol to analyze."),
+    hops: int = typer.Option(2, min=1, max=6, help="Dependency traversal depth."),
+    show_graph: bool = typer.Option(True, "--show-graph/--no-graph", help="Include ASCII graph output."),
+    llm_provider: str = typer.Option(
+        config.LLM_PROVIDER,
+        help="LLM provider: ollama, groq, openai, anthropic, gemini, openrouter.",
+    ),
+    llm_api_key: Optional[str] = typer.Option(
+        config.LLM_API_KEY or None,
+        help="API key for cloud LLM providers.",
+    ),
+    llm_model: str = typer.Option(
+        config.LLM_MODEL,
+        help="LLM model name.",
+    ),
+):
+    """Run multi-hop impact analysis using graph + RAG + local LLM."""
+    pm = ProjectManager()
+    store = _open_current_store(pm)
+    orchestrator = MCPOrchestrator(
+        store,
+        llm_model=llm_model,
+        llm_provider=llm_provider,
+        llm_api_key=llm_api_key,
+    )
+
+    report = orchestrator.impact(symbol, hops=hops)
+    
+    # Check if symbol was found
+    if "not found" in report.explanation.lower() and not report.impacted:
+        typer.echo(f"❌ Symbol '{symbol}' not found in current project.", err=True)
+        
+        # Try to find similar symbols
+        search_results = orchestrator.search(symbol, top_k=3)
+        if search_results:
+            typer.echo(f"\n💡 Did you mean one of these?", err=True)
+            for result in search_results:
+                typer.echo(f"   - {result.qualname} ({result.node_type})", err=True)
+            typer.echo(f"\n💡 Tip: Use 'cg search {symbol}' to find similar symbols", err=True)
+        store.close()
+        raise typer.Exit(code=1)
+    
+    typer.echo(f"Root: {report.root}")
+    if report.impacted:
+        typer.echo("Impacted symbols:")
+        for impacted in report.impacted:
+            typer.echo(f"- {impacted}")
+    else:
+        typer.echo("Impacted symbols: none found")
+
+    if show_graph:
+        typer.echo("\nASCII graph:")
+        typer.echo(report.ascii_graph)
+
+    typer.echo("\nExplanation:")
+    typer.echo(report.explanation)
+    store.close()
+
+
+@app.command("graph")
+def graph(
+    symbol: str = typer.Argument(..., help="Function/class/module symbol to inspect."),
+    depth: int = typer.Option(2, min=1, max=6, help="Traversal depth."),
+):
+    """Show lightweight ASCII dependency graph around a symbol."""
+    pm = ProjectManager()
+    store = _open_current_store(pm)
+    orchestrator = MCPOrchestrator(store)
+    text = orchestrator.graph(symbol, depth=depth)
+    typer.echo(text)
+    store.close()
+
+
+@app.command("export-graph")
+def export_graph(
+    symbol: str = typer.Argument("", help="Optional focus symbol to export local subgraph."),
+    fmt: str = typer.Option("html", "--format", "-f", help="Export format: html or dot."),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path."),
+):
+    """Export graph to standalone HTML or Graphviz DOT."""
+    fmt = fmt.lower()
+    if fmt not in {"html", "dot"}:
+        raise typer.BadParameter("Format must be one of: html, dot")
+
+    pm = ProjectManager()
+    store = _open_current_store(pm)
+    current = pm.get_current_project() or "project"
+
+    if output is None:
+        output = Path.cwd() / f"{current}_graph.{fmt}"
+
+    if fmt == "html":
+        export_html(store, output, focus=symbol)
+    else:
+        export_dot(store, output, focus=symbol)
+
+    typer.echo(f"Exported graph to {output}")
+    store.close()
+
+
+@app.command("current-project")
+def current_project():
+    """Print active project memory name."""
+    pm = ProjectManager()
+    current = pm.get_current_project()
+    typer.echo(current or "No project loaded")
+
+
+@app.command("rag-context")
+def rag_context(
+    query: str = typer.Argument(..., help="Query to retrieve code context without analysis."),
+    top_k: int = typer.Option(6, min=1, max=30, help="Number of snippets to fetch."),
+):
+    """Retrieve top semantic snippets to inspect RAG context directly."""
+    pm = ProjectManager()
+    store = _open_current_store(pm)
+    orchestrator = MCPOrchestrator(store)
+    typer.echo(orchestrator.rag_context(query, top_k=top_k))
+    store.close()
+
+
+if __name__ == "__main__":
+    app()

codegraph_cli/cli_chat.py

@@ -0,0 +1,367 @@
+"""Interactive chat CLI for conversational coding assistance."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from . import config
+from .chat_agent import ChatAgent
+from .chat_session import SessionManager
+from .crew_chat import CrewChatAgent
+from .llm import LocalLLM
+from .orchestrator import MCPOrchestrator
+from .rag import RAGRetriever
+from .storage import GraphStore, ProjectManager
+
+
+# ── Theme colors ──────────────────────────────────────────────
+C_RESET = "\033[0m"
+C_BOLD = "\033[1m"
+C_DIM = "\033[2m"
+C_CYAN = "\033[36m"
+C_GREEN = "\033[32m"
+C_YELLOW = "\033[33m"
+C_MAGENTA = "\033[35m"
+C_RED = "\033[31m"
+C_BLUE = "\033[34m"
+C_WHITE = "\033[97m"
+C_BG_DARK = "\033[48;5;235m"
+
+
+def _term_width() -> int:
+    """Get terminal width, default 80."""
+    return shutil.get_terminal_size((80, 24)).columns
+
+
+def _box(text: str, color: str = C_CYAN, width: int = 0) -> str:
+    """Draw a box around text."""
+    w = width or min(_term_width(), 70)
+    inner = w - 4
+    lines = text.split("\n")
+    out = [f"{color}╭{'─' * (w - 2)}╮{C_RESET}"]
+    for line in lines:
+        padded = line.ljust(inner)[:inner]
+        out.append(f"{color}│{C_RESET} {padded} {color}│{C_RESET}")
+    out.append(f"{color}╰{'─' * (w - 2)}╯{C_RESET}")
+    return "\n".join(out)
+
+
+def _divider(char: str = "─", color: str = C_DIM) -> str:
+    w = min(_term_width(), 70)
+    return f"{color}{char * w}{C_RESET}"
+
+
+def _print_welcome(project_name: str, use_crew: bool, provider: str, model: str):
+    """Print the modern welcome banner."""
+    mode = "CrewAI Multi-Agent" if use_crew else "Chat"
+    
+    banner = (
+        f"  {C_BOLD}{C_CYAN}⚡ CodeGraph {mode}{C_RESET}\n"
+        f"  {C_DIM}Project: {C_WHITE}{project_name}{C_RESET}\n"
+        f"  {C_DIM}LLM:     {C_WHITE}{provider}/{model}{C_RESET}"
+    )
+    print(f"\n{_box(f'⚡ CodeGraph {mode}', C_CYAN)}")
+    print(f"  {C_DIM}Project  {C_RESET}{C_WHITE}{project_name}{C_RESET}")
+    print(f"  {C_DIM}LLM      {C_RESET}{C_WHITE}{provider}/{model}{C_RESET}")
+    print(f"  {C_DIM}Type {C_YELLOW}/help{C_DIM} for commands, {C_YELLOW}/exit{C_DIM} to quit{C_RESET}")
+    print(_divider())
+    print()
+
+
+def _print_help(use_crew: bool):
+    """Print help with styled formatting."""
+    print(f"\n  {C_BOLD}{C_CYAN}📖 Commands{C_RESET}")
+    print(_divider("─", C_DIM))
+    cmds = [
+        ("/exit", "Exit chat session"),
+        ("/clear", "Clear conversation history & start fresh"),
+        ("/new", "Start a brand new session"),
+        ("/help", "Show this help"),
+    ]
+    if use_crew:
+        cmds.extend([
+            ("/backups", "List all file backups"),
+            ("/rollback <file>", "Rollback a file to its last backup"),
+            ("/undo <file>", "Alias for /rollback"),
+        ])
+    else:
+        cmds.extend([
+            ("/apply", "Apply pending code proposal"),
+            ("/preview", "Preview pending changes"),
+        ])
+    for cmd, desc in cmds:
+        print(f"  {C_YELLOW}{cmd:<22}{C_RESET}{C_DIM}{desc}{C_RESET}")
+    print()
+
+
+def _print_response(text: str):
+    """Print assistant response with styling."""
+    print(f"\n  {C_GREEN}●{C_RESET} {C_BOLD}Assistant{C_RESET}")
+    # Indent each line for clean look
+    for line in text.split("\n"):
+        print(f"  {line}")
+    print()
+
+
+def _print_status(emoji: str, msg: str, color: str = C_GREEN):
+    """Print a status message."""
+    print(f"  {color}{emoji}  {msg}{C_RESET}")
+
+
+def start_chat_repl(
+    agent,  # Can be ChatAgent or CrewChatAgent
+    session_manager: SessionManager,
+    project_name: str,
+    session_id: Optional[str] = None,
+    use_crew: bool = False,
+    provider: str = "",
+    model: str = "",
+):
+    """Start interactive REPL for chat."""
+    # Load or create session
+    if session_id:
+        session = session_manager.load_session(session_id)
+        if not session:
+            _print_status("🆕", "Session not found. Starting new session.", C_YELLOW)
+            session = session_manager.create_session(project_name)
+        else:
+            _print_status("📂", f"Resumed session ({session.message_count} messages)")
+    else:
+        # Try to load latest session for this project
+        latest_id = session_manager.get_latest_session(project_name)
+        if latest_id:
+            session = session_manager.load_session(latest_id)
+            _print_status("📂", f"Resumed session ({session.message_count} messages)")
+        else:
+            session = session_manager.create_session(project_name)
+            _print_status("🆕", "Started new chat session")
+    
+    # Welcome
+    _print_welcome(project_name, use_crew, provider, model)
+    
+    # REPL loop
+    while True:
+        try:
+            # Prompt
+            try:
+                user_input = input(f"  {C_BLUE}●{C_RESET} {C_BOLD}You ›{C_RESET} ").strip()
+            except EOFError:
+                print(f"\n  {C_DIM}👋 Goodbye! Session saved.{C_RESET}\n")
+                break
+            
+            if not user_input:
+                continue
+            
+            # ── Handle commands ──────────────────────────────
+            if user_input.startswith("/"):
+                cmd = user_input.lower().split()[0]
+                
+                if cmd == "/exit":
+                    session_manager.save_session(session)
+                    print(f"\n  {C_DIM}👋 Goodbye! Session saved.{C_RESET}\n")
+                    break
+                
+                elif cmd == "/clear":
+                    session.clear_history()
+                    session.clear_proposals()
+                    session_manager.save_session(session)
+                    _print_status("🧹", "Conversation cleared. Fresh start!", C_GREEN)
+                    print()
+                    continue
+                
+                elif cmd == "/new":
+                    session_manager.save_session(session)
+                    session = session_manager.create_session(project_name)
+                    _print_status("🆕", "New session started.", C_GREEN)
+                    print()
+                    continue
+                
+                elif cmd == "/help":
+                    _print_help(use_crew)
+                    continue
+                
+                elif not use_crew:
+                    if cmd == "/apply":
+                        if hasattr(agent, 'apply_pending_proposal'):
+                            result = agent.apply_pending_proposal(session)
+                            _print_status("📋", result)
+                        else:
+                            _print_status("📋", "No pending proposals.", C_YELLOW)
+                        continue
+                    elif cmd == "/preview":
+                        if session.pending_proposals:
+                            for i, prop in enumerate(session.pending_proposals):
+                                print(f"\n  {C_BOLD}Proposal {i+1}:{C_RESET} {prop.description}")
+                                for ch in prop.changes:
+                                    icon = {"create": "🆕", "modify": "✏️", "delete": "🗑️"}.get(ch.change_type, "📄")
+                                    print(f"    {icon} {ch.file_path}")
+                        else:
+                            _print_status("📋", "No pending proposals.", C_YELLOW)
+                        print()
+                        continue
+                
+                elif use_crew:
+                    if cmd in ("/rollback", "/undo"):
+                        parts = user_input.split(maxsplit=1)
+                        if len(parts) < 2:
+                            _print_status("❓", "Usage: /rollback <file_path> [timestamp]", C_YELLOW)
+                            continue
+                        args = parts[1].split()
+                        file_path = args[0]
+                        ts = args[1] if len(args) > 1 else None
+                        result = agent.rollback(file_path, ts)
+                        _print_status("⏪", result)
+                        print()
+                        continue
+                    
+                    elif cmd == "/backups":
+                        backups = agent.list_all_backups()
+                        if not backups:
+                            _print_status("📦", "No backups found.", C_YELLOW)
+                        else:
+                            print(f"\n  {C_BOLD}{C_CYAN}📦 File Backups{C_RESET}")
+                            print(_divider("─", C_DIM))
+                            for b in backups:
+                                ts = b["timestamp"]
+                                fp = b["original_path"]
+                                print(f"  {C_WHITE}{ts}{C_RESET}  {C_DIM}{fp}{C_RESET}")
+                            print(f"\n  {C_DIM}Use /rollback <file_path> to restore{C_RESET}")
+                        print()
+                        continue
+                
+                _print_status("❓", f"Unknown command: {cmd}. Type /help", C_YELLOW)
+                continue
+            
+            # ── Process message ──────────────────────────────
+            session.add_message("user", user_input, datetime.now().isoformat())
+            
+            # Show thinking indicator
+            print(f"\n  {C_DIM}⏳ Thinking...{C_RESET}", end="", flush=True)
+            
+            if use_crew:
+                response = agent.process_message(user_input)
+            else:
+                response = agent.process_message(user_input, session)
+            
+            # Clear thinking indicator
+            print(f"\r{' ' * 30}\r", end="")
+            
+            # Save & display
+            session.add_message("assistant", response, datetime.now().isoformat())
+            session_manager.save_session(session)
+            
+            _print_response(response)
+            
+        except KeyboardInterrupt:
+            session_manager.save_session(session)
+            print(f"\n\n  {C_DIM}👋 Goodbye! Session saved.{C_RESET}\n")
+            break
+        except Exception as e:
+            print(f"\n  {C_RED}❌ Error: {str(e)}{C_RESET}\n")
+
+
+# ── Typer app ────────────────────────────────────────────────
+chat_app = typer.Typer(help="💬 Interactive chat with AI agents")
+
+
+@chat_app.command("start")
+def start_chat(
+    session_id: Optional[str] = typer.Option(None, "--session", "-s", help="Resume specific session ID"),
+    llm_model: str = typer.Option(config.LLM_MODEL, help="LLM model to use"),
+    llm_provider: str = typer.Option(config.LLM_PROVIDER, help="LLM provider"),
+    llm_api_key: Optional[str] = typer.Option(config.LLM_API_KEY, help="API key for cloud providers"),
+    llm_endpoint: Optional[str] = typer.Option(config.LLM_ENDPOINT, help="LLM endpoint URL"),
+    use_crew: bool = typer.Option(False, "--crew", help="Use CrewAI multi-agent system"),
+    new_session: bool = typer.Option(False, "--new", "-n", help="Force start a new session"),
+):
+    """Start interactive chat session."""
+    from .embeddings import HashEmbeddingModel
+    from .project_context import ProjectContext
+    
+    pm = ProjectManager()
+    project = pm.get_current_project()
+    
+    if not project:
+        print(f"\n  {C_RED}❌ No project loaded.{C_RESET}")
+        print(f"  {C_DIM}Use: cg load-project <name>  or  cg index <path>{C_RESET}\n")
+        raise typer.Exit(1)
+    
+    # Initialize components
+    context = ProjectContext(project, pm)
+    embedding_model = HashEmbeddingModel()
+    llm = LocalLLM(model=llm_model, provider=llm_provider, api_key=llm_api_key, endpoint=llm_endpoint)
+    rag_retriever = RAGRetriever(context.store, embedding_model)
+    
+    if use_crew:
+        print(f"\n  {C_MAGENTA}🤖 Initializing CrewAI multi-agent system...{C_RESET}")
+        agent = CrewChatAgent(context, llm, rag_retriever)
+    else:
+        orchestrator = MCPOrchestrator(
+            context.store,
+            llm_model=llm_model,
+            llm_provider=llm_provider,
+            llm_api_key=llm_api_key,
+            llm_endpoint=llm_endpoint
+        )
+        agent = ChatAgent(context, llm, orchestrator, rag_retriever)
+    
+    session_manager = SessionManager()
+    
+    # Force new session if requested
+    effective_session_id = None if new_session else session_id
+    
+    try:
+        start_chat_repl(
+            agent, session_manager, project, effective_session_id,
+            use_crew=use_crew,
+            provider=llm_provider,
+            model=llm_model,
+        )
+    finally:
+        context.close()
+
+
+@chat_app.command("list")
+def list_sessions(
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Filter by project")
+):
+    """List all chat sessions."""
+    session_manager = SessionManager()
+    sessions = session_manager.list_sessions(project_name=project)
+    
+    if not sessions:
+        print(f"\n  {C_DIM}No chat sessions found.{C_RESET}\n")
+        return
+    
+    print(f"\n  {C_BOLD}{C_CYAN}📋 Chat Sessions ({len(sessions)}){C_RESET}")
+    print(_divider())
+    
+    for i, sess in enumerate(sessions, 1):
+        created = sess['created_at'][:16].replace("T", " ")
+        msgs = sess['message_count']
+        proj = sess['project_name']
+        sid = sess['id'][:8]
+        
+        print(f"  {C_WHITE}{i}.{C_RESET} {C_BOLD}{proj}{C_RESET}  {C_DIM}({msgs} msgs, {created}){C_RESET}  {C_DIM}id:{sid}…{C_RESET}")
+    
+    print()
+
+
+@chat_app.command("delete")
+def delete_session(
+    session_id: str = typer.Argument(..., help="Session ID to delete")
+):
+    """Delete a chat session."""
+    session_manager = SessionManager()
+    
+    if session_manager.delete_session(session_id):
+        _print_status("✅", f"Deleted session {session_id[:8]}…")
+    else:
+        print(f"  {C_RED}❌ Session not found{C_RESET}")
+        raise typer.Exit(1)