connectonion 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

connectonion/cli/co_ai/commands/cost.py

@@ -0,0 +1,77 @@
+"""Cost command for showing session spending."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+# Module-level storage for agent reference
+_current_agent = None
+
+
+def set_agent(agent):
+    """Set the current agent for cost tracking."""
+    global _current_agent
+    _current_agent = agent
+
+
+def cmd_cost(args: str = "") -> str:
+    """
+    Display cost and token usage for the current session.
+
+    Shows:
+    - Total cost
+    - Token usage (input/output)
+    - Context usage percentage
+    - Model being used
+    """
+    if _current_agent is None:
+        console.print("[yellow]No agent session active. Start a conversation first.[/]")
+        return "No session"
+
+    agent = _current_agent
+
+    # Build cost table
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Label", style="dim")
+    table.add_column("Value", style="cyan")
+
+    # Model
+    model = getattr(agent.llm, 'model', 'unknown')
+    table.add_row("Model", model)
+
+    # Cost
+    total_cost = getattr(agent, 'total_cost', 0)
+    if total_cost > 0:
+        cost_str = f"${total_cost:.4f}" if total_cost < 0.01 else f"${total_cost:.2f}"
+    else:
+        cost_str = "$0.00"
+    table.add_row("Total Cost", cost_str)
+
+    # Token usage
+    last_usage = getattr(agent, 'last_usage', None)
+    if last_usage:
+        input_tokens = last_usage.get('input_tokens', 0)
+        output_tokens = last_usage.get('output_tokens', 0)
+        table.add_row("Input Tokens", f"{input_tokens:,}")
+        table.add_row("Output Tokens", f"{output_tokens:,}")
+        table.add_row("Total Tokens", f"{input_tokens + output_tokens:,}")
+
+    # Context usage
+    context_percent = getattr(agent, 'context_percent', 0)
+    if context_percent > 0:
+        bar_width = 20
+        filled = int(bar_width * context_percent / 100)
+        bar = "█" * filled + "░" * (bar_width - filled)
+        color = "green" if context_percent < 50 else "yellow" if context_percent < 80 else "red"
+        table.add_row("Context Usage", f"[{color}]{bar}[/] {context_percent:.0f}%")
+
+    # Messages count
+    if hasattr(agent, 'current_session') and agent.current_session:
+        messages = agent.current_session.get('messages', [])
+        table.add_row("Messages", str(len(messages)))
+
+    console.print(Panel(table, title="💰 Session Cost", border_style="green"))
+
+    return f"Cost: {cost_str}"

connectonion/cli/co_ai/commands/export.py

@@ -0,0 +1,60 @@
+"""Export command - export conversation to markdown."""
+
+import os
+import subprocess
+import tempfile
+from datetime import datetime
+
+_agent = None
+
+
+def set_agent(agent):
+    global _agent
+    _agent = agent
+
+
+def cmd_export(args: str = "") -> str:
+    if not _agent:
+        return "No active conversation to export."
+    
+    messages = getattr(_agent, 'messages', [])
+    if not messages:
+        return "No messages to export."
+    
+    lines = [
+        f"# Conversation Export",
+        f"",
+        f"**Date:** {datetime.now().strftime('%Y-%m-%d %H:%M')}",
+        f"**Model:** {_agent.llm.model if hasattr(_agent, 'llm') else 'unknown'}",
+        f"",
+        "---",
+        "",
+    ]
+    
+    for msg in messages:
+        role = msg.get('role', 'unknown')
+        content = msg.get('content', '')
+        
+        if role == 'user':
+            lines.append(f"## User\n\n{content}\n")
+        elif role == 'assistant':
+            lines.append(f"## Assistant\n\n{content}\n")
+        elif role == 'tool':
+            tool_name = msg.get('name', 'tool')
+            lines.append(f"### Tool: {tool_name}\n\n```\n{content}\n```\n")
+    
+    markdown = "\n".join(lines)
+    
+    editor = os.environ.get("EDITOR", "vim")
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:
+        f.write(markdown)
+        f.flush()
+        temp_path = f.name
+    
+    editor_parts = editor.split()
+    cmd = editor_parts + [temp_path]
+    
+    subprocess.run(cmd)
+    
+    return f"Exported to `{temp_path}`"

connectonion/cli/co_ai/commands/help.py

@@ -0,0 +1,80 @@
+"""Help command for OO CLI."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+
+console = Console()
+
+HELP_TEXT = """
+# OO Commands
+
+## Built-in Commands
+
+| Command | Description |
+|---------|-------------|
+| `/init` | Initialize .co/OO.md for the project |
+| `/review-pr` | Review a GitHub PR (agent skill) |
+| `/cost` | Show session cost and token usage |
+| `/compact` | Compress conversation (LLM summarization) |
+| `/tasks` | List background tasks |
+| `/help` | Show this help message |
+| `clear` | Clear the screen |
+| `exit` | Exit OO |
+
+## Usage
+
+```bash
+# One-shot mode
+oo "fix the bug in auth.py"
+
+# Interactive mode
+oo
+
+# With options
+oo -m co/gemini-2.5-pro "task"   # Use different model
+oo -y "task"                      # Auto-approve file changes
+```
+
+## Agent Tools
+
+**Search:** `glob`, `grep`
+**Files:** `read_file`, `edit`, `write`
+**Execute:** `bash`
+**Sub-agents:** `task` (explore, plan)
+**Plan Mode:** `enter_plan_mode`, `exit_plan_mode`
+**Interaction:** `ask_user`, `confirm`
+**Skills:** `skill` (auto-invoked when relevant)
+**Background:** `run_background`, `task_output`, `kill_task`
+
+## Skills
+
+Skills are auto-discovered instruction sets. Built-in skills:
+- `commit` - Create git commits with good messages
+- `review-pr` - Review GitHub pull requests
+
+Add custom skills in `.co/skills/skill-name/SKILL.md`
+
+## Configuration
+
+OO reads context from (in priority order):
+1. `.co/OO.md` - OO-specific instructions
+2. `CLAUDE.md` - Compatibility with Claude Code
+3. `README.md` - Project understanding
+
+Run `/init` to create `.co/OO.md` for your project.
+
+## Tips
+
+- Use `@` to autocomplete file paths
+- Use `/` to autocomplete commands
+- Use `/cost` to check spending
+- Use `/compact` when context is high (>70%)
+- Use `/tasks` to monitor background operations
+"""
+
+
+def cmd_help(args: str = "") -> str:
+    """Show help message."""
+    console.print(Panel(Markdown(HELP_TEXT), title="oo /help", border_style="blue"))
+    return "Help displayed"

connectonion/cli/co_ai/commands/init.py

@@ -0,0 +1,101 @@
+"""Initialize OO for a project."""
+
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+OO_MD_TEMPLATE = """# Project Configuration for OO
+
+## About This Project
+
+[Describe what this project does]
+
+## Key Files
+
+- `src/` - Source code
+- `tests/` - Tests
+
+## Commands
+
+```bash
+# Development
+npm run dev
+
+# Testing
+npm test
+
+# Build
+npm run build
+```
+
+## Coding Conventions
+
+- [Add your coding style preferences]
+- [Add naming conventions]
+- [Add any project-specific rules]
+
+## Important Notes
+
+- [Add things OO should know when working on this project]
+"""
+
+
+def cmd_init(args: str = "") -> str:
+    """
+    Initialize .co/ directory with OO.md configuration.
+
+    Creates:
+    - .co/OO.md - Project configuration file for OO
+
+    Detects:
+    - README.md - Will be used for project understanding
+    - CLAUDE.md - Will be used for compatibility
+    """
+    cwd = Path.cwd()
+    co_dir = cwd / ".co"
+    oo_md = co_dir / "OO.md"
+
+    # Check what already exists
+    readme_exists = (cwd / "README.md").exists()
+    claude_exists = (cwd / "CLAUDE.md").exists()
+    oo_exists = oo_md.exists()
+
+    if oo_exists:
+        console.print(f"[yellow].co/OO.md already exists[/]")
+        console.print(f"Edit [cyan]{oo_md}[/] to update configuration.")
+        return "Already initialized"
+
+    # Create .co directory
+    co_dir.mkdir(exist_ok=True)
+
+    # Create OO.md
+    oo_md.write_text(OO_MD_TEMPLATE, encoding="utf-8")
+
+    # Build status message
+    lines = [
+        "[green]✓[/] Created [cyan].co/OO.md[/]",
+        "",
+        "Detected:",
+    ]
+
+    if readme_exists:
+        lines.append("  [green]✓[/] README.md (will use for project understanding)")
+    else:
+        lines.append("  [dim]○[/] README.md (not found)")
+
+    if claude_exists:
+        lines.append("  [green]✓[/] CLAUDE.md (will use for compatibility)")
+    else:
+        lines.append("  [dim]○[/] CLAUDE.md (not found)")
+
+    lines.extend([
+        "",
+        f"Edit [cyan].co/OO.md[/] to configure OO for your project.",
+    ])
+
+    output = "\n".join(lines)
+    console.print(Panel(output, title="oo /init", border_style="green"))
+
+    return "Initialized"

connectonion/cli/co_ai/commands/sessions.py

@@ -0,0 +1,55 @@
+"""Session commands - /sessions, /new."""
+
+from connectonion.cli.co_ai.sessions import get_session_manager
+
+_agent = None
+
+
+def set_agent(agent):
+    global _agent
+    _agent = agent
+
+
+def cmd_sessions(args: str = "") -> str:
+    manager = get_session_manager()
+    sessions = manager.list_sessions(limit=10)
+    
+    if not sessions:
+        return "No saved sessions. Start chatting to create one!"
+    
+    lines = ["**Recent Sessions:**\n"]
+    for s in sessions:
+        date = s["updated_at"][:10] if s.get("updated_at") else "unknown"
+        title = s.get("title", "Untitled")[:40]
+        lines.append(f"- `{s['id']}` - {title} ({date})")
+    
+    lines.append("\n*Use `/resume <id>` to continue a session*")
+    return "\n".join(lines)
+
+
+def cmd_new(args: str = "") -> str:
+    manager = get_session_manager()
+    model = _agent.llm.model if _agent and hasattr(_agent, 'llm') else ""
+    session_id = manager.create_session(model=model)
+    
+    if _agent and hasattr(_agent, 'messages'):
+        _agent.messages = []
+    
+    return f"Started new session: `{session_id}`"
+
+
+def cmd_resume(args: str = "") -> str:
+    if not args.strip():
+        return "Usage: `/resume <session_id>`\n\nUse `/sessions` to see available sessions."
+    
+    session_id = args.strip()
+    manager = get_session_manager()
+    messages = manager.load_session(session_id)
+    
+    if messages is None:
+        return f"Session `{session_id}` not found."
+    
+    if _agent and hasattr(_agent, 'messages'):
+        _agent.messages = [{"role": m["role"], "content": m["content"]} for m in messages]
+    
+    return f"Resumed session `{session_id}` with {len(messages)} messages."

connectonion/cli/co_ai/commands/tasks.py

@@ -0,0 +1,63 @@
+"""Tasks command - list and manage background tasks."""
+
+from rich.console import Console
+from rich.table import Table
+
+from connectonion.cli.co_ai.tools.background import _tasks, TaskStatus
+
+console = Console()
+
+
+def cmd_tasks(args: str = "") -> str:
+    """List background tasks.
+
+    Usage:
+        /tasks          - List all tasks
+        /tasks kill bg_1 - Kill a specific task
+    """
+    parts = args.strip().split()
+
+    if parts and parts[0] == "kill":
+        if len(parts) < 2:
+            console.print("[error]Usage: /tasks kill <task_id>[/]")
+            return "Missing task ID"
+
+        from connectonion.cli.co_ai.tools.background import kill_task
+        result = kill_task(parts[1])
+        console.print(result)
+        return result
+
+    # List all tasks
+    if not _tasks:
+        console.print("[dim]No background tasks.[/]")
+        return "No background tasks"
+
+    table = Table(title="Background Tasks")
+    table.add_column("ID", style="cyan")
+    table.add_column("Status", style="bold")
+    table.add_column("Command")
+    table.add_column("Time", justify="right")
+
+    import time
+    for task in _tasks.values():
+        elapsed = time.time() - task.start_time
+        if task.end_time:
+            elapsed = task.end_time - task.start_time
+
+        status_style = {
+            TaskStatus.RUNNING: "yellow",
+            TaskStatus.COMPLETED: "green",
+            TaskStatus.FAILED: "red",
+        }[task.status]
+
+        cmd_short = task.command[:50] + "..." if len(task.command) > 50 else task.command
+
+        table.add_row(
+            task.id,
+            f"[{status_style}]{task.status.value}[/]",
+            cmd_short,
+            f"{elapsed:.1f}s",
+        )
+
+    console.print(table)
+    return f"Listed {len(_tasks)} tasks"

connectonion/cli/co_ai/commands/undo.py

@@ -0,0 +1,103 @@
+"""Undo/Redo commands with Git backing."""
+
+import subprocess
+from typing import Optional
+
+_agent = None
+_undo_stack: list[dict] = []
+_redo_stack: list[dict] = []
+
+
+def set_agent(agent):
+    global _agent
+    _agent = agent
+
+
+def _is_git_repo() -> bool:
+    result = subprocess.run(["git", "rev-parse", "--git-dir"], capture_output=True)
+    return result.returncode == 0
+
+
+def _git_stash_push(message: str) -> bool:
+    result = subprocess.run(
+        ["git", "stash", "push", "-m", message, "--include-untracked"],
+        capture_output=True, text=True
+    )
+    return result.returncode == 0
+
+
+def _git_stash_pop() -> bool:
+    result = subprocess.run(["git", "stash", "pop"], capture_output=True, text=True)
+    return result.returncode == 0
+
+
+def _git_stash_apply(index: int = 0) -> bool:
+    result = subprocess.run(
+        ["git", "stash", "apply", f"stash@{{{index}}}"],
+        capture_output=True, text=True
+    )
+    return result.returncode == 0
+
+
+def _git_stash_drop(index: int = 0) -> bool:
+    result = subprocess.run(
+        ["git", "stash", "drop", f"stash@{{{index}}}"],
+        capture_output=True, text=True
+    )
+    return result.returncode == 0
+
+
+def cmd_undo(args: str = "") -> str:
+    if not _is_git_repo():
+        return "**Error:** Not a git repository. Undo requires git."
+    
+    if not _agent or not hasattr(_agent, 'messages'):
+        return "No conversation to undo."
+    
+    messages = _agent.messages
+    if len(messages) < 2:
+        return "Nothing to undo."
+    
+    user_msg = None
+    assistant_msg = None
+    
+    for i in range(len(messages) - 1, -1, -1):
+        if messages[i].get('role') == 'assistant' and assistant_msg is None:
+            assistant_msg = messages[i]
+        elif messages[i].get('role') == 'user' and assistant_msg and user_msg is None:
+            user_msg = messages[i]
+            break
+    
+    if not user_msg or not assistant_msg:
+        return "Nothing to undo."
+    
+    _git_stash_push(f"oo-undo-{len(_undo_stack)}")
+    
+    _undo_stack.append({
+        "user": user_msg,
+        "assistant": assistant_msg,
+        "stash_index": len(_undo_stack)
+    })
+    
+    messages.remove(user_msg)
+    messages.remove(assistant_msg)
+    _redo_stack.clear()
+    
+    return f"Undone last message. File changes stashed. Use `/redo` to restore."
+
+
+def cmd_redo(args: str = "") -> str:
+    if not _undo_stack:
+        return "Nothing to redo."
+    
+    if not _agent or not hasattr(_agent, 'messages'):
+        return "No active conversation."
+    
+    entry = _undo_stack.pop()
+    
+    _git_stash_pop()
+    
+    _agent.messages.append(entry["user"])
+    _agent.messages.append(entry["assistant"])
+    
+    return "Restored last undone message and file changes."

connectonion/cli/co_ai/context.py

@@ -0,0 +1,127 @@
+"""Context loading for project awareness."""
+
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from connectonion.cli.co_ai.skills.loader import load_skills, get_skills_for_prompt
+
+
+def load_project_context(base_path: Optional[Path] = None) -> str:
+    """
+    Load project context from various sources.
+
+    Reading priority:
+    1. .co/OO.md   - OO-specific instructions (our brand)
+    2. CLAUDE.md   - Compatibility with Claude Code
+    3. README.md   - Project understanding
+    4. Git status  - Current branch and changes
+    5. Environment - Working directory, date
+
+    Args:
+        base_path: Base directory to look for context files (default: cwd)
+
+    Returns:
+        Assembled context string for system prompt
+    """
+    base = base_path or Path.cwd()
+    parts = []
+
+    # 1. Load .co/OO.md (our brand, primary)
+    oo_md = base / ".co" / "OO.md"
+    if oo_md.exists():
+        content = oo_md.read_text(encoding="utf-8")
+        parts.append(f"# Project Instructions (OO.md)\n\n{content}")
+
+    # 2. Load CLAUDE.md (compatibility)
+    claude_md = base / "CLAUDE.md"
+    if claude_md.exists():
+        content = claude_md.read_text(encoding="utf-8")
+        if oo_md.exists():
+            parts.append(f"# Additional Instructions (CLAUDE.md)\n\n{content}")
+        else:
+            parts.append(f"# Project Instructions (CLAUDE.md)\n\n{content}")
+
+    # 3. Load README.md (project understanding)
+    readme_md = base / "README.md"
+    if readme_md.exists():
+        content = readme_md.read_text(encoding="utf-8")
+        # Truncate if too long (README can be verbose)
+        if len(content) > 5000:
+            content = content[:5000] + "\n\n... (truncated)"
+        parts.append(f"# Project Overview (README.md)\n\n{content}")
+
+    # 4. Load skills (descriptions only)
+    load_skills(base)
+    skills_prompt = get_skills_for_prompt()
+    if skills_prompt:
+        parts.append(f"# Available Skills\n\n{skills_prompt}")
+
+    # 5. Git status
+    git_info = _get_git_info(base)
+    if git_info:
+        parts.append(git_info)
+
+    # 6. Environment info
+    env_info = f"""# Environment
+
+Working Directory: {base}
+Date: {datetime.now().strftime("%Y-%m-%d")}
+"""
+    parts.append(env_info)
+
+    return "\n\n---\n\n".join(parts)
+
+
+def _get_git_info(base: Path) -> Optional[str]:
+    """Get git status information."""
+    git_dir = base / ".git"
+    if not git_dir.exists():
+        return None
+
+    try:
+        # Get current branch
+        branch = subprocess.run(
+            ["git", "branch", "--show-current"],
+            capture_output=True,
+            text=True,
+            cwd=base,
+            timeout=5,
+        )
+        branch_name = branch.stdout.strip() if branch.returncode == 0 else "unknown"
+
+        # Get status
+        status = subprocess.run(
+            ["git", "status", "--short"],
+            capture_output=True,
+            text=True,
+            cwd=base,
+            timeout=5,
+        )
+        status_output = status.stdout.strip() if status.returncode == 0 else ""
+
+        # Get recent commits (last 3)
+        log = subprocess.run(
+            ["git", "log", "--oneline", "-3"],
+            capture_output=True,
+            text=True,
+            cwd=base,
+            timeout=5,
+        )
+        log_output = log.stdout.strip() if log.returncode == 0 else ""
+
+        result = f"# Git Status\n\nBranch: {branch_name}"
+
+        if status_output:
+            result += f"\n\nChanges:\n```\n{status_output}\n```"
+        else:
+            result += "\n\nNo uncommitted changes."
+
+        if log_output:
+            result += f"\n\nRecent commits:\n```\n{log_output}\n```"
+
+        return result
+
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        return None