kivi-cli 2.0.6__py3-none-any.whl

kiviai/services/tools/copilot_tools/code_search/tools.py

@@ -0,0 +1,137 @@
+"""
+Code search primitives: grep (ripgrep wrapper) and glob_search.
+
+Both are designed for speed-first, low-overhead discovery inside a repository.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Enums
+# ---------------------------------------------------------------------------
+
+class OutputMode(str, Enum):
+    FILES_WITH_MATCHES = "files_with_matches"
+    CONTENT = "content"
+    COUNT = "count"
+
+
+# ---------------------------------------------------------------------------
+# grep — ripgrep wrapper
+# ---------------------------------------------------------------------------
+
+def grep(
+    pattern: str,
+    *,
+    path: Optional[str] = None,
+    output_mode: str = "files_with_matches",
+    glob_filter: Optional[str] = None,
+    file_type: Optional[str] = None,
+    case_insensitive: bool = False,
+    line_numbers: bool = False,
+    after_context: Optional[int] = None,
+    before_context: Optional[int] = None,
+    context: Optional[int] = None,
+    multiline: bool = False,
+    head_limit: Optional[int] = None,
+) -> str:
+    """Fast code search using **ripgrep** (``rg``).
+
+    Parameters
+    ----------
+    pattern:
+        Regex pattern to search for.
+    path:
+        File or directory to search.  Defaults to cwd.
+    output_mode:
+        ``"files_with_matches"`` | ``"content"`` | ``"count"``.
+    glob_filter:
+        Glob to filter files (e.g. ``"*.py"``).
+    file_type:
+        Ripgrep type filter (e.g. ``"py"``, ``"js"``).
+    case_insensitive:
+        Enable ``-i`` flag.
+    line_numbers:
+        Show line numbers (requires ``output_mode="content"``).
+    after_context / before_context / context:
+        Context lines around matches (requires ``output_mode="content"``).
+    multiline:
+        Allow patterns that span multiple lines.
+    head_limit:
+        Max number of results.
+
+    Returns
+    -------
+    Ripgrep output as a string.
+    """
+    mode = OutputMode(output_mode)
+    search_path = Path(path) if path else Path.cwd()
+
+    args: list[str] = ["rg"]
+
+    # Output mode flags
+    if mode == OutputMode.FILES_WITH_MATCHES:
+        args.append("--files-with-matches")
+    elif mode == OutputMode.COUNT:
+        args.append("--count")
+    # content mode uses default rg output
+
+    # Optional flags
+    if glob_filter:
+        args.extend(["--glob", glob_filter])
+    if file_type:
+        args.extend(["--type", file_type])
+    if case_insensitive:
+        args.append("--ignore-case")
+    if line_numbers and mode == OutputMode.CONTENT:
+        args.append("--line-number")
+    if after_context is not None and mode == OutputMode.CONTENT:
+        args.extend(["--after-context", str(after_context)])
+    if before_context is not None and mode == OutputMode.CONTENT:
+        args.extend(["--before-context", str(before_context)])
+    if context is not None and mode == OutputMode.CONTENT:
+        args.extend(["--context", str(context)])
+    if multiline:
+        args.append("--multiline")
+    if head_limit is not None:
+        args.extend(["--max-count", str(head_limit)])
+
+    # Pattern + path
+    args.append(pattern)
+    args.append(str(search_path))
+
+    result = subprocess.run(args, capture_output=True, text=True)
+    return result.stdout
+
+
+# ---------------------------------------------------------------------------
+# glob_search — file pattern matching
+# ---------------------------------------------------------------------------
+
+def glob_search(
+    pattern: str,
+    *,
+    path: Optional[str] = None,
+) -> list[str]:
+    """Find files by glob pattern.
+
+    Parameters
+    ----------
+    pattern:
+        Glob pattern (e.g. ``"**/*.py"``, ``"src/**/*.ts"``).
+    path:
+        Base directory.  Defaults to cwd.
+
+    Returns
+    -------
+    List of matching absolute file paths.
+    """
+    base = Path(path) if path else Path.cwd()
+    matches = sorted(base.glob(pattern))
+    return [str(m.resolve()) for m in matches if not any(p.startswith(".") for p in m.parts)]

kiviai/services/tools/copilot_tools/file_operations/__init__.py

@@ -0,0 +1,12 @@
+"""
+File Operation Tools — the triad of ``view``, ``create``, and ``edit``.
+
+Safety-first file I/O:
+    view   — Read files, directories, or images (read-only)
+    create — Write a new file (write-once, refuses if exists)
+    edit   — Surgical single-occurrence string replacement (write-many)
+"""
+
+from copilot_tools.file_operations.tools import view, create, edit
+
+__all__ = ["view", "create", "edit"]

kiviai/services/tools/copilot_tools/file_operations/tools.py

@@ -0,0 +1,197 @@
+"""
+Filesystem primitives: view, create, edit.
+
+All paths must be absolute (enforced via ``pathlib.Path``).
+"""
+
+from __future__ import annotations
+
+import base64
+import mimetypes
+from pathlib import Path
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+MAX_FILE_SIZE = 50 * 1024  # 50 KB
+IMAGE_EXTENSIONS = {
+    ".png", ".jpg", ".jpeg", ".gif", ".svg",
+    ".webp", ".bmp", ".ico", ".tiff", ".tif",
+}
+DIR_LIST_DEPTH = 2
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _ensure_absolute(path: Path) -> None:
+    if not path.is_absolute():
+        raise ValueError(f"Path MUST be absolute, got: {path}")
+
+
+def _add_line_numbers(content: str) -> str:
+    lines = content.splitlines(keepends=True)
+    numbered = []
+    for i, line in enumerate(lines, start=1):
+        numbered.append(f"{i}. {line.rstrip()}")
+    return "\n".join(numbered)
+
+
+def _list_directory(path: Path, *, depth: int = DIR_LIST_DEPTH, _current: int = 0) -> str:
+    """Recursively list non-hidden entries up to *depth* levels."""
+    entries: list[str] = []
+    indent = "  " * _current
+
+    try:
+        children = sorted(path.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+    except PermissionError:
+        return f"{indent}{path.name}/ [permission denied]"
+
+    for child in children:
+        if child.name.startswith("."):
+            continue
+        if child.is_dir():
+            entries.append(f"{indent}{child.name}/")
+            if _current < depth - 1:
+                entries.append(_list_directory(child, depth=depth, _current=_current + 1))
+        else:
+            entries.append(f"{indent}{child.name}")
+
+    return "\n".join(entries)
+
+
+def _is_image(path: Path) -> bool:
+    return path.suffix.lower() in IMAGE_EXTENSIONS
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def view(
+    path: str,
+    *,
+    view_range: Optional[tuple[int, int]] = None,
+    force_read_large_files: bool = False,
+) -> str | dict:
+    """View a file, directory, or image.
+
+    Parameters
+    ----------
+    path:
+        Absolute path to file or directory.  Must exist.
+    view_range:
+        ``(start, end)`` — 1-indexed line range.  ``end=-1`` means EOF.
+    force_read_large_files:
+        Skip the 50 KB truncation guard.
+
+    Returns
+    -------
+    * **str** with line-numbered content for regular files.
+    * **dict** ``{"base64": ..., "mimeType": ...}`` for images.
+    * **str** directory listing for directories.
+    """
+    p = Path(path)
+    _ensure_absolute(p)
+
+    if not p.exists():
+        raise FileNotFoundError(f"File MUST exist to view: {p}")
+
+    # --- Directory ---
+    if p.is_dir():
+        return _list_directory(p)
+
+    # --- Image ---
+    if _is_image(p):
+        data = p.read_bytes()
+        mime = mimetypes.guess_type(str(p))[0] or "application/octet-stream"
+        return {"base64": base64.b64encode(data).decode(), "mimeType": mime}
+
+    # --- Regular file ---
+    size = p.stat().st_size
+    if size > MAX_FILE_SIZE and not force_read_large_files:
+        content = p.read_text(errors="replace")[:MAX_FILE_SIZE]
+        return (
+            _add_line_numbers(content)
+            + "\n[File truncated at 50KB. Use view_range to read specific sections.]"
+        )
+
+    content = p.read_text(errors="replace")
+
+    if view_range is not None:
+        start, end = view_range
+        lines = content.splitlines()
+        if end == -1:
+            end = len(lines)
+        content = "\n".join(lines[start - 1 : end])
+
+    return _add_line_numbers(content)
+
+
+def create(path: str, file_text: str) -> dict:
+    """Create a new file.  Refuses if the file already exists.
+
+    Parameters
+    ----------
+    path:
+        Absolute path.  File MUST NOT exist.
+    file_text:
+        Complete content to write.
+    """
+    p = Path(path)
+    _ensure_absolute(p)
+
+    if p.exists():
+        raise FileExistsError(
+            f"File already exists at {p}. Cannot overwrite. Use edit() for existing files."
+        )
+
+    if not p.parent.exists():
+        raise FileNotFoundError(
+            f"Parent directory does not exist: {p.parent}. Create it first."
+        )
+
+    p.write_text(file_text)
+    return {"success": True, "path": str(p), "bytes_written": len(file_text)}
+
+
+def edit(path: str, old_str: str, new_str: str) -> dict:
+    """Replace exactly one occurrence of *old_str* with *new_str*.
+
+    Parameters
+    ----------
+    path:
+        Absolute path.  File MUST exist.
+    old_str:
+        Exact text to find (must appear exactly once).
+    new_str:
+        Replacement text.
+    """
+    p = Path(path)
+    _ensure_absolute(p)
+
+    if not p.exists():
+        raise FileNotFoundError(
+            f"File MUST exist to edit: {p}. Use create() for new files."
+        )
+
+    content = p.read_text(errors="replace")
+    occurrences = content.count(old_str)
+
+    if occurrences == 0:
+        raise ValueError(
+            f"old_str not found in {p}. "
+            "Ensure the string matches exactly, including whitespace."
+        )
+    if occurrences > 1:
+        raise ValueError(
+            f"old_str appears {occurrences} times in {p}. "
+            "Not unique — include more surrounding context."
+        )
+
+    new_content = content.replace(old_str, new_str, 1)
+    p.write_text(new_content)
+    return {"success": True, "path": str(p)}

kiviai/services/tools/copilot_tools/markdown/__init__.py

@@ -0,0 +1,41 @@
+"""
+Markdown Analysis Tools — structured extraction from markdown documents.
+
+    get_overview        — Full eagle-eye overview (stats, structure, intro)
+    get_headers         — Extract all headers with line numbers
+    get_section         — Extract section content under a specific header
+    get_intro           — Extract introduction/abstract/summary
+    get_links           — Extract HTTP/HTTPS links
+    get_tables_metadata — Table metadata (headers, line numbers, column counts)
+    get_table           — Extract and format a specific table by line number
+"""
+
+from .tools import (
+    markdown_analyzer_get_headers as get_headers,
+    markdown_analyzer_get_header_by_line as get_section,
+    markdown_analyzer_get_intro as get_intro,
+    markdown_analyzer_get_overview as get_overview,
+    markdown_analyzer_get_links as get_links,
+    markdown_analyzer_get_table_by_line as get_table,
+    markdown_analyzer_get_tables_metadata as get_tables_metadata,
+)
+
+__all__ = [
+    "get_overview",
+    "get_headers",
+    "get_section",
+    "get_intro",
+    "get_links",
+    "get_tables_metadata",
+    "get_table",
+]
+
+tools = {
+    "markdown_get_overview": get_overview,
+    "markdown_get_headers": get_headers,
+    "markdown_get_section": get_section,
+    "markdown_get_intro": get_intro,
+    "markdown_get_links": get_links,
+    "markdown_get_tables_metadata": get_tables_metadata,
+    "markdown_get_table": get_table,
+}