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

connectonion/cli/co_ai/tools/read.py

@@ -0,0 +1,67 @@
+"""Read file tool."""
+
+from pathlib import Path
+from typing import Optional
+
+from connectonion.cli.co_ai.reminders import inject_reminder, should_show_security_reminder
+
+
+def read_file(
+    path: str,
+    offset: Optional[int] = None,
+    limit: Optional[int] = None,
+) -> str:
+    """
+    Read and return the contents of a file with line numbers.
+
+    Args:
+        path: Path to the file to read
+        offset: Line number to start from (1-indexed, default: 1)
+        limit: Number of lines to read (default: 2000)
+
+    Returns:
+        File contents with line numbers
+
+    Examples:
+        read_file("app.py")                    # Read entire file
+        read_file("large.log", offset=100)     # Start from line 100
+        read_file("data.csv", limit=50)        # First 50 lines
+    """
+    file_path = Path(path)
+
+    if not file_path.exists():
+        return f"Error: File '{path}' does not exist"
+
+    if not file_path.is_file():
+        return f"Error: '{path}' is not a file"
+
+    content = file_path.read_text(encoding="utf-8", errors="replace")
+    lines = content.splitlines()
+
+    total_lines = len(lines)
+
+    # Apply offset and limit
+    start = (offset - 1) if offset and offset > 0 else 0
+    end = (start + limit) if limit else len(lines)
+
+    selected_lines = lines[start:end]
+
+    # Format with line numbers
+    result_lines = []
+    for i, line in enumerate(selected_lines, start=start + 1):
+        # Truncate very long lines
+        if len(line) > 500:
+            line = line[:500] + "..."
+        result_lines.append(f"{i:>6}\t{line}")
+
+    result = "\n".join(result_lines)
+
+    # Add info about truncation
+    if end < total_lines:
+        result += f"\n\n... ({total_lines - end} more lines)"
+
+    # Inject security reminder for sensitive files
+    if should_show_security_reminder(path):
+        result = inject_reminder(result, "security")
+
+    return result

connectonion/cli/co_ai/tools/task.py

@@ -0,0 +1,59 @@
+"""Task tool for delegating to sub-agents."""
+
+from typing import Literal
+
+from rich.console import Console
+from rich.text import Text
+
+from connectonion.cli.co_ai.agents.registry import get_subagent, SUBAGENTS
+
+console = Console()
+
+
+def task(
+    prompt: str,
+    agent_type: Literal["explore", "plan"] = "explore",
+) -> str:
+    """
+    Delegate a task to a specialized sub-agent.
+
+    Use this when you need to:
+    - Explore the codebase (find files, search code, understand structure)
+    - Plan an implementation (design approach, identify files to change)
+
+    Args:
+        prompt: The task description for the sub-agent
+        agent_type: Type of sub-agent to use
+            - "explore": Fast codebase exploration (find files, search code)
+            - "plan": Design implementation plans
+
+    Returns:
+        Sub-agent's response
+
+    Examples:
+        task("Find all files that handle user authentication", agent_type="explore")
+        task("Design a plan to add dark mode support", agent_type="plan")
+        task("What is the project structure?", agent_type="explore")
+    """
+    if agent_type not in SUBAGENTS:
+        available = ", ".join(SUBAGENTS.keys())
+        return f"Error: Unknown agent type '{agent_type}'. Available: {available}"
+
+    subagent = get_subagent(agent_type)
+    if subagent is None:
+        return f"Error: Failed to create {agent_type} agent"
+
+    # Show task start
+    short_prompt = prompt[:50] + "..." if len(prompt) > 50 else prompt
+    text = Text()
+    text.append("  ▶ ", style="blue")
+    text.append(f"Task ({agent_type})", style="bold blue")
+    text.append(f" {short_prompt}", style="dim")
+    console.print(text)
+
+    result = subagent.input(prompt)
+
+    # Show task complete
+    console.print(Text("  ◀ Task completed", style="blue"))
+
+    return result

connectonion/cli/co_ai/tools/todo_list.py

@@ -0,0 +1,159 @@
+"""
+Purpose: Web-friendly todo tracking tool that emits updates via io
+LLM-Note:
+  Dependencies: imports from [typing, dataclasses] | imported by [co_ai.tools.__init__]
+  Data flow: Agent calls TodoList methods -> updates internal list -> emits todo_update via io -> returns status string
+  State/Effects: maintains in-memory list of TodoItem objects | sends updates via io | no console output
+  Integration: exposes TodoList class with add(content, active_form), start(content), complete(content), remove(content), list(), update(todos), clear()
+"""
+
+from typing import List, Literal, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class TodoItem:
+    """A single todo item."""
+    content: str
+    status: Literal["pending", "in_progress", "completed"]
+    active_form: str
+
+
+class TodoList:
+    """Task tracking tool for agents (web-first)."""
+
+    def __init__(self):
+        self._todos: List[TodoItem] = []
+        self.io = None
+
+    def add(self, content: str, active_form: str) -> str:
+        """Add a new todo item."""
+        if self._find(content):
+            return f"Todo already exists: {content}"
+
+        self._todos.append(TodoItem(
+            content=content,
+            status="pending",
+            active_form=active_form
+        ))
+        self._emit()
+        return f"Added: {content}"
+
+    def start(self, content: str) -> str:
+        """Mark a todo as in_progress."""
+        item = self._find(content)
+        if not item:
+            return f"Todo not found: {content}"
+
+        if item.status == "completed":
+            return f"Cannot start completed todo: {content}"
+
+        in_progress = [t for t in self._todos if t.status == "in_progress"]
+        if in_progress and in_progress[0].content != content:
+            return f"Another task is in progress: {in_progress[0].content}. Complete it first."
+
+        item.status = "in_progress"
+        self._emit()
+        return f"Started: {item.active_form}"
+
+    def complete(self, content: str) -> str:
+        """Mark a todo as completed."""
+        item = self._find(content)
+        if not item:
+            return f"Todo not found: {content}"
+
+        item.status = "completed"
+        self._emit()
+        return f"Completed: {content}"
+
+    def remove(self, content: str) -> str:
+        """Remove a todo from the list."""
+        item = self._find(content)
+        if not item:
+            return f"Todo not found: {content}"
+
+        self._todos.remove(item)
+        self._emit()
+        return f"Removed: {content}"
+
+    def list(self) -> str:
+        """Get all todos as formatted text."""
+        if not self._todos:
+            return "No todos"
+
+        lines = []
+        for item in self._todos:
+            status_icon = self._status_icon(item.status)
+            lines.append(f"{status_icon} {item.content}")
+
+        return "\n".join(lines)
+
+    def update(self, todos: List[dict]) -> str:
+        """Replace entire todo list (for bulk updates)."""
+        self._todos = []
+        for t in todos:
+            self._todos.append(TodoItem(
+                content=t["content"],
+                status=t["status"],
+                active_form=t.get("active_form", t["content"] + "...")
+            ))
+        self._emit()
+        return f"Updated {len(self._todos)} todos"
+
+    def clear(self) -> str:
+        """Clear all todos."""
+        count = len(self._todos)
+        self._todos = []
+        self._emit()
+        return f"Cleared {count} todos"
+
+    def _find(self, content: str) -> Optional[TodoItem]:
+        """Find todo by content."""
+        for item in self._todos:
+            if item.content == content:
+                return item
+        return None
+
+    def _status_icon(self, status: str) -> str:
+        """Get icon for status (ASCII)."""
+        return {
+            "pending": "[ ]",
+            "in_progress": "[>]",
+            "completed": "[x]"
+        }.get(status, "[ ]")
+
+    def _emit(self) -> None:
+        """Emit todo updates to io (best-effort)."""
+        if not self.io:
+            return
+
+        payload = {
+            "type": "todo_update",
+            "todos": [
+                {
+                    "content": t.content,
+                    "status": t.status,
+                    "active_form": t.active_form
+                }
+                for t in self._todos
+            ],
+            "progress": self.progress,
+            "current_task": self.current_task,
+        }
+        self.io.send(payload)
+
+    @property
+    def progress(self) -> float:
+        """Get progress as percentage (0.0 to 1.0)."""
+        if not self._todos:
+            return 1.0
+        completed = sum(1 for t in self._todos if t.status == "completed")
+        return completed / len(self._todos)
+
+    @property
+    def current_task(self) -> Optional[str]:
+        """Get the currently in_progress task."""
+        for item in self._todos:
+            if item.status == "in_progress":
+                return item.active_form
+        return None

connectonion/cli/co_ai/tools/write.py

@@ -0,0 +1,126 @@
+"""
+Purpose: Write file tool with Claude Code-style approval (web mode)
+LLM-Note:
+  Dependencies: imports from [.diff_writer] | imported by [co_ai.tools.__init__]
+  Data flow: Agent calls write(path, content) -> DiffWriter handles approval via io -> writes file
+  State/Effects: writes file to filesystem | sends events via io for approval
+  Integration: exposes write(path, content) function and Write class | used as agent tool
+
+This is a wrapper around DiffWriter for simpler function-based usage.
+For class-based usage with mode control, use DiffWriter directly.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+from .diff_writer import DiffWriter, MODE_NORMAL, MODE_AUTO, MODE_PLAN
+
+
+# Global writer instance for function-based API
+_writer: Optional[DiffWriter] = None
+
+
+def _get_writer() -> DiffWriter:
+    """Get or create the global writer instance."""
+    global _writer
+    if _writer is None:
+        _writer = DiffWriter(mode=MODE_AUTO)  # Default to auto for function API
+    return _writer
+
+
+def write(path: str, content: str) -> str:
+    """
+    Write content to a file (full overwrite).
+
+    For new files or when replacing most of the content.
+    Use edit() for small, targeted changes instead.
+
+    Args:
+        path: File path to write to
+        content: Complete file content
+
+    Returns:
+        Success message or error description
+
+    Examples:
+        write("new_file.py", "print('hello')")
+        write("config.json", '{"debug": true}')
+    """
+    writer = _get_writer()
+    return writer.write(path, content)
+
+
+class Write:
+    """File writer with Claude Code-style permission modes (web mode).
+
+    Use this class when you need mode control (normal/auto/plan).
+    For simple writes, use the write() function instead.
+
+    Usage:
+        writer = Write(mode="normal")  # Prompt for every write
+        writer = Write(mode="auto")    # Auto-approve all writes
+        writer = Write(mode="plan")    # Read-only, preview only
+    """
+
+    def __init__(self, mode: str = MODE_NORMAL):
+        """Initialize Write tool.
+
+        Args:
+            mode: Permission mode - "normal" (prompt), "auto" (auto-approve), "plan" (read-only)
+        """
+        self._writer = DiffWriter(mode=mode)
+
+    @property
+    def io(self):
+        """IO channel for web mode."""
+        return self._writer.io
+
+    @io.setter
+    def io(self, value):
+        """Set IO channel."""
+        self._writer.io = value
+
+    @property
+    def mode(self):
+        """Current permission mode."""
+        return self._writer.mode
+
+    @mode.setter
+    def mode(self, value):
+        """Set permission mode."""
+        self._writer.mode = value
+
+    def write(self, path: str, content: str) -> str:
+        """Write content to a file with approval.
+
+        Args:
+            path: File path to write to
+            content: Complete file content
+
+        Returns:
+            Success message, rejection with feedback, or plan mode preview
+        """
+        return self._writer.write(path, content)
+
+    def diff(self, path: str, content: str) -> str:
+        """Show diff without writing (preview mode).
+
+        Args:
+            path: File path to compare against
+            content: New content to compare
+
+        Returns:
+            Diff string in unified format
+        """
+        return self._writer.diff(path, content)
+
+    def read(self, path: str) -> str:
+        """Read file contents.
+
+        Args:
+            path: File path to read
+
+        Returns:
+            File contents or error message
+        """
+        return self._writer.read(path)

connectonion/cli/commands/__init__.py

@@ -1 +1,11 @@
-"""Command modules for ConnectOnion CLI."""
+"""
+Purpose: CLI command modules namespace
+LLM-Note:
+  Dependencies: none | imported by [cli/main.py] | no direct tests
+  Data flow: no exports (commands imported directly from submodules)
+  State/Effects: no state
+  Integration: namespace package for auth_commands, browser_commands, create, deploy_commands, doctor_commands, eval_commands, init, status_commands, etc.
+  Performance: trivial
+  Errors: none
+Command modules for ConnectOnion CLI.
+"""

connectonion/cli/commands/ai_commands.py

@@ -0,0 +1,34 @@
+"""
+Purpose: AI coding agent CLI command
+LLM-Note:
+  Dependencies: imports from [cli/co_ai/main.py] | imported by [cli/main.py] | no direct tests
+  Data flow: CLI args → start_server(port, model, max_iterations) → co_ai.main.start_server()
+  Integration: exposes handle_ai() | called from main.py as 'co ai' command
+"""
+
+from rich.console import Console
+
+console = Console()
+
+
+def handle_ai(
+    port: int = 8000,
+    model: str = "co/claude-opus-4-5",
+    max_iterations: int = 20,
+):
+    """Start AI coding agent web server.
+
+    Args:
+        port: Port to run server on
+        model: LLM model to use
+        max_iterations: Max tool calling iterations
+
+    Examples:
+        co ai                      # Start on port 8000
+        co ai --port 3001          # Custom port
+        co ai --model co/gpt-5     # Different model
+    """
+    from ..co_ai.main import start_server
+
+    console.print(f"[green]Starting AI coding agent on port {port}...[/]")
+    start_server(port=port, model=model, max_iterations=max_iterations)

connectonion/cli/commands/copy_commands.py

@@ -1,9 +1,9 @@
 """
-Purpose: CLI command to copy built-in tools and plugins to user's project for customization
+Purpose: CLI command to copy built-in tools, plugins, and prompts to user's project for customization
 LLM-Note:
   Dependencies: imports from [shutil, pathlib, typing, rich] | imported by [cli/main.py via handle_copy()]
-  Data flow: user runs `co copy <name>` → looks up name in TOOLS/PLUGINS registry → finds source via module.__file__ → copies to ./tools/ or ./plugins/
-  State/Effects: creates tools/ or plugins/ directory if needed | copies .py files from installed package to user's project
+  Data flow: user runs `co copy <name>` → looks up name in TOOLS/PLUGINS/PROMPTS registry → finds source via module.__file__ → copies to ./tools/, ./plugins/, or ./prompts/
+  State/Effects: creates tools/, plugins/, or prompts/ directory if needed | copies files/directories from installed package to user's project
   Integration: exposes handle_copy() for CLI | uses Python import system to find installed package location (cross-platform)
 """
 
@@ -17,6 +17,7 @@ console = Console()
 
 # Registry of copyable tools
 TOOLS = {
+    "ask_user": "ask_user.py",
     "gmail": "gmail.py",
     "outlook": "outlook.py",
     "google_calendar": "google_calendar.py",
@@ -37,6 +38,12 @@ PLUGINS = {
     "shell_approval": "shell_approval.py",
     "gmail_plugin": "gmail_plugin.py",
     "calendar_plugin": "calendar_plugin.py",
+    "system_reminder": "system_reminder.py",
+}
+
+# Plugins that also need prompts copied
+PLUGIN_PROMPTS = {
+    "system_reminder": "system-reminders",
 }
 
 # Registry of copyable TUI components
@@ -51,6 +58,11 @@ TUI = {
     "keys": "keys.py",
 }
 
+# Registry of copyable prompt templates (directories)
+PROMPTS = {
+    "coding_agent": "coding_agent",
+}
+
 
 def handle_copy(
     names: List[str],
@@ -58,7 +70,7 @@ def handle_copy(
     path: Optional[str] = None,
     force: bool = False
 ):
-    """Copy built-in tools and plugins to user's project."""
+    """Copy built-in tools, plugins, and prompts to user's project."""
 
     # Show list if requested or no names provided
     if list_all or not names:
@@ -69,10 +81,12 @@ def handle_copy(
     import connectonion.useful_tools as tools_module
     import connectonion.useful_plugins as plugins_module
     import connectonion.tui as tui_module
+    import connectonion.useful_prompts as prompts_module
 
     useful_tools_dir = Path(tools_module.__file__).parent
     useful_plugins_dir = Path(plugins_module.__file__).parent
     tui_dir = Path(tui_module.__file__).parent
+    useful_prompts_dir = Path(prompts_module.__file__).parent
 
     current_dir = Path.cwd()
 
@@ -91,12 +105,24 @@ def handle_copy(
             dest_dir = Path(path) if path else current_dir / "plugins"
             copy_file(source, dest_dir, force)
 
+            # Also copy associated prompts if any
+            if name_lower in PLUGIN_PROMPTS:
+                prompt_source = useful_prompts_dir / PLUGIN_PROMPTS[name_lower]
+                prompt_dest = Path(path) if path else current_dir / "prompts"
+                copy_directory(prompt_source, prompt_dest, force)
+
         # Check if it's a TUI component
         elif name_lower in TUI:
             source = tui_dir / TUI[name_lower]
             dest_dir = Path(path) if path else current_dir / "tui"
             copy_file(source, dest_dir, force)
 
+        # Check if it's a prompt template
+        elif name_lower in PROMPTS:
+            source = useful_prompts_dir / PROMPTS[name_lower]
+            dest_dir = Path(path) if path else current_dir / "prompts"
+            copy_directory(source, dest_dir, force)
+
         else:
             console.print(f"[red]Unknown: {name}[/red]")
             console.print("Use [cyan]co copy --list[/cyan] to see available items")
@@ -119,12 +145,31 @@ def copy_file(source: Path, dest_dir: Path, force: bool):
     console.print(f"[green]✓ Copied: {dest}[/green]")
 
 
+def copy_directory(source: Path, dest_dir: Path, force: bool):
+    """Copy an entire directory to destination."""
+    if not source.exists():
+        console.print(f"[red]Source not found: {source}[/red]")
+        return
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / source.name
+
+    if dest.exists():
+        if not force:
+            console.print(f"[yellow]Skipped: {dest} (exists, use --force)[/yellow]")
+            return
+        shutil.rmtree(dest)
+
+    shutil.copytree(source, dest)
+    console.print(f"[green]✓ Copied: {dest}/[/green]")
+
+
 def show_available_items():
-    """Display available tools, plugins, and TUI components."""
+    """Display available tools, plugins, prompts, and TUI components."""
     table = Table(title="Available Items to Copy")
     table.add_column("Name", style="cyan")
     table.add_column("Type", style="green")
-    table.add_column("File")
+    table.add_column("Path")
 
     for name, file in sorted(TOOLS.items()):
         table.add_row(name, "tool", file)
@@ -132,8 +177,12 @@ def show_available_items():
     for name, file in sorted(PLUGINS.items()):
         table.add_row(name, "plugin", file)
 
+    for name, dir_name in sorted(PROMPTS.items()):
+        table.add_row(name, "prompt", f"{dir_name}/")
+
     for name, file in sorted(TUI.items()):
         table.add_row(name, "tui", file)
 
     console.print(table)
     console.print("\n[dim]Usage: co copy <name> [--path ./custom/][/dim]")
+    console.print("[dim]Prompts are copied as directories to ./prompts/<name>/[/dim]")

connectonion/cli/commands/create.py

@@ -35,7 +35,8 @@ from .project_cmd_lib import (
     get_template_info,
     generate_custom_template_with_name,
     show_progress,
-    configure_env_for_provider
+    configure_env_for_provider,
+    get_docs_source,
 )
 
 console = Console()
@@ -358,26 +359,28 @@ def handle_create(name: Optional[str], ai: Optional[bool], key: Optional[str],
     if not co_dir.exists():
         co_dir.mkdir(exist_ok=True)
 
-    # Create docs directory
+    # Create docs directory and copy ALL documentation (always overwrite for latest version)
     docs_dir = co_dir / "docs"
+    if docs_dir.exists():
+        shutil.rmtree(docs_dir)
     docs_dir.mkdir(exist_ok=True)
 
-    # Copy ConnectOnion documentation from single master source
-    cli_dir = Path(__file__).parent.parent
+    # Get docs source (works in both dev and installed package)
+    docs_source = get_docs_source()
 
-    # Copy the main vibe-coding documentation - keep original filename
-    master_vibe_doc = cli_dir / "docs" / "co-vibecoding-principles-docs-contexts-all-in-one.md"
-    if master_vibe_doc.exists():
-        # Copy to .co/docs/ (project metadata)
-        shutil.copy2(master_vibe_doc, docs_dir / "co-vibecoding-principles-docs-contexts-all-in-one.md")
-        files_created.append(".co/docs/co-vibecoding-principles-docs-contexts-all-in-one.md")
-
-        # ALSO copy to project root (always visible, easier to find)
-        root_doc = project_dir / "co-vibecoding-principles-docs-contexts-all-in-one.md"
-        shutil.copy2(master_vibe_doc, root_doc)
-        files_created.append("co-vibecoding-principles-docs-contexts-all-in-one.md")
+    # Copy ALL docs to .co/docs/
+    if docs_source.exists() and docs_source.is_dir():
+        for item in docs_source.iterdir():
+            if item.name.startswith('.') or item.name == 'archive':
+                continue
+            dest = docs_dir / item.name
+            if item.is_dir():
+                shutil.copytree(item, dest, dirs_exist_ok=True)
+            else:
+                shutil.copy2(item, dest)
+        files_created.append(".co/docs/ (full documentation)")
     else:
-        console.print(f"[yellow]⚠️  Warning: Vibe coding documentation not found at {master_vibe_doc}[/yellow]")
+        console.print(f"[yellow]⚠️  Warning: Documentation not found at {docs_source}[/yellow]")
 
     # Create config.toml (simplified - agent metadata now in .env)
     config = {
@@ -500,7 +503,7 @@ todo.md
 
     # Vibe Coding hint - clean formatting with proper spacing
     console.print("[bold yellow]💡 Vibe Coding:[/bold yellow] Use Claude/Cursor/Codex with")
-    console.print(f"   [cyan]co-vibecoding-principles-docs-contexts-all-in-one.md[/cyan]")
+    console.print(f"   [cyan].co/docs/[/cyan] for full documentation")
     console.print()
 
     # Resources - clean format with arrows for better alignment