iac-code 0.1.0__py3-none-any.whl

iac_code/tools/cloud/types.py

@@ -0,0 +1,105 @@
+from dataclasses import dataclass
+
+from iac_code.i18n import _
+
+# Stack/resource status strings for pybabel extraction.
+# Reference: https://help.aliyun.com/zh/ros/developer-reference/api-ros-2019-09-10-getstack
+_STACK_STATUS_STRINGS = [
+    _("CREATE_IN_PROGRESS"),
+    _("CREATE_FAILED"),
+    _("CREATE_COMPLETE"),
+    _("UPDATE_IN_PROGRESS"),
+    _("UPDATE_FAILED"),
+    _("UPDATE_COMPLETE"),
+    _("DELETE_IN_PROGRESS"),
+    _("DELETE_FAILED"),
+    _("DELETE_COMPLETE"),
+    _("CREATE_ROLLBACK_IN_PROGRESS"),
+    _("CREATE_ROLLBACK_FAILED"),
+    _("CREATE_ROLLBACK_COMPLETE"),
+    _("ROLLBACK_IN_PROGRESS"),
+    _("ROLLBACK_FAILED"),
+    _("ROLLBACK_COMPLETE"),
+    _("CHECK_IN_PROGRESS"),
+    _("CHECK_FAILED"),
+    _("CHECK_COMPLETE"),
+    _("REVIEW_IN_PROGRESS"),
+    _("IMPORT_CREATE_IN_PROGRESS"),
+    _("IMPORT_CREATE_FAILED"),
+    _("IMPORT_CREATE_COMPLETE"),
+    _("IMPORT_CREATE_ROLLBACK_IN_PROGRESS"),
+    _("IMPORT_CREATE_ROLLBACK_FAILED"),
+    _("IMPORT_CREATE_ROLLBACK_COMPLETE"),
+    _("IMPORT_UPDATE_IN_PROGRESS"),
+    _("IMPORT_UPDATE_FAILED"),
+    _("IMPORT_UPDATE_COMPLETE"),
+    _("IMPORT_UPDATE_ROLLBACK_IN_PROGRESS"),
+    _("IMPORT_UPDATE_ROLLBACK_FAILED"),
+    _("IMPORT_UPDATE_ROLLBACK_COMPLETE"),
+    # Resource-level statuses (ListStackResources API)
+    _("INIT_COMPLETE"),
+    _("IMPORT_IN_PROGRESS"),
+    _("IMPORT_COMPLETE"),
+    _("IMPORT_FAILED"),
+]
+
+
+def translate_status(status: str) -> str:
+    """Translate a stack/resource status code to localized display text."""
+    return _(status)
+
+
+@dataclass
+class StackStatus:
+    stack_id: str
+    stack_name: str
+    status: str
+    status_reason: str
+    progress_percentage: float
+
+    @property
+    def is_terminal(self) -> bool:
+        return self.status.endswith("_COMPLETE") or self.status.endswith("_FAILED")
+
+    @property
+    def is_success(self) -> bool:
+        return self.status.endswith("_COMPLETE")
+
+
+@dataclass
+class ResourceStatus:
+    name: str
+    resource_type: str
+    status: str
+    status_reason: str
+
+    @property
+    def status_icon(self) -> str:
+        if self.status.endswith("_COMPLETE"):
+            return "\u2705"
+        if "IN_PROGRESS" in self.status:
+            return "\u23f3"
+        if self.status.endswith("_FAILED"):
+            return "\u274c"
+        if "DELETE" in self.status:
+            return "\U0001f5d1\ufe0f"
+        return "\u2b1a"
+
+
+@dataclass
+class InstanceStatus:
+    account_id: str
+    region_id: str
+    status: str
+    status_reason: str
+    elapsed_seconds: int
+
+    @property
+    def status_icon(self) -> str:
+        if self.status in ("SUCCEEDED", "CURRENT"):
+            return "\u2705"
+        if self.status in ("RUNNING",):
+            return "\u23f3"
+        if self.status in ("FAILED",):
+            return "\u274c"
+        return "\u2b1a"

iac_code/tools/edit_file.py

@@ -0,0 +1,121 @@
+"""EditFile tool - makes targeted edits to files using search and replace."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from iac_code.i18n import _
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+
+
+class EditFileTool(Tool):
+    @property
+    def name(self) -> str:
+        return "edit_file"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Make targeted edits to a file using search and replace. The old_string must "
+            "match exactly one location in the file. For creating new files, use WriteFile instead. "
+            "Always read the file first to understand its current content before editing."
+        )
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "The path to the file to edit.",
+                },
+                "old_string": {
+                    "type": "string",
+                    "description": "The exact string to search for in the file. Must match exactly one location.",
+                },
+                "new_string": {
+                    "type": "string",
+                    "description": "The string to replace old_string with.",
+                },
+            },
+            "required": ["path", "old_string", "new_string"],
+        }
+
+    def normalize_input(self, tool_input: dict[str, Any]) -> None:
+        if "file_path" in tool_input and "path" not in tool_input:
+            tool_input["path"] = tool_input.pop("file_path")
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        path = tool_input["path"]
+        old_string = tool_input["old_string"]
+        new_string = tool_input["new_string"]
+
+        if not os.path.isabs(path):
+            path = os.path.join(context.cwd, path)
+
+        if not os.path.exists(path):
+            return ToolResult.error(f"File not found: {path}")
+
+        try:
+            with open(path, encoding="utf-8") as f:
+                content = f.read()
+        except Exception as e:
+            return ToolResult.error(f"Error reading file: {e}")
+
+        # Check for exact match
+        count = content.count(old_string)
+        if count == 0:
+            return ToolResult.error(
+                f"old_string not found in {path}. Make sure the string matches exactly, "
+                "including whitespace and indentation."
+            )
+        if count > 1:
+            return ToolResult.error(
+                f"old_string found {count} times in {path}. It must match exactly once. "
+                "Include more surrounding context to make the match unique."
+            )
+
+        # Perform the replacement
+        new_content = content.replace(old_string, new_string, 1)
+
+        try:
+            with open(path, "w", encoding="utf-8") as f:
+                f.write(new_content)
+        except Exception as e:
+            return ToolResult.error(f"Error writing file: {e}")
+
+        return ToolResult.success(f"Successfully edited {path}")
+
+    # UI rendering methods
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False):
+        path = input.get("path", "")
+        if not path:
+            return None
+        if verbose and (input.get("old_string") or input.get("new_string")):
+            old = input.get("old_string", "")
+            preview = old[:60] + "…" if len(old) > 60 else old
+            preview = preview.replace("\n", "↵")
+            return f"{path} · {preview}"
+        return path
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False):
+        if verbose:
+            return output
+        # Compact: just the success/error summary line
+        first_line = output.split("\n", 1)[0] if output else output
+        return first_line
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        if input and input.get("old_string") == "":
+            return _("Create")
+        return _("Update")
+
+    def get_activity_description(self, input: dict | None = None) -> str:
+        if input:
+            return _("Editing {path}").format(path=input.get("path", ""))
+        return _("Editing file...")
+
+    def is_destructive(self, input: dict | None = None) -> bool:
+        return True

iac_code/tools/glob.py

@@ -0,0 +1,103 @@
+"""GlobTool - fast file pattern matching using glob."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from iac_code.i18n import _
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+
+
+class GlobTool(Tool):
+    @property
+    def name(self) -> str:
+        return "glob"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Fast file pattern matching using glob patterns. Searches for files "
+            "matching the given pattern and returns matching file paths sorted by "
+            "modification time (newest first). Use ** for recursive matching."
+        )
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "The glob pattern to match files against, e.g. '**/*.py' or 'src/**/*.ts'.",
+                },
+                "path": {
+                    "type": "string",
+                    "description": "The directory to search in. Defaults to current working directory.",
+                },
+            },
+            "required": ["pattern"],
+        }
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        pattern = tool_input["pattern"]
+        path = tool_input.get("path", context.cwd)
+
+        search_root = Path(path)
+        if not search_root.is_absolute():
+            search_root = Path(context.cwd) / path
+
+        if not search_root.exists():
+            return ToolResult.error(f"Path not found: {path}")
+
+        if not search_root.is_dir():
+            return ToolResult.error(f"Not a directory: {path}")
+
+        try:
+            matches = [p for p in search_root.glob(pattern) if p.is_file()]
+        except Exception as e:
+            return ToolResult.error(f"Error during glob: {e}")
+
+        if not matches:
+            return ToolResult.success("No files found")
+
+        # Sort by mtime descending (newest first)
+        matches.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+
+        # Return relative paths
+        relative_paths = [str(p.relative_to(search_root)) for p in matches]
+        return ToolResult.success("\n".join(relative_paths))
+
+    # UI rendering methods
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False):
+        pattern = input.get("pattern", "")
+        if not pattern:
+            return None
+        path = input.get("path", "")
+        if path:
+            return f'pattern: "{pattern}", path: "{path}"'
+        return f'pattern: "{pattern}"'
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False):
+        if is_error:
+            return output
+        if output == "No files found":
+            return _("Found 0 files")
+        lines = output.strip().splitlines()
+        count = len(lines)
+        summary = _("Found {count} files").format(count=count)
+        if verbose:
+            return f"{summary}\n" + "\n".join(f"    {line}" for line in lines)
+        return summary
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        return _("Search")
+
+    def get_activity_description(self, input: dict | None = None) -> str:
+        if input:
+            pattern = input.get("pattern", "")
+            return _("Searching {pattern}").format(pattern=pattern)
+        return _("Searching files...")
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return True

iac_code/tools/grep.py

@@ -0,0 +1,254 @@
+"""GrepTool - content search using ripgrep with Python fallback."""
+
+from __future__ import annotations
+
+import asyncio
+import fnmatch
+import os
+import re
+import shutil
+from typing import Any
+
+from iac_code.i18n import _
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+
+
+def _is_rg_available() -> bool:
+    """Check whether ripgrep (rg) is available on the system PATH."""
+    return shutil.which("rg") is not None
+
+
+async def _run_rg(
+    pattern: str,
+    path: str,
+    *,
+    glob: str | None = None,
+    case_insensitive: bool = False,
+    output_mode: str = "files_with_matches",
+    max_results: int = 100,
+) -> tuple[int, str, str]:
+    """Run ripgrep and return (returncode, stdout, stderr)."""
+    cmd: list[str] = ["rg"]
+
+    if case_insensitive:
+        cmd.append("--ignore-case")
+
+    if output_mode == "content":
+        cmd.extend(["--line-number", "--with-filename"])
+    else:
+        cmd.append("--files-with-matches")
+
+    if glob:
+        cmd.extend(["--glob", glob])
+
+    # For content mode, --max-count limits matches per file.
+    # We apply a total limit by post-processing the output lines.
+    if output_mode == "content":
+        cmd.extend(["--max-count", str(max_results)])
+
+    cmd.append("--")
+    cmd.append(pattern)
+    cmd.append(path)
+
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout_bytes, stderr_bytes = await proc.communicate()
+    return (
+        proc.returncode or 0,
+        stdout_bytes.decode(errors="replace"),
+        stderr_bytes.decode(errors="replace"),
+    )
+
+
+def _python_grep(
+    pattern: str,
+    path: str,
+    *,
+    glob: str | None = None,
+    case_insensitive: bool = False,
+    output_mode: str = "files_with_matches",
+    max_results: int = 100,
+) -> str:
+    """Pure-Python fallback for grep using re + os.walk."""
+    flags = re.IGNORECASE if case_insensitive else 0
+    try:
+        compiled = re.compile(pattern, flags)
+    except re.error as e:
+        return f"Invalid pattern: {e}"
+
+    results: list[str] = []
+    files_matched = 0
+
+    for dirpath, _dirnames, filenames in os.walk(path):
+        if files_matched >= max_results:
+            break
+        for filename in sorted(filenames):
+            if files_matched >= max_results:
+                break
+            if glob and not fnmatch.fnmatch(filename, glob):
+                continue
+            filepath = os.path.join(dirpath, filename)
+            try:
+                with open(filepath, encoding="utf-8", errors="replace") as fh:
+                    lines = fh.readlines()
+            except (PermissionError, OSError):
+                continue
+
+            matched_lines: list[str] = []
+            for lineno, line in enumerate(lines, start=1):
+                if compiled.search(line):
+                    if output_mode == "content":
+                        matched_lines.append(f"{filepath}:{lineno}:{line.rstrip()}")
+                    else:
+                        matched_lines.append(filepath)
+                        break  # files_with_matches — one hit is enough
+
+            if matched_lines:
+                if output_mode == "content":
+                    results.extend(matched_lines)
+                else:
+                    results.append(filepath)
+                    files_matched += 1
+
+    return "\n".join(results)
+
+
+class GrepTool(Tool):
+    @property
+    def name(self) -> str:
+        return "grep"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Search for a regex pattern across file contents. Uses ripgrep (rg) when "
+            "available for speed, otherwise falls back to a pure-Python implementation. "
+            "Returns matching file paths or matching lines depending on output_mode."
+        )
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "pattern": {
+                    "type": "string",
+                    "description": "The regular expression pattern to search for.",
+                },
+                "path": {
+                    "type": "string",
+                    "description": ("The directory to search in. Defaults to current working directory."),
+                },
+                "glob": {
+                    "type": "string",
+                    "description": (
+                        "Glob pattern to filter files, e.g. '*.py'. "
+                        "Only files whose names match this pattern will be searched."
+                    ),
+                },
+                "case_insensitive": {
+                    "type": "boolean",
+                    "description": "Perform a case-insensitive search. Defaults to false.",
+                },
+                "output_mode": {
+                    "type": "string",
+                    "enum": ["files_with_matches", "content"],
+                    "description": (
+                        "Controls output format. "
+                        "'files_with_matches' (default) returns only the paths of matching files. "
+                        "'content' returns each matching line with its file path and line number."
+                    ),
+                },
+                "max_results": {
+                    "type": "integer",
+                    "description": "Maximum number of results to return. Defaults to 100.",
+                },
+            },
+            "required": ["pattern"],
+        }
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        pattern: str = tool_input["pattern"]
+        path: str = tool_input.get("path", context.cwd)
+        glob: str | None = tool_input.get("glob")
+        case_insensitive: bool = bool(tool_input.get("case_insensitive", False))
+        output_mode: str = tool_input.get("output_mode", "files_with_matches")
+        max_results: int = int(tool_input.get("max_results", 100))
+
+        # Resolve relative paths against cwd
+        if not os.path.isabs(path):
+            path = os.path.join(context.cwd, path)
+
+        if not os.path.exists(path):
+            return ToolResult.error(f"Path not found: {path}")
+
+        if _is_rg_available():
+            returncode, stdout, stderr = await _run_rg(
+                pattern,
+                path,
+                glob=glob,
+                case_insensitive=case_insensitive,
+                output_mode=output_mode,
+                max_results=max_results,
+            )
+            # rg exits with 1 when no matches found (not an error)
+            if returncode > 1:
+                return ToolResult.error(f"ripgrep error: {stderr.strip()}")
+            output = stdout.strip()
+        else:
+            output = _python_grep(
+                pattern,
+                path,
+                glob=glob,
+                case_insensitive=case_insensitive,
+                output_mode=output_mode,
+                max_results=max_results,
+            ).strip()
+
+        if not output:
+            return ToolResult.success("No matches")
+
+        # Enforce max_results on total output lines
+        lines = output.splitlines()
+        if len(lines) > max_results:
+            output = "\n".join(lines[:max_results])
+
+        return ToolResult.success(output)
+
+    # UI rendering methods
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False):
+        pattern = input.get("pattern", "")
+        if not pattern:
+            return None
+        parts = [f'pattern: "{pattern}"']
+        path = input.get("path", "")
+        if path:
+            parts.append(f'path: "{path}"')
+        return ", ".join(parts)
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False):
+        if is_error:
+            return output
+        if output == "No matches":
+            return _("Found 0 files")
+        lines = output.strip().splitlines()
+        count = len(lines)
+        summary = _("Found {count} files").format(count=count)
+        if verbose:
+            return f"{summary}\n" + "\n".join(f"    {line}" for line in lines)
+        return summary
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        return _("Search")
+
+    def get_activity_description(self, input: dict | None = None) -> str:
+        if input:
+            pattern = input.get("pattern", "")
+            return _("Searching for {pattern}").format(pattern=pattern)
+        return _("Searching content...")
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return True

iac_code/tools/list_files.py

@@ -0,0 +1,104 @@
+"""ListFiles tool - lists directory contents."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from iac_code.i18n import _
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+
+
+class ListFilesTool(Tool):
+    @property
+    def name(self) -> str:
+        return "list_files"
+
+    @property
+    def description(self) -> str:
+        return (
+            "List the contents of a directory. Returns file and directory names "
+            "with indicators for type (file/directory). Useful for exploring "
+            "project structure."
+        )
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "The directory path to list. Defaults to current working directory.",
+                },
+            },
+            "required": [],
+        }
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        path = tool_input.get("path", context.cwd)
+
+        if not os.path.isabs(path):
+            path = os.path.join(context.cwd, path)
+
+        if not os.path.exists(path):
+            return ToolResult.error(f"Path not found: {path}")
+
+        if not os.path.isdir(path):
+            return ToolResult.error(f"Not a directory: {path}")
+
+        try:
+            entries = sorted(os.listdir(path))
+        except PermissionError:
+            return ToolResult.error(f"Permission denied: {path}")
+        except Exception as e:
+            return ToolResult.error(f"Error listing directory: {e}")
+
+        if not entries:
+            return ToolResult.success(f"Directory {path} is empty.")
+
+        lines = []
+        for entry in entries:
+            full_path = os.path.join(path, entry)
+            if os.path.isdir(full_path):
+                lines.append(f"  {entry}/")
+            else:
+                size = os.path.getsize(full_path)
+                lines.append(f"  {entry} ({_format_size(size)})")
+
+        result = f"Directory: {path}\n\n" + "\n".join(lines)
+        return ToolResult.success(result)
+
+    # UI rendering methods
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False):
+        path = input.get("path", ".")
+        return path
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False):
+        if is_error:
+            return output
+        lines = [line for line in output.strip().splitlines() if line.startswith("  ")]
+        summary = _("Found {count} items").format(count=len(lines))
+        if verbose:
+            return f"{summary}\n" + "\n".join(f"    {line.strip()}" for line in lines)
+        return summary
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        return _("List")
+
+    def get_activity_description(self, input: dict | None = None) -> str:
+        if input:
+            return _("Listing {path}").format(path=input.get("path", "."))
+        return _("Listing files...")
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return True
+
+
+def _format_size(size: int | float) -> str:
+    """Format file size in human readable form."""
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size < 1024:
+            return f"{size:.0f}{unit}" if unit == "B" else f"{size:.1f}{unit}"
+        size /= 1024
+    return f"{size:.1f}TB"