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

connectonion/cli/co_ai/tools/grep.py

@@ -0,0 +1,158 @@
+"""Grep tool for content searching."""
+
+import re
+from pathlib import Path
+from typing import Optional, Literal
+
+from connectonion.cli.co_ai.tools.glob import IGNORE_DIRS
+
+
+def grep(
+    pattern: str,
+    path: Optional[str] = None,
+    file_pattern: Optional[str] = None,
+    output_mode: Literal["files", "content", "count"] = "files",
+    context_lines: int = 0,
+    ignore_case: bool = False,
+    max_results: int = 50,
+) -> str:
+    """
+    Search for content in files using regex.
+
+    Args:
+        pattern: Regular expression pattern to search for
+        path: File or directory to search in (default: current directory)
+        file_pattern: Glob pattern to filter files (e.g., "*.py", "*.ts")
+        output_mode:
+            - "files": Return only matching file paths (default)
+            - "content": Return matching lines with context
+            - "count": Return match counts per file
+        context_lines: Number of lines to show before/after match (for content mode)
+        ignore_case: Case insensitive search
+        max_results: Maximum number of results to return
+
+    Returns:
+        Search results based on output_mode
+
+    Examples:
+        grep("def main")                           # Find "def main" in all files
+        grep("TODO|FIXME", file_pattern="*.py")   # Find TODOs in Python files
+        grep("class.*Agent", output_mode="content") # Show matching lines
+        grep("import", output_mode="count")        # Count imports per file
+    """
+    base = Path(path) if path else Path.cwd()
+
+    if not base.exists():
+        return f"Error: Path '{base}' does not exist"
+
+    # Compile regex
+    flags = re.IGNORECASE if ignore_case else 0
+    try:
+        regex = re.compile(pattern, flags)
+    except re.error as e:
+        return f"Error: Invalid regex pattern: {e}"
+
+    # Collect files to search
+    if base.is_file():
+        files = [base]
+    else:
+        if file_pattern:
+            files = list(base.glob(f"**/{file_pattern}"))
+        else:
+            files = list(base.glob("**/*"))
+
+        files = [f for f in files if f.is_file() and not _should_ignore(f) and _is_text_file(f)]
+
+    results = []
+    total_matches = 0
+
+    for file in files:
+        if total_matches >= max_results:
+            break
+
+        try:
+            content = file.read_text(encoding="utf-8", errors="ignore")
+            lines = content.splitlines()
+        except Exception:
+            continue
+
+        file_matches = []
+        for i, line in enumerate(lines):
+            if regex.search(line):
+                file_matches.append((i + 1, line))  # 1-indexed line number
+
+        if not file_matches:
+            continue
+
+        rel_path = _relative_path(file, base)
+
+        if output_mode == "files":
+            results.append(str(rel_path))
+            total_matches += 1
+
+        elif output_mode == "count":
+            results.append(f"{rel_path}: {len(file_matches)} matches")
+            total_matches += 1
+
+        elif output_mode == "content":
+            results.append(f"\n{rel_path}:")
+            for line_num, line_text in file_matches[:10]:  # Limit per file
+                # Add context if requested
+                if context_lines > 0:
+                    start = max(0, line_num - 1 - context_lines)
+                    end = min(len(lines), line_num + context_lines)
+                    for ctx_i in range(start, end):
+                        prefix = ">" if ctx_i == line_num - 1 else " "
+                        results.append(f"  {prefix} {ctx_i + 1}: {lines[ctx_i]}")
+                    results.append("")
+                else:
+                    results.append(f"  {line_num}: {line_text}")
+                total_matches += 1
+
+                if total_matches >= max_results:
+                    break
+
+    if not results:
+        return f"No matches found for '{pattern}'"
+
+    output = "\n".join(results)
+
+    if total_matches >= max_results:
+        output += f"\n\n... results truncated at {max_results}"
+
+    return output
+
+
+def _should_ignore(path: Path) -> bool:
+    """Check if path should be ignored."""
+    parts = path.parts
+    for part in parts:
+        if part in IGNORE_DIRS:
+            return True
+        for ignore in IGNORE_DIRS:
+            if "*" in ignore and Path(part).match(ignore):
+                return True
+    return False
+
+
+def _is_text_file(path: Path) -> bool:
+    """Check if file is likely a text file."""
+    # Skip binary file extensions
+    binary_extensions = {
+        ".pyc", ".pyo", ".so", ".dylib", ".dll", ".exe",
+        ".png", ".jpg", ".jpeg", ".gif", ".ico", ".svg",
+        ".pdf", ".doc", ".docx", ".xls", ".xlsx",
+        ".zip", ".tar", ".gz", ".rar", ".7z",
+        ".mp3", ".mp4", ".wav", ".avi", ".mov",
+        ".ttf", ".woff", ".woff2", ".eot",
+        ".lock", ".bin", ".dat",
+    }
+    return path.suffix.lower() not in binary_extensions
+
+
+def _relative_path(path: Path, base: Path) -> Path:
+    """Get relative path, handling edge cases."""
+    try:
+        return path.relative_to(base)
+    except ValueError:
+        return path

connectonion/cli/co_ai/tools/load_guide.py

@@ -0,0 +1,23 @@
+"""Load ConnectOnion framework guides."""
+
+from pathlib import Path
+
+GUIDES_DIR = Path(__file__).parent.parent / "prompts" / "connectonion"
+
+
+def load_guide(path: str) -> str:
+    """
+    Load a ConnectOnion framework guide.
+
+    Args:
+        path: Full path like "concepts/agent", "concepts/tools", "useful_tools/shell"
+
+    Returns:
+        Guide content
+    """
+    guide_file = GUIDES_DIR / f"{path}.md"
+
+    if not guide_file.exists():
+        return f"Guide '{path}' not found. Use full path: concepts/agent, concepts/tools, useful_tools/shell. See index.md."
+
+    return guide_file.read_text(encoding="utf-8")

connectonion/cli/co_ai/tools/multi_edit.py

@@ -0,0 +1,116 @@
+"""
+Purpose: Atomic multiple string replacements in a single file (like Claude Code's MultiEdit)
+LLM-Note:
+  Dependencies: imports from [pathlib, typing] | imported by [co_ai.tools.__init__]
+  Data flow: Agent calls multi_edit(file_path, edits) -> validates all edits -> applies sequentially -> returns status
+  State/Effects: reads and writes file on filesystem | atomic (all succeed or none applied)
+  Integration: exposes multi_edit(file_path, edits) function | used as agent tool
+  Errors: returns error if file not found | returns error if any old_string not found | rolls back on failure
+
+Usage:
+    multi_edit("app.py", [
+        {"old_string": "def foo():", "new_string": "def bar():"},
+        {"old_string": "return None", "new_string": "return True"},
+    ])
+"""
+
+from pathlib import Path
+from typing import List, TypedDict, Optional
+
+
+class EditOperation(TypedDict, total=False):
+    """Single edit operation."""
+    old_string: str              # Required: exact string to replace
+    new_string: str              # Required: replacement string
+    replace_all: bool            # Optional: replace all occurrences (default: False)
+
+
+def multi_edit(
+    file_path: str,
+    edits: List[EditOperation],
+) -> str:
+    """
+    Apply multiple string replacements to a file atomically.
+
+    All edits succeed or none are applied. Edits are applied sequentially,
+    so earlier edits affect the text that later edits search for.
+
+    Args:
+        file_path: Path to the file to edit
+        edits: List of edit operations, each with:
+            - old_string: Exact string to replace
+            - new_string: Replacement string
+            - replace_all: If True, replace all occurrences (default: False)
+
+    Returns:
+        Success message or error description
+
+    Examples:
+        multi_edit("app.py", [
+            {"old_string": "def foo():", "new_string": "def bar():"},
+            {"old_string": "foo()", "new_string": "bar()", "replace_all": True},
+        ])
+    """
+    path = Path(file_path)
+
+    if not path.exists():
+        return f"Error: File '{file_path}' does not exist"
+
+    if not path.is_file():
+        return f"Error: '{file_path}' is not a file"
+
+    if not edits:
+        return "Error: No edits provided"
+
+    # Read original content
+    original_content = path.read_text(encoding="utf-8")
+    content = original_content
+
+    # Validate and apply edits
+    applied = []
+    for i, edit in enumerate(edits):
+        old_string = edit.get("old_string", "")
+        new_string = edit.get("new_string", "")
+        replace_all = edit.get("replace_all", False)
+
+        if not old_string:
+            return f"Error: Edit {i+1} missing 'old_string'"
+
+        # Check if old_string exists in current content
+        count = content.count(old_string)
+
+        if count == 0:
+            # Show what edits were successful before failure
+            if applied:
+                applied_msg = "\n".join([f"  {j+1}. Replaced '{e['old']}'" for j, e in enumerate(applied)])
+                return (
+                    f"Error: Edit {i+1} failed - string not found after previous edits.\n"
+                    f"Looking for: {repr(old_string[:100])}\n\n"
+                    f"Successfully applied before failure:\n{applied_msg}\n\n"
+                    f"No changes were saved (atomic operation)."
+                )
+            return f"Error: Edit {i+1} - string not found in '{file_path}': {repr(old_string[:100])}"
+
+        if count > 1 and not replace_all:
+            return (
+                f"Error: Edit {i+1} - string appears {count} times. "
+                f"Use replace_all=True or provide more context.\n"
+                f"String: {repr(old_string[:100])}"
+            )
+
+        # Apply this edit
+        if replace_all:
+            content = content.replace(old_string, new_string)
+            applied.append({"old": old_string[:50], "count": count})
+        else:
+            content = content.replace(old_string, new_string, 1)
+            applied.append({"old": old_string[:50], "count": 1})
+
+    # All edits validated and applied in memory - now write to file
+    path.write_text(content, encoding="utf-8")
+
+    # Build success message
+    total_replacements = sum(e["count"] for e in applied)
+    if len(edits) == 1:
+        return f"Successfully edited '{file_path}'"
+    return f"Successfully applied {len(edits)} edits ({total_replacements} replacements) to '{file_path}'"

connectonion/cli/co_ai/tools/plan_mode.py

@@ -0,0 +1,169 @@
+"""Plan Mode tools for planning before implementation."""
+
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+
+console = Console()
+
+# Plan mode state (module-level for simplicity)
+_plan_mode_active = False
+_plan_file_path: Optional[Path] = None
+
+
+def get_plan_file_path() -> Path:
+    """Get the default plan file path."""
+    co_dir = Path.cwd() / ".co"
+    co_dir.mkdir(exist_ok=True)
+    return co_dir / "PLAN.md"
+
+
+def is_plan_mode_active() -> bool:
+    """Check if plan mode is currently active."""
+    return _plan_mode_active
+
+
+def enter_plan_mode() -> str:
+    """
+    Enter plan mode for designing implementation before coding.
+
+    Use this when you need to:
+    - Plan a complex feature implementation
+    - Design architecture before writing code
+    - Get user approval on approach before making changes
+
+    In plan mode:
+    - Explore the codebase to understand structure
+    - Design the implementation approach
+    - Write your plan to .co/PLAN.md
+    - Exit plan mode when ready for user approval
+
+    Returns:
+        Confirmation message with instructions
+
+    Example workflow:
+        1. enter_plan_mode() - Start planning
+        2. Use glob/grep/read_file to explore
+        3. Write plan to .co/PLAN.md
+        4. exit_plan_mode() - Get user approval
+        5. Implement after approval
+    """
+    global _plan_mode_active, _plan_file_path
+
+    if _plan_mode_active:
+        return "Already in plan mode. Use exit_plan_mode() when ready for user approval."
+
+    _plan_mode_active = True
+    _plan_file_path = get_plan_file_path()
+
+    # Create initial plan file
+    initial_content = """# Implementation Plan
+
+## Summary
+[One-sentence description of what will be implemented]
+
+## Current Understanding
+[What you learned from exploring the codebase]
+
+## Files to Modify
+- `path/to/file.py` - What changes needed
+
+## Files to Create
+- `path/to/new_file.py` - Purpose
+
+## Implementation Steps
+1. Step 1 - Details
+2. Step 2 - Details
+3. Step 3 - Details
+
+## Considerations
+- Any risks or trade-offs
+
+---
+*Plan created by OO. Waiting for user approval.*
+"""
+
+    _plan_file_path.write_text(initial_content, encoding="utf-8")
+
+    console.print(Panel(
+        "[bold green]Entered Plan Mode[/]\n\n"
+        "You are now in planning mode. In this mode:\n"
+        "1. [cyan]Explore[/] - Use glob/grep/read_file to understand the codebase\n"
+        "2. [cyan]Design[/] - Write your implementation plan\n"
+        "3. [cyan]Document[/] - Update .co/PLAN.md with your plan\n"
+        "4. [cyan]Exit[/] - Call exit_plan_mode() for user approval\n\n"
+        f"Plan file: [dim]{_plan_file_path}[/]",
+        title="Plan Mode",
+        border_style="green"
+    ))
+
+    return f"Entered plan mode. Write your plan to {_plan_file_path}, then call exit_plan_mode() when ready for user approval."
+
+
+def exit_plan_mode() -> str:
+    """
+    Exit plan mode and request user approval for the plan.
+
+    Call this after you have:
+    1. Explored the codebase
+    2. Written your implementation plan to .co/PLAN.md
+
+    The user will review the plan and either:
+    - Approve: You can proceed with implementation
+    - Request changes: Update the plan and try again
+    - Reject: Abandon the plan
+
+    Returns:
+        The plan content for user review
+    """
+    global _plan_mode_active, _plan_file_path
+
+    if not _plan_mode_active:
+        return "Not in plan mode. Use enter_plan_mode() first."
+
+    plan_file = _plan_file_path or get_plan_file_path()
+
+    if not plan_file.exists():
+        return f"Plan file not found at {plan_file}. Write your plan first."
+
+    plan_content = plan_file.read_text(encoding="utf-8")
+
+    # Reset state
+    _plan_mode_active = False
+    _plan_file_path = None
+
+    # Display plan for user approval
+    console.print(Panel(
+        Markdown(plan_content),
+        title="📋 Implementation Plan - Review Required",
+        border_style="yellow"
+    ))
+
+    console.print()
+    console.print("[bold yellow]Please review the plan above.[/]")
+    console.print("Reply with:")
+    console.print("  [green]'approve'[/] or [green]'yes'[/] - Proceed with implementation")
+    console.print("  [yellow]'modify: <feedback>'[/] - Request changes to the plan")
+    console.print("  [red]'reject'[/] or [red]'no'[/] - Abandon this plan")
+    console.print()
+
+    return f"Exited plan mode. Plan saved to {plan_file}. Waiting for user approval.\n\n---\n\n{plan_content}"
+
+
+def write_plan(content: str) -> str:
+    """
+    Write or update the implementation plan.
+
+    Use this to document your implementation plan while in plan mode.
+
+    Args:
+        content: The plan content in markdown format
+
+    Returns:
+        Confirmation message
+    """
+    plan_file = get_plan_file_path()
+    plan_file.write_text(content, encoding="utf-8")
+    return f"Plan updated: {plan_file}"

connectonion/cli/co_ai/tools/read.py

@@ -0,0 +1,61 @@
+"""Read file tool."""
+
+from pathlib import Path
+from typing import Optional
+
+
+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)"
+
+    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