crabcode 0.1.6__py3-none-win_amd64.whl

crabcode_core/tools/image.py

@@ -0,0 +1,173 @@
+"""ImageTool - attach local images with optional inline descriptions."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.io_worker import run_file_tool
+from crabcode_core.types.tool import PermissionBehavior, PermissionResult, Tool, ToolContext, ToolResult
+
+
+class ImageTool(Tool):
+    """Emit local images as separate ImageContent blocks.
+
+    Codex tools send image bytes through ``emitImage`` instead of putting a
+    filesystem path in Markdown.  This tool provides the same explicit
+    boundary to the model after another tool creates an image file.
+    """
+
+    name = "Image"
+    description = "View and analyze local images, including PSD composite previews, or attach images for the user."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema: dict[str, Any] = {
+        "type": "object",
+        "properties": {
+            "path": {
+                "anyOf": [
+                    {"type": "string", "minLength": 1},
+                    {"type": "array", "items": {"type": "string", "minLength": 1}, "minItems": 1},
+                ],
+                "description": "One absolute or session-relative image path, or a non-empty list of image paths in display order.",
+            },
+            "description": {
+                "anyOf": [
+                    {"type": "string"},
+                    {"type": "array", "items": {"type": "string"}, "minItems": 1},
+                ],
+                "description": "Optional plain-text caption below each image. Use a string for one image, or a list matching the paths in length and order. Use an empty string to omit an individual caption.",
+            },
+            "mime_type": {
+                "type": "string",
+                "description": "Optional expected output image MIME type for all paths. Converted previews use image/png. Usually omit to detect automatically.",
+            },
+        },
+        "required": ["path"],
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "View and analyze one or more local images, or attach images for the user. "
+            "You receive the actual image content for visual analysis after this tool returns. "
+            "Read also supports viewing a single local image. PSD files are converted "
+            "to saved composite previews; other non-native formats are converted to PNG. "
+            "Large images may be resized; animated/multipage images show the first frame/page. The image "
+            "bytes are sent as a separate ImageContent block, so do not put a "
+            "file:// or local filesystem path in Markdown. Pass path as a string "
+            "or a non-empty list of paths. Optionally pass description as a string "
+            "for one image or a list matching the paths in length and order; each "
+            "description appears below its image as plain text. Empty descriptions "
+            "are allowed. All files are validated before any images are attached. "
+            "mime_type, if supplied, must match the decoded image format."
+        )
+
+    async def check_permissions(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> PermissionResult:
+        return PermissionResult(behavior=PermissionBehavior.ALLOW)
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        result = await run_file_tool(self.name, tool_input, context)
+        context.emitted_images.extend(result.images)
+        return result
+
+    async def _call_local(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        raw_paths = tool_input.get("path", tool_input.get("file_path", ""))
+        if raw_paths == "":
+            raw_paths = tool_input.get("file_path", "")
+        paths = [raw_paths] if isinstance(raw_paths, str) else raw_paths
+        if not isinstance(paths, list) or not paths:
+            return ToolResult(result_for_model="Error: path must be a string or a non-empty list of strings", is_error=True)
+        if any(not isinstance(path, str) or not path.strip() for path in paths):
+            return ToolResult(result_for_model="Error: every path must be a non-empty string", is_error=True)
+
+        descriptions = tool_input.get("description", [""] * len(paths))
+        if isinstance(descriptions, str):
+            descriptions = [descriptions]
+        if (
+            not isinstance(descriptions, list)
+            or len(descriptions) != len(paths)
+            or any(not isinstance(description, str) for description in descriptions)
+        ):
+            return ToolResult(
+                result_for_model="Error: description must be a string for one image or a list of strings matching the paths in length and order",
+                is_error=True,
+            )
+
+        # Stage attachments so a later invalid file cannot leave a partial batch
+        # in the invocation sink, which the tool runner merges even on errors.
+        staged = replace(context, emitted_images=[])
+        details = []
+        messages = []
+        for raw_path, description in zip(paths, descriptions):
+            result = self._attach_one(raw_path.strip(), description, tool_input, staged)
+            if result.is_error:
+                return result
+            details.append(result.data)
+            messages.append(result.result_for_model)
+        context.emitted_images.extend(staged.emitted_images)
+        message = "\n".join(messages)
+        return ToolResult(
+            data=details[0] if isinstance(raw_paths, str) else {"images": details},
+            result_for_model=message,
+            result_for_display=message,
+            images=staged.emitted_images,
+        )
+
+    def _attach_one(
+        self, raw_path: str, description: str, tool_input: dict[str, Any], context: ToolContext,
+    ) -> ToolResult:
+        if not raw_path:
+            return ToolResult(result_for_model="Error: path is required", is_error=True)
+
+        path = Path(raw_path).expanduser()
+        if not path.is_absolute():
+            path = Path(context.cwd) / path
+        try:
+            path = path.resolve()
+        except OSError:
+            # Keep the original path for a useful error if resolution fails.
+            pass
+
+        if not path.exists():
+            return ToolResult(result_for_model=f"Error: image not found: {path}", is_error=True)
+        if not path.is_file():
+            return ToolResult(result_for_model=f"Error: not a file: {path}", is_error=True)
+
+        mime_type = str(
+            tool_input.get("mime_type", "")
+            or tool_input.get("mimeType", "")
+            or ""
+        ).strip()
+        try:
+            from crabcode_core.image_io import load_image_preview
+
+            preview = load_image_preview(path)
+            if mime_type and mime_type.lower() != preview.media_type:
+                raise ValueError(f"mime_type must match the image content ({preview.media_type})")
+            data, mime_type = preview.data, preview.media_type
+            context.emit_image(data, mime_type, description=description)
+        except (OSError, TypeError, ValueError) as exc:
+            return ToolResult(result_for_model=f"Error attaching image {path}: {exc}", is_error=True)
+
+        message = f"Image attached: {path} ({preview.summary()})"
+        if description:
+            message += f"\nDescription: {description}"
+        return ToolResult(
+            data={"path": str(path), "media_type": mime_type, "bytes": len(data), **({"description": description} if description else {})},
+            result_for_model=message,
+            result_for_display=message,
+            images=[context.emitted_images[-1]],
+        )

crabcode_core/tools/image_generate.py

@@ -0,0 +1,115 @@
+"""Generate images with the active Codex provider and return inline artifacts."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import mimetypes
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+import httpx
+
+from crabcode_core.types.tool import MAX_INLINE_IMAGE_BYTES, Tool, ToolContext, ToolResult
+
+
+class ImageGenerateTool(Tool):
+    name = "ImageGenerate"
+    description = (
+        "Generate or edit a raster image using the current Codex auth.json login "
+        "or an explicitly enabled compatible Responses provider. Uses the active "
+        "provider's configured credentials. Describe the subject, style, composition, "
+        "exact text and constraints in prompt. For edits or visual references, pass "
+        "reference_image_paths after inspecting those images with Image. State each "
+        "reference's role and what must remain unchanged in prompt. Saves unique files "
+        "under output/imagegen in the current workspace and attaches images inline. "
+        "Use once per asset; generation may take several minutes. Only use when the "
+        "user requests image generation or the task needs a generated image."
+    )
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "prompt": {"type": "string", "minLength": 1},
+            "reference_image_paths": {
+                "type": "array", "maxItems": 5,
+                "items": {"type": "string", "minLength": 1},
+                "description": "Optional local images for editing or visual reference, relative to the workspace or absolute.",
+            },
+        },
+        "required": ["prompt"],
+        "additionalProperties": False,
+    }
+
+    def is_available(self, context: ToolContext) -> bool:
+        return self.is_enabled and bool(getattr(context.api_adapter, "supports_image_generation", False))
+
+    async def call(self, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        if not self.is_available(context):
+            return ToolResult(
+                is_error=True,
+                result_for_model=(
+                    "ImageGenerate requires Codex auth.json mode or "
+                    "image_generation_enabled=true on a compatible Codex model."
+                ),
+            )
+        prompt = tool_input.get("prompt")
+        if not isinstance(prompt, str) or not prompt.strip():
+            return ToolResult(is_error=True, result_for_model="Error: prompt is required")
+        paths = tool_input.get("reference_image_paths", [])
+        if not isinstance(paths, list) or len(paths) > 5 or any(not isinstance(p, str) or not p.strip() for p in paths):
+            return ToolResult(is_error=True, result_for_model="Error: provide at most five reference image paths")
+
+        try:
+            references = []
+            for raw_path in paths:
+                path = Path(raw_path).expanduser()
+                if not path.is_absolute():
+                    path = Path(context.cwd) / path
+                media_type = mimetypes.guess_type(path.name)[0]
+                if media_type not in {"image/png", "image/jpeg", "image/webp", "image/gif"}:
+                    raise ValueError(f"Unsupported reference image type: {path}")
+                if path.stat().st_size > MAX_INLINE_IMAGE_BYTES:
+                    raise ValueError("Reference image exceeds the 20MB limit")
+                raw = path.read_bytes()
+                if not raw or len(raw) > MAX_INLINE_IMAGE_BYTES:
+                    raise ValueError("Reference image is empty or exceeds the 20MB limit")
+                references.append({"media_type": media_type, "data": base64.b64encode(raw).decode("ascii")})
+
+            images = await context.api_adapter.generate_images(
+                prompt.strip(), model=context.model or context.api_adapter.config.model,
+                reference_images=references,
+            )
+            # Validate all results before saving or publishing any image.
+            decoded = []
+            for image in images:
+                encoded = image["data"]
+                if len(encoded) > 4 * ((MAX_INLINE_IMAGE_BYTES + 2) // 3):
+                    raise ValueError("Generated image exceeds the 20MB limit")
+                raw = base64.b64decode(encoded, validate=True)
+                if not raw or len(raw) > MAX_INLINE_IMAGE_BYTES:
+                    raise ValueError("Generated image is empty or exceeds the 20MB limit")
+                suffix = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp"}.get(image["media_type"])
+                if not suffix:
+                    raise ValueError("Unsupported generated image MIME type")
+                decoded.append((raw, image["media_type"], suffix))
+            if not decoded:
+                raise ValueError("The provider returned no generated image")
+
+            output_dir = Path(context.cwd).resolve() / "output" / "imagegen"
+            output_dir.mkdir(parents=True, exist_ok=True)
+            saved = []
+            for raw, media_type, suffix in decoded:
+                path = output_dir / f"image-{uuid4().hex}{suffix}"
+                with path.open("xb") as file:
+                    file.write(raw)
+                saved.append(str(path))
+                context.emit_image(raw, media_type)
+            message = "Generated image(s):\n" + "\n".join(saved)
+            return ToolResult(
+                data={"paths": saved}, result_for_model=message,
+                result_for_display=message, images=context.emitted_images[-len(saved):],
+            )
+        except (OSError, ValueError, binascii.Error, RuntimeError, httpx.HTTPError) as exc:
+            return ToolResult(is_error=True, result_for_model=f"Image generation failed: {exc}")

crabcode_core/tools/lint.py

@@ -0,0 +1,388 @@
+"""LintTool — read linter errors and diagnostics for specified files."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+from pathlib import Path
+from typing import Any
+
+from crabcode_core.logging_utils import get_logger
+from crabcode_core.subprocess_utils import (
+    decode_subprocess_output,
+    managed_process_command,
+    resolve_executable_command,
+    subprocess_group_options,
+    terminate_process_tree,
+)
+from crabcode_core.types.tool import Tool, ToolContext, ToolResult
+
+logger = get_logger(__name__)
+
+_LINTER_CONFIGS: list[dict[str, Any]] = [
+    # ── Python ──
+    {
+        "name": "ruff",
+        "extensions": {".py", ".pyi"},
+        "cmd": ["ruff", "check", "--output-format=concise"],
+        "detect_files": {"ruff.toml", ".ruff.toml"},
+        "detect_sections": {"ruff"},
+    },
+    {
+        "name": "pylint",
+        "extensions": {".py"},
+        "cmd": ["pylint", "--output-format=text", "--score=no"],
+        "detect_files": {".pylintrc", "pylintrc"},
+        "detect_sections": {"pylint"},
+    },
+    {
+        "name": "mypy",
+        "extensions": {".py", ".pyi"},
+        "cmd": ["mypy", "--no-error-summary", "--no-pretty", "--show-column-numbers"],
+        "detect_files": {"mypy.ini", ".mypy.ini"},
+        "detect_sections": {"mypy"},
+    },
+    # ── JavaScript / TypeScript ──
+    {
+        "name": "eslint",
+        "extensions": {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"},
+        "cmd": ["eslint", "--format=unix", "--no-color"],
+        "detect_files": {
+            ".eslintrc", ".eslintrc.js", ".eslintrc.cjs", ".eslintrc.json",
+            ".eslintrc.yml", ".eslintrc.yaml", "eslint.config.js",
+            "eslint.config.mjs", "eslint.config.cjs", "eslint.config.ts",
+        },
+        "detect_sections": set(),
+    },
+    # ── Go ──
+    {
+        "name": "golangci-lint",
+        "extensions": {".go"},
+        "cmd": ["golangci-lint", "run", "--out-format=line-number"],
+        "detect_files": {".golangci.yml", ".golangci.yaml", ".golangci.toml"},
+        "detect_sections": set(),
+    },
+    # ── Rust ──
+    {
+        "name": "clippy",
+        "extensions": {".rs"},
+        "cmd": ["cargo", "clippy", "--quiet", "--message-format=short"],
+        "detect_files": {"Cargo.toml"},
+        "detect_sections": set(),
+        "project_level": True,
+        "use_stderr": True,
+    },
+    # ── C / C++ ──
+    {
+        "name": "clang-tidy",
+        "extensions": {".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx"},
+        "cmd": ["clang-tidy"],
+        "detect_files": {".clang-tidy", "compile_commands.json"},
+        "detect_sections": set(),
+        "suffix_args": ["--"],
+    },
+    {
+        "name": "cppcheck",
+        "extensions": {".c", ".cpp", ".cc", ".cxx", ".h", ".hpp", ".hxx"},
+        "cmd": ["cppcheck", "--enable=warning,style,performance", "--template=gcc", "--quiet"],
+        "detect_files": set(),
+        "detect_sections": set(),
+    },
+    # ── Java ──
+    {
+        "name": "checkstyle",
+        "extensions": {".java"},
+        "cmd": ["checkstyle"],
+        "detect_files": {"checkstyle.xml", ".checkstyle", "checkstyle-config.xml"},
+        "detect_sections": set(),
+    },
+    {
+        "name": "pmd",
+        "extensions": {".java"},
+        "cmd": ["pmd", "check", "-f", "text", "--no-progress", "-R",
+                "rulesets/java/quickstart.xml"],
+        "detect_files": {"ruleset.xml", "pmd-ruleset.xml"},
+        "detect_sections": set(),
+        "target_flag": "-d",
+    },
+]
+
+
+def _has_pyproject_section(cwd: str, section_names: set[str]) -> bool:
+    """Check if pyproject.toml has a [tool.<name>] section."""
+    if not section_names:
+        return False
+    pyproject = Path(cwd) / "pyproject.toml"
+    if not pyproject.exists():
+        return False
+    try:
+        text = pyproject.read_text(encoding="utf-8", errors="replace")
+        return any(f"[tool.{s}]" in text for s in section_names)
+    except Exception:
+        logger.debug("Failed to read %s while detecting lint config", pyproject, exc_info=True)
+        return False
+
+
+def _has_config_file(cwd: str, filenames: set[str]) -> bool:
+    """Check if any of the given config files exist in cwd."""
+    for name in filenames:
+        if (Path(cwd) / name).exists():
+            return True
+    return False
+
+
+def _detect_linters(
+    paths: list[Path], cwd: str
+) -> list[dict[str, Any]]:
+    """Pick applicable linters based on file extensions and project config.
+
+    When no paths are given, scans for project config files to decide which
+    linters apply instead of guessing by extension.
+    """
+    extensions = {p.suffix for p in paths if p.suffix}
+    no_paths = not paths
+
+    matched: list[dict[str, Any]] = []
+    seen_names: set[str] = set()
+    for cfg in _LINTER_CONFIGS:
+        if cfg["name"] in seen_names:
+            continue
+        if not shutil.which(cfg["cmd"][0]):
+            continue
+
+        has_config = (
+            _has_config_file(cwd, cfg["detect_files"])
+            or _has_pyproject_section(cwd, cfg["detect_sections"])
+        )
+
+        if no_paths:
+            if not has_config:
+                continue
+        else:
+            if not extensions & cfg["extensions"]:
+                continue
+
+        matched.append({**cfg, "has_config": has_config})
+        seen_names.add(cfg["name"])
+
+    if not matched:
+        return []
+
+    configured = [m for m in matched if m["has_config"]]
+    if configured:
+        return configured
+    return matched[:1]
+
+
+async def _run_linter(
+    cfg: dict[str, Any],
+    targets: list[str],
+    cwd: str,
+    timeout: int = 60,
+) -> tuple[str, str, int]:
+    """Run a linter command and return (output, stderr, exit_code).
+
+    Respects per-linter config flags:
+      project_level  – don't append file targets
+      use_stderr     – read diagnostics from stderr instead of stdout
+      suffix_args    – extra args appended after targets (e.g. ["--"] for clang-tidy)
+      target_flag    – flag before each target (e.g. "-d" for pmd)
+    """
+    cmd = cfg["cmd"]
+    is_project_level = cfg.get("project_level", False)
+    target_flag = cfg.get("target_flag")
+    suffix_args = cfg.get("suffix_args", [])
+
+    full_cmd = list(cmd)
+    if not is_project_level:
+        if target_flag:
+            full_cmd.extend([target_flag, ",".join(targets)])
+        else:
+            full_cmd.extend(targets)
+        full_cmd.extend(suffix_args)
+
+    proc: asyncio.subprocess.Process | None = None
+    try:
+        full_cmd = resolve_executable_command(full_cmd, cwd=cwd)
+        proc = await asyncio.create_subprocess_exec(
+            *managed_process_command(full_cmd),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd,
+            **subprocess_group_options(),
+        )
+        stdout_bytes, stderr_bytes = await asyncio.wait_for(
+            proc.communicate(), timeout=timeout
+        )
+        stdout = decode_subprocess_output(stdout_bytes)
+        stderr = decode_subprocess_output(stderr_bytes)
+
+        if cfg.get("use_stderr"):
+            return stderr, stdout, proc.returncode or 0
+        return stdout, stderr, proc.returncode or 0
+    except asyncio.TimeoutError:
+        if proc is not None and proc.returncode is None:
+            await terminate_process_tree(proc)
+        return "", f"Linter timed out after {timeout}s", -1
+    except asyncio.CancelledError:
+        if proc is not None and proc.returncode is None:
+            await terminate_process_tree(proc)
+        raise
+    except FileNotFoundError:
+        return "", f"Linter command not found: {cmd[0]}", -1
+    except ValueError as exc:
+        return "", str(exc), -1
+
+
+class LintTool(Tool):
+    name = "Lint"
+    description = "Read linter errors and diagnostics for specified files."
+    is_read_only = True
+    is_concurrency_safe = True
+    input_schema = {
+        "type": "object",
+        "properties": {
+            "paths": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": (
+                    "File or directory paths to check. "
+                    "If omitted, checks the current working directory."
+                ),
+            },
+            "linter": {
+                "type": "string",
+                "description": (
+                    "Force a specific linter (e.g., 'ruff', 'eslint', 'mypy'). "
+                    "If omitted, auto-detects based on file types and project config."
+                ),
+            },
+        },
+    }
+
+    async def get_prompt(self, **kwargs: Any) -> str:
+        return (
+            "Read linter errors and diagnostics for specified files or directories. "
+            "Auto-detects the appropriate linter based on file types and project "
+            "configuration.\n\n"
+            "Supported linters:\n"
+            "- Python: ruff, pylint, mypy\n"
+            "- JavaScript/TypeScript: eslint\n"
+            "- Go: golangci-lint\n"
+            "- Rust: clippy (via cargo)\n"
+            "- C/C++: clang-tidy, cppcheck\n"
+            "- Java: checkstyle, pmd\n\n"
+            "Use this tool after making edits to verify you haven't introduced "
+            "errors. You can provide specific file paths or omit them to check "
+            "the whole project.\n\n"
+            "Guidelines:\n"
+            "- Only use on files you've edited or are about to edit.\n"
+            "- Results may include pre-existing errors — focus on errors in "
+            "code you changed.\n"
+            "- If no linter is installed or configured, the tool will report "
+            "that clearly.\n"
+            "- For Rust projects, clippy runs at the project level (ignores "
+            "individual file paths)."
+        )
+
+    async def call(
+        self,
+        tool_input: dict[str, Any],
+        context: ToolContext,
+    ) -> ToolResult:
+        raw_paths = tool_input.get("paths") or []
+        forced_linter = tool_input.get("linter")
+
+        cwd = context.cwd
+
+        resolved: list[Path] = []
+        for p in raw_paths:
+            path = Path(p)
+            if not path.is_absolute():
+                path = Path(cwd) / path
+            resolved.append(path)
+
+        missing = [str(p) for p in resolved if not p.exists()]
+        if missing:
+            return ToolResult(
+                result_for_model=f"Error: paths not found: {', '.join(missing)}",
+                is_error=True,
+            )
+
+        if forced_linter:
+            cfg = next(
+                (c for c in _LINTER_CONFIGS if c["name"] == forced_linter), None
+            )
+            if cfg is None:
+                known = ", ".join(c["name"] for c in _LINTER_CONFIGS)
+                return ToolResult(
+                    result_for_model=(
+                        f"Unknown linter '{forced_linter}'. "
+                        f"Supported: {known}"
+                    ),
+                    is_error=True,
+                )
+            if not shutil.which(cfg["cmd"][0]):
+                return ToolResult(
+                    result_for_model=(
+                        f"Linter '{forced_linter}' is not installed. "
+                        f"Install it and try again."
+                    ),
+                    is_error=True,
+                )
+            linters = [cfg]
+        else:
+            linters = _detect_linters(resolved, cwd)
+            if not linters:
+                return ToolResult(
+                    result_for_model=(
+                        "No suitable linter found. Either no linter is installed "
+                        "for the given file types, or no matching files were provided.\n"
+                        "Supported: ruff, pylint, mypy, eslint, golangci-lint, clippy, "
+                        "clang-tidy, cppcheck, checkstyle, pmd."
+                    ),
+                )
+
+        targets = [str(p) for p in resolved] if resolved else ["."]
+
+        all_output: list[str] = []
+        total_issues = 0
+
+        for linter_cfg in linters:
+            linter_name = linter_cfg["name"]
+            stdout, stderr, exit_code = await _run_linter(
+                linter_cfg, targets, cwd
+            )
+
+            if exit_code == -1:
+                all_output.append(f"[{linter_name}] Error: {stderr}")
+                continue
+
+            output = stdout.strip()
+            if not output and exit_code == 0:
+                all_output.append(f"[{linter_name}] No issues found.")
+                continue
+
+            lines = output.split("\n") if output else []
+            issue_count = len([
+                l for l in lines
+                if l.strip() and not l.startswith((" ", "\t"))
+            ])
+            total_issues += issue_count
+
+            max_chars = 50_000
+            if len(output) > max_chars:
+                output = output[:max_chars] + "\n... (truncated)"
+
+            header = f"[{linter_name}] {issue_count} issue(s):"
+            all_output.append(f"{header}\n{output}")
+
+            if stderr.strip() and exit_code != 0:
+                err_preview = stderr.strip()[:2000]
+                all_output.append(f"[{linter_name}] stderr:\n{err_preview}")
+
+        result_text = "\n\n".join(all_output)
+        return ToolResult(
+            data={"total_issues": total_issues},
+            result_for_model=result_text,
+        )