raggiecode 0.2.1__py3-none-any.whl

Tools/view_changes.py

@@ -0,0 +1,179 @@
+import os
+from Agent.git_manager import GitManager
+from .utils import BLUE, RESET
+
+
+def handle(arguments, toolcall_id):
+    """Handle ViewChanges tool calls."""
+    print(f"{BLUE}ViewChanges{RESET}")
+
+    view_type = arguments.get("view_type", "status")
+    path = arguments.get("path")
+    max_count = arguments.get("max_count", 10)
+    category = arguments.get("category")
+    max_diff_lines = arguments.get("max_diff_lines", 500)
+
+    # --- Input validation ---
+    VALID_VIEW_TYPES = {'status', 'diff', 'log'}
+    if view_type not in VALID_VIEW_TYPES:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": (
+                f"Unknown view_type: '{view_type}'. "
+                f"Supported values: {', '.join(sorted(VALID_VIEW_TYPES))}."
+            ),
+        }
+
+    # Treat empty string category as None (no filter)
+    if category is not None and category == "":
+        category = None
+
+    VALID_CATEGORIES = {'added', 'modified', 'deleted', 'unchanged'}
+    if category is not None and category not in VALID_CATEGORIES:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": (
+                f"Invalid category: '{category}'. "
+                f"Must be one of: {', '.join(sorted(VALID_CATEGORIES))}."
+            ),
+        }
+
+    # Validate max_count
+    if not isinstance(max_count, (int, float)) or isinstance(max_count, bool):
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Invalid max_count: must be a number, got {type(max_count).__name__}.",
+        }
+    max_count = int(max_count)
+    if max_count < 0:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Invalid max_count: must be non-negative, got {max_count}.",
+        }
+
+    # Validate max_diff_lines
+    if max_diff_lines is not None:
+        if not isinstance(max_diff_lines, (int, float)) or isinstance(max_diff_lines, bool):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"Invalid max_diff_lines: must be a number, got {type(max_diff_lines).__name__}.",
+            }
+        max_diff_lines = int(max_diff_lines)
+        if max_diff_lines < 0:
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"Invalid max_diff_lines: must be non-negative, got {max_diff_lines}.",
+            }
+
+    try:
+        git_manager = GitManager(root_dir=os.getcwd())
+
+        if view_type == "status":
+            status = git_manager.get_status(category=category)
+            result_parts = []
+
+            if status["commit_id"]:
+                result_parts.append(f"Last commit: {status['commit_id'][:8]} - {status['commit_message']}")
+            else:
+                result_parts.append("No commits yet.")
+
+            if category:
+                # Only show the requested category
+                label = category.capitalize()
+                items = status[category]
+                result_parts.append("")
+                result_parts.append(f"{label} ({len(items)}):")
+                for f in items[:50]:
+                    symbol = {"added": "+", "modified": "~", "deleted": "-", "unchanged": " "}.get(category, "")
+                    result_parts.append(f"  {symbol} {f}")
+                if len(items) > 50:
+                    result_parts.append(f"  ... and {len(items) - 50} more")
+            else:
+                # Show all categories
+                result_parts.append("")
+                result_parts.append(f"Added ({len(status['added'])}):")
+                for f in status["added"][:50]:
+                    result_parts.append(f"  + {f}")
+                if len(status["added"]) > 50:
+                    result_parts.append(f"  ... and {len(status['added']) - 50} more")
+
+                result_parts.append("")
+                result_parts.append(f"Modified ({len(status['modified'])}):")
+                for f in status["modified"][:50]:
+                    result_parts.append(f"  ~ {f}")
+                if len(status["modified"]) > 50:
+                    result_parts.append(f"  ... and {len(status['modified']) - 50} more")
+
+                result_parts.append("")
+                result_parts.append(f"Deleted ({len(status['deleted'])}):")
+                for f in status["deleted"][:50]:
+                    result_parts.append(f"  - {f}")
+                if len(status["deleted"]) > 50:
+                    result_parts.append(f"  ... and {len(status['deleted']) - 50} more")
+
+                result_parts.append("")
+                result_parts.append(f"Unchanged ({len(status['unchanged'])} files)")
+
+            content = "\n".join(result_parts)
+
+        elif view_type == "diff":
+            diffs = git_manager.get_diff(path_filter=path, max_diff_lines=max_diff_lines)
+
+            if not diffs:
+                content = "No differences found between working tree and last commit."
+            else:
+                result_parts = []
+                result_parts.append(f"Showing {len(diffs)} changed file(s):")
+                if path:
+                    result_parts.append(f"(filtered to files containing '{path}')")
+                if max_diff_lines:
+                    result_parts.append(f"(diffs truncated to {max_diff_lines} lines each)")
+                result_parts.append("")
+
+                for d in diffs:
+                    change_symbol = {"added": "+", "modified": "~", "deleted": "-"}.get(d["change_type"], "?")
+                    result_parts.append(f"{'='*60}")
+                    result_parts.append(f"{change_symbol} {d['change_type'].upper()}: {d['path']}")
+                    result_parts.append(f"{'='*60}")
+                    result_parts.append(d["content"])
+                    result_parts.append("")
+
+                content = "\n".join(result_parts)
+
+        elif view_type == "log":
+            commits = git_manager.get_log(max_count=max_count)
+
+            if not commits:
+                content = "No commits found."
+            else:
+                result_parts = []
+                result_parts.append(f"Last {len(commits)} commit(s):")
+                result_parts.append("")
+                for c in commits:
+                    short_id = c["commit_id"][:8]
+                    result_parts.append(f"  commit {short_id}")
+                    result_parts.append(f"  Author: {c['author']}")
+                    result_parts.append(f"  Date:   {c['timestamp']}")
+                    result_parts.append("")
+                    result_parts.append(f"      {c['message']}")
+                    result_parts.append("")
+                content = "\n".join(result_parts)
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": content,
+        }
+
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error executing ViewChanges: {str(e)}",
+        }

Tools/walk_call_tree.py

@@ -0,0 +1,30 @@
+from RAG.graph import walk_call_tree
+from .utils import is_within_cwd, BLUE, RESET
+
+
+def handle(arguments, toolcall_id):
+    symbol_name = arguments["symbol_name"]
+    file_path = arguments.get("file_path")
+    max_depth = arguments.get("max_depth", 5)
+    include_external = arguments.get("include_external", False)
+    exclude = arguments.get("exclude")
+    print(f"{BLUE}WalkCallTree {symbol_name} (depth={max_depth}){RESET}")
+
+    # Check if the file is outside the current working directory
+    if file_path and not is_within_cwd(file_path):
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: access denied - path is outside the current working directory",
+        }
+
+    try:
+        result = walk_call_tree(symbol_name, file_path, max_depth, include_external, exclude)
+    except Exception as e:
+        result = f"Error walking call tree: {str(e)}"
+
+    return {
+        "role": "tool",
+        "tool_call_id": toolcall_id,
+        "content": result,
+    }

Tools/web_fetch.py

@@ -0,0 +1,175 @@
+import re
+import gzip
+import zlib
+from html.parser import HTMLParser
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError, URLError
+
+from .utils import BLUE, RED, RESET
+
+
+DEFAULT_MAX_CHARS = 20000
+DEFAULT_TIMEOUT = 20
+USER_AGENT = "Mozilla/5.0 (compatible; RaggieBot/1.0; +https://github.com/myuser/raggie)"
+
+_BLOCK_TAGS = {
+    "p", "div", "section", "article", "header", "footer", "main", "br",
+    "h1", "h2", "h3", "h4", "h5", "h6", "li", "tr", "ul", "ol", "table",
+    "blockquote", "pre", "hr", "figure", "figcaption", "nav",
+}
+_SKIP_TAGS = {"script", "style", "noscript", "template", "svg", "head"}
+
+
+class _TextExtractor(HTMLParser):
+    """Convert HTML into readable plain text using only the stdlib.
+
+    Drops script/style/etc., inserts newlines around block-level elements,
+    and collapses runs of whitespace.
+    """
+
+    def __init__(self):
+        super().__init__(convert_charrefs=True)
+        self._parts = []
+        self._skip_depth = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in _SKIP_TAGS:
+            self._skip_depth += 1
+        elif tag in _BLOCK_TAGS:
+            self._parts.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag in _SKIP_TAGS and self._skip_depth > 0:
+            self._skip_depth -= 1
+        elif tag in _BLOCK_TAGS:
+            self._parts.append("\n")
+
+    def handle_data(self, data):
+        if self._skip_depth == 0 and data.strip():
+            self._parts.append(data)
+
+    def get_text(self):
+        text = "".join(self._parts)
+        # Collapse horizontal whitespace, then squeeze blank lines.
+        text = re.sub(r"[ \t\r\f\v]+", " ", text)
+        text = re.sub(r"\n[ \t]+", "\n", text)
+        text = re.sub(r"\n{3,}", "\n\n", text)
+        return text.strip()
+
+
+def _decode_body(raw, headers):
+    """Decompress (if needed) and decode the response body to str."""
+    encoding = (headers.get("Content-Encoding") or "").lower()
+    if "gzip" in encoding:
+        try:
+            raw = gzip.decompress(raw)
+        except OSError as e:
+            print(f"{RED}Warning: Failed to decompress gzip response: {e}{RESET}")
+    elif "deflate" in encoding:
+        try:
+            raw = zlib.decompress(raw)
+        except zlib.error:
+            raw = zlib.decompress(raw, -zlib.MAX_WBITS)
+
+    charset = "utf-8"
+    content_type = headers.get("Content-Type", "")
+    match = re.search(r"charset=([\w\-]+)", content_type, re.IGNORECASE)
+    if match:
+        charset = match.group(1)
+    try:
+        return raw.decode(charset, errors="replace")
+    except (LookupError, TypeError):
+        return raw.decode("utf-8", errors="replace")
+
+
+def handle(arguments, toolcall_id):
+    url = arguments.get("url")
+    print(f"{BLUE}WebFetch {url}{RESET}")
+
+    if not url:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: 'url' is required",
+        }
+
+    if not re.match(r"^https?://", url, re.IGNORECASE):
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: url must start with http:// or https://",
+        }
+
+    max_chars = arguments.get("max_chars", DEFAULT_MAX_CHARS)
+    try:
+        max_chars = int(max_chars)
+    except (TypeError, ValueError):
+        max_chars = DEFAULT_MAX_CHARS
+
+    req = Request(
+        url,
+        headers={
+            "User-Agent": USER_AGENT,
+            "Accept": "text/html,application/xhtml+xml,application/json,text/plain,*/*",
+            "Accept-Encoding": "gzip, deflate",
+        },
+    )
+
+    try:
+        with urlopen(req, timeout=DEFAULT_TIMEOUT) as resp:
+            headers = resp.headers
+            raw = resp.read()
+            final_url = resp.geturl()
+    except HTTPError as err:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error: HTTP {err.code} {err.reason} for {url}",
+        }
+    except URLError as err:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error: failed to fetch {url}: {err.reason}",
+        }
+    except Exception as err:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error fetching {url}: {err}",
+        }
+
+    content_type = (headers.get("Content-Type") or "").lower()
+
+    if "html" in content_type:
+        body = _decode_body(raw, headers)
+        parser = _TextExtractor()
+        try:
+            parser.feed(body)
+            text = parser.get_text()
+        except Exception:
+            text = body
+    elif content_type.startswith("text/") or "json" in content_type or "xml" in content_type:
+        text = _decode_body(raw, headers)
+    else:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error: unsupported content type '{content_type}' for {url} ({len(raw)} bytes). Only text/HTML/JSON/XML are supported.",
+        }
+
+    truncated = False
+    if len(text) > max_chars:
+        text = text[:max_chars]
+        truncated = True
+
+    header = f"URL: {final_url}\nContent-Type: {content_type or 'unknown'}\n"
+    if truncated:
+        header += f"[truncated to {max_chars} chars]\n"
+    header += "\n"
+
+    return {
+        "role": "tool",
+        "tool_call_id": toolcall_id,
+        "content": header + text,
+    }

Tools/web_search.py

@@ -0,0 +1,69 @@
+from .utils import BLUE, RESET
+
+
+DEFAULT_MAX_RESULTS = 5
+MAX_RESULTS_CAP = 20
+
+
+def handle(arguments, toolcall_id):
+    query = arguments.get("query")
+    print(f"{BLUE}WebSearch {query}{RESET}")
+
+    if not query or not str(query).strip():
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: 'query' is required",
+        }
+
+    max_results = arguments.get("max_results", DEFAULT_MAX_RESULTS)
+    try:
+        max_results = int(max_results)
+    except (TypeError, ValueError):
+        max_results = DEFAULT_MAX_RESULTS
+    max_results = max(1, min(max_results, MAX_RESULTS_CAP))
+
+    region = arguments.get("region") or "wt-wt"
+
+    try:
+        from ddgs import DDGS
+    except ImportError:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": "Error: the 'ddgs' package is not installed. Run: pip install ddgs",
+        }
+
+    try:
+        results = DDGS().text(query, region=region, max_results=max_results)
+    except Exception as err:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error performing web search: {err}",
+        }
+
+    if not results:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"No results found for '{query}'.",
+        }
+
+    lines = [f"Search results for '{query}':", ""]
+    for i, item in enumerate(results, start=1):
+        title = (item.get("title") or "").strip()
+        href = (item.get("href") or "").strip()
+        body = (item.get("body") or "").strip()
+        lines.append(f"{i}. {title}")
+        if href:
+            lines.append(f"   URL: {href}")
+        if body:
+            lines.append(f"   {body}")
+        lines.append("")
+
+    return {
+        "role": "tool",
+        "tool_call_id": toolcall_id,
+        "content": "\n".join(lines).strip(),
+    }

Tools/write.py

@@ -0,0 +1,48 @@
+from .utils import is_ignored_by_gitignore, is_within_cwd, BLUE, RESET, auto_record_change, reindex_after_change, remove_em_dashes
+
+
+def handle(arguments, toolcall_id, session_id=None, code_indexer=None):
+    file_path = arguments["file_path"]
+    content = arguments["content"]
+    print(f"{BLUE}Writing {file_path}{RESET}")
+
+    try:
+        # Check if the file is outside the current working directory
+        if not is_within_cwd(file_path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": "Error: access denied - path is outside the current working directory",
+            }
+
+        # Check if file is in .gitignore
+        if is_ignored_by_gitignore(file_path):
+            return {
+                "role": "tool",
+                "tool_call_id": toolcall_id,
+                "content": f"Error: File '{file_path}' is in .gitignore. Operations on gitignored files are not allowed.",
+            }
+
+        content = remove_em_dashes(content)
+
+        with open(file_path, "w") as f:
+            f.write(content)
+
+        if session_id is not None:
+            from Agent.chat_history_db import record_session_file
+            record_session_file(session_id, file_path, "write")
+            auto_record_change(session_id, file_path, "file_create", f"Created file {file_path}")
+
+        reindex_after_change(code_indexer)
+
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"file {file_path} written successfully",
+        }
+    except Exception as e:
+        return {
+            "role": "tool",
+            "tool_call_id": toolcall_id,
+            "content": f"Error writing file: {str(e)}",
+        }

cli.py

@@ -0,0 +1,111 @@
+import argparse
+import sys
+
+KNOWN_COMMANDS = {"skill", "roles", "keys", "setup"}
+
+
+def _create_agent_parser():
+    """Parser for the default agent mode: raggie <role> <project-dir>."""
+    parser = argparse.ArgumentParser(
+        prog="raggie",
+        description="Raggie - AI Coding Agent",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""commands:
+  raggie <role> <project-dir>   Run the AI agent (e.g. raggie code .)
+  raggie skill <role> ...       Manage agent skills
+  raggie roles                  List and edit agent roles
+  raggie keys                   Manage API keys
+  raggie setup                  First-time setup (keys + roles)
+
+examples:
+  raggie code .                                   # interactive mode in current dir
+  raggie code /path/to/project                    # interactive mode in a project
+  raggie code . --prompt "Write a hello function" # single prompt
+  raggie code /tmp/new-project                    # creates dir if missing
+  raggie skill code --show                        # list all skills for role
+  raggie skill code --show --name testing         # show a specific skill
+  raggie skill code --import-skill skills.md --name testing  # import from file
+  raggie skill code --delete --name testing       # delete a skill
+  raggie skill --list-all                        # list all skills across all roles
+        """
+    )
+    parser.add_argument("--version", action="version", version=f"raggie v{__import__('importlib.metadata').metadata.version('raggiecode')}")
+    parser.add_argument("role", nargs="?", help="The agent role to use (defined in roles.json)")
+    parser.add_argument("project_dir", nargs="?", default=".", help="Path to the project directory (use '.' for current directory)")
+    parser.add_argument("--prompt", help="The initial prompt for the agent (if not provided, runs in interactive mode)")
+    parser.add_argument("--effort", type=int, choices=[1, 2, 3, 4, 5], help="Effort level: 1=Zen, 2=Serious, 3=Extreme, 4=Feral, 5=Insane (default: 1=Zen)")
+    parser.add_argument("--debug", action="store_true", help="Enable debug mode to display tool call outputs")
+    return parser
+
+
+def _create_subcommand_parser():
+    """Parser for subcommands: skill, roles, keys."""
+    parser = argparse.ArgumentParser(
+        description="Raggie - AI Coding Agent",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=f"raggie v{__import__('importlib.metadata').metadata.version('raggiecode')}")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Skill command
+    skill_parser = subparsers.add_parser(
+        "skill",
+        help="Manage agent skills",
+        description="Manage named skills stored in the database. A role can have multiple skills, each identified by a unique name.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  raggie skill code --show                              # list all skills for role 'code'
+  raggie skill code --show --name testing               # show full content of a specific skill
+  raggie skill code --import-skill my-skill.md --name testing   # import from file
+  raggie skill code --export-skill backup.md --name testing     # export to file
+  raggie skill code --delete --name testing             # delete a skill
+  raggie skill --list-all                               # list all skills across all roles
+        """
+    )
+    skill_parser.add_argument("role", nargs="?", help="The agent role (required unless using --list-all)")
+    skill_parser.add_argument("--name", help="The skill name (required for --import-skill, --export-skill, --delete)")
+    skill_parser.add_argument("--import-skill", metavar="FILE", help="Import skill from markdown file into the database (requires --name)")
+    skill_parser.add_argument("--export-skill", metavar="FILE", help="Export skill from database to markdown file (requires --name)")
+    skill_parser.add_argument("--show", action="store_true", help="Display skill(s) for the role (all if --name omitted)")
+    skill_parser.add_argument("--delete", action="store_true", help="Delete a skill (requires --name)")
+    skill_parser.add_argument("--list-all", action="store_true", help="List all skills across all roles")
+
+    # Roles command
+    subparsers.add_parser(
+        "roles",
+        help="List and edit agent roles",
+        description="List all agent roles and interactively edit their base URL and model settings.",
+    )
+
+    # Keys command
+    subparsers.add_parser(
+        "keys",
+        help="Manage API keys",
+        description="Interactive interface to list, add, and remove API keys stored in keys.json.",
+    )
+
+    # Setup command
+    subparsers.add_parser(
+        "setup",
+        help="First-time setup wizard",
+        description="Guided first-time setup: configure API keys, then review agent roles.",
+    )
+
+    return parser
+
+
+def parse_args():
+    """Parse command-line arguments and return the parsed args."""
+    if len(sys.argv) > 1 and sys.argv[1] in KNOWN_COMMANDS:
+        parser = _create_subcommand_parser()
+    else:
+        parser = _create_agent_parser()
+
+    args = parser.parse_args()
+
+    if getattr(args, "command", None) is None and getattr(args, "role", None) is None:
+        parser.print_help()
+        sys.exit(1)
+
+    return args