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

connectonion/cli/co_ai/tools/edit.py

@@ -0,0 +1,89 @@
+"""Edit tool for precise string replacement."""
+
+from pathlib import Path
+
+
+def edit(
+    file_path: str,
+    old_string: str,
+    new_string: str,
+    replace_all: bool = False,
+) -> str:
+    """
+    Replace a string in a file with precise matching.
+
+    More token-efficient than rewriting entire files. Use for small, targeted changes.
+    The old_string must exist in the file (and be unique unless replace_all=True).
+
+    Args:
+        file_path: Path to the file to edit
+        old_string: Exact string to replace (must be unique in file)
+        new_string: String to replace with
+        replace_all: If True, replace all occurrences; if False, old_string must be unique
+
+    Returns:
+        Success message or error description
+
+    Examples:
+        edit("app.py", "def foo():", "def bar():")
+        edit("config.json", '"debug": false', '"debug": true')
+        edit("README.md", "v1.0", "v2.0", 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"
+
+    content = path.read_text(encoding="utf-8")
+
+    # Check if old_string exists
+    count = content.count(old_string)
+
+    if count == 0:
+        # Try to help debug: show similar strings
+        lines_with_similar = []
+        for i, line in enumerate(content.splitlines(), 1):
+            # Check if any significant part of old_string is in the line
+            if len(old_string) > 10:
+                # For longer strings, check first 20 chars
+                if old_string[:20] in line or old_string[-20:] in line:
+                    lines_with_similar.append(f"  Line {i}: {line[:80]}")
+            elif old_string.strip() in line:
+                lines_with_similar.append(f"  Line {i}: {line[:80]}")
+
+        msg = f"Error: String not found in '{file_path}'"
+        if lines_with_similar:
+            msg += f"\n\nSimilar content found:\n" + "\n".join(lines_with_similar[:5])
+        return msg
+
+    if count > 1 and not replace_all:
+        # Show where the duplicates are
+        lines_with_match = []
+        for i, line in enumerate(content.splitlines(), 1):
+            if old_string in line:
+                lines_with_match.append(f"  Line {i}: {line[:80]}")
+
+        return (
+            f"Error: String appears {count} times in '{file_path}'. "
+            f"Use replace_all=True to replace all, or provide more context to make it unique.\n\n"
+            f"Found at:\n" + "\n".join(lines_with_match[:10])
+        )
+
+    # Perform replacement
+    if replace_all:
+        new_content = content.replace(old_string, new_string)
+        replaced_count = count
+    else:
+        new_content = content.replace(old_string, new_string, 1)
+        replaced_count = 1
+
+    # Write back
+    path.write_text(new_content, encoding="utf-8")
+
+    if replace_all and replaced_count > 1:
+        return f"Replaced {replaced_count} occurrences in '{file_path}'"
+    else:
+        return f"Successfully edited '{file_path}'"

connectonion/cli/co_ai/tools/glob.py

@@ -0,0 +1,84 @@
+"""Glob tool for file pattern matching."""
+
+from pathlib import Path
+from typing import Optional
+
+IGNORE_DIRS = {
+    ".git",
+    "node_modules",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".env",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    "target",
+    ".idea",
+    ".vscode",
+    "*.egg-info",
+}
+
+
+def glob(pattern: str, path: Optional[str] = None) -> str:
+    """
+    Search for files matching a glob pattern.
+
+    Args:
+        pattern: Glob pattern (e.g., "**/*.py", "src/**/*.ts")
+        path: Directory to search in (default: current directory)
+
+    Returns:
+        Matching file paths, one per line, sorted by modification time (newest first)
+
+    Examples:
+        glob("**/*.py")           # All Python files
+        glob("src/**/*.tsx")      # All TSX files in src/
+        glob("**/test_*.py")      # All test files
+        glob("*.md", "docs")      # Markdown files in docs/
+    """
+    base = Path(path) if path else Path.cwd()
+
+    if not base.exists():
+        return f"Error: Path '{base}' does not exist"
+
+    if not base.is_dir():
+        return f"Error: Path '{base}' is not a directory"
+
+    matches = []
+    for p in base.glob(pattern):
+        if p.is_file() and not _should_ignore(p):
+            matches.append(p)
+
+    if not matches:
+        return f"No files found matching '{pattern}'"
+
+    # Sort by modification time (newest first)
+    matches.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+
+    # Format output
+    results = []
+    for p in matches[:100]:  # Limit to 100 results
+        rel_path = p.relative_to(base) if path else p.relative_to(Path.cwd())
+        results.append(str(rel_path))
+
+    output = "\n".join(results)
+
+    if len(matches) > 100:
+        output += f"\n\n... and {len(matches) - 100} more files"
+
+    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
+        # Handle patterns like *.egg-info
+        for ignore in IGNORE_DIRS:
+            if "*" in ignore and Path(part).match(ignore):
+                return True
+    return False

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,172 @@
+"""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
+
+from connectonion.cli.co_ai.reminders import REMINDERS
+
+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"
+    ))
+
+    plan_mode_reminder = REMINDERS.get("plan_mode_active", "")
+    return f"Entered plan mode. Write your plan to {_plan_file_path}, then call exit_plan_mode() when ready for user approval.\n\n{plan_mode_reminder}"
+
+
+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}"