mosscode 0.1.0__py3-none-any.whl

mosscode/tools/search.py

@@ -0,0 +1,229 @@
+import json
+import shutil
+import sys
+from pathlib import Path
+from typing import Literal
+
+from pydantic import Field
+
+from .base import Params, Tool, ToolFailure
+from .process import run_process
+
+SKIP_DIRS = (".git", ".venv", "venv", "node_modules", "__pycache__")
+WORKTREES = (".mosscode", "worktrees")  # Skipped unless the search starts inside one.
+GLOB_LIMIT = 200
+
+
+class GlobParams(Params):
+    pattern: str = Field(min_length=1)
+    path: str = "."
+
+
+class GrepParams(Params):
+    pattern: str
+    path: str = "."
+    glob: str | None = None
+    output_mode: Literal["files_with_matches", "content", "count"] = "files_with_matches"
+    ignore_case: bool = False
+    context: int = Field(default=0, ge=0, le=10)
+    head_limit: int = Field(default=200, ge=1, le=2000)
+
+
+def rg_command():
+    executable = shutil.which("rg")
+    if executable is None:
+        raise ToolFailure("search_unavailable", "搜索工具需要 ripgrep（rg），请安装并加入 PATH。")
+    # .gitignore applies even outside a git repository, matching the fallback.
+    return [executable, "--hidden", "--no-require-git"]
+
+
+def fallback_command(mode, arguments):
+    return [sys.executable, "-m", "mosscode.tools.search_worker", mode, json.dumps(arguments, ensure_ascii=False)]
+
+
+def stderr_hint(stderr: str) -> str:
+    text = stderr.strip()[:500]
+    return f"\n{text}" if text else ""
+
+
+def inside_worktrees(path: Path) -> bool:
+    parts = path.parts
+    return any(parts[i : i + 2] == WORKTREES for i in range(len(parts) - 1))
+
+
+def skip_globs(path: Path | None = None):
+    # Later rg globs override earlier ones, so exclusions follow user filters.
+    globs = [arg for name in SKIP_DIRS for arg in ("-g", f"!**/{name}/**")]
+    if path is None or not inside_worktrees(path):
+        globs.extend(("-g", "!**/.mosscode/worktrees/**"))
+    return globs
+
+
+def newest_first(paths):
+    def mtime(path):
+        try:
+            return path.stat().st_mtime_ns
+        except OSError:
+            return 0
+
+    return sorted(paths, key=lambda path: (-mtime(path), str(path)))
+
+
+class SearchTool(Tool):
+    read_only = True
+
+    def base(self, path: Path) -> str | None:
+        # The fallback reads .gitignore files from the project root down to `path`.
+        return str(self.root) if path.is_relative_to(self.root) else None
+
+
+class Glob(SearchTool):
+    name = "glob"
+    description = (
+        f"按 glob 模式查找文件，例如 **/*.py，支持花括号多选如 *.{{py,md}}、{{src,docs}}/**/*，可指定搜索目录 path。遵守 .gitignore，并跳过 .git、.venv、node_modules "
+        f"和缓存目录（以及 .mosscode/worktrees，除非 path 指向其中）；结果按修改时间从新到旧排列，最多 {GLOB_LIMIT} 项。项目目录之外的路径需要用户确认。"
+    )
+    prompt_summary = "按文件名或路径模式定位文件"
+    prompt_guidelines = (
+        "按文件名或路径找文件时优先 glob；pattern 是路径模式，不是内容正则。根据已知目录缩小范围，结果截断时细化模式。",
+    )
+    params_model = GlobParams
+
+    async def execute(self, params: GlobParams):
+        path = self.read_path(params.path)
+        if not path.is_dir():
+            raise ToolFailure("invalid_path", "glob 的 path 必须是存在的目录。")
+        if shutil.which("rg"):
+            args = [*rg_command(), "--files", "-g", params.pattern, *skip_globs(path), "--", "."]
+        else:
+            args = fallback_command("glob", {"pattern": params.pattern, "path": str(path), "base": self.base(path)})
+        details = await run_process(args, path, check=False, limit=262144)
+        if details["exit_code"] not in (0, 1):
+            raise ToolFailure(
+                "search_failed", "文件搜索失败。" + stderr_hint(details["stderr"]), stderr=details["stderr"]
+            )
+        lines = details["stdout"].splitlines()
+        if details["truncated"] and lines:
+            lines.pop()  # The last path may be only a captured prefix.
+        files = newest_first(found for line in lines if (found := self.read_path(str(path / line))).is_file())
+        truncated = details["truncated"] or len(files) > GLOB_LIMIT
+        shown = [self.display(item) for item in files[:GLOB_LIMIT]]
+        if not shown:
+            return "没有匹配文件。", {"count": 0, "truncated": False}
+        note = (
+            f"\n（共 {len(files)}{'+' if details['truncated'] else ''} 项，仅显示最新的 {GLOB_LIMIT} 项；请细化模式）"
+            if truncated
+            else ""
+        )
+        return "\n".join(shown) + note, {"count": len(shown), "truncated": truncated}
+
+
+class Grep(SearchTool):
+    name = "grep"
+    description = (
+        "用正则搜索文本内容。output_mode：files_with_matches（默认，只列文件，按修改时间从新到旧）、"
+        "content（路径:行号: 匹配行，context 指定前后各几行）、count（每个文件的匹配行数）。"
+        "path 指定范围，glob 限定文件，ignore_case 忽略大小写，head_limit 限制条数（默认 200）。"
+        "遵守 .gitignore；无匹配是成功。项目目录之外的路径需要用户确认。"
+    )
+    prompt_summary = "搜索代码内容，返回文件、匹配行或计数"
+    prompt_guidelines = (
+        "按内容定位代码时优先 grep；先用默认的 files_with_matches 找到相关文件，需要看匹配行时再用 output_mode=content，必要时加 context。使用 path 和 glob 限定范围，结果截断时细化搜索。",
+        "grep 的匹配行用于定位；修改前仍需读取相关原文和周边上下文。无匹配只说明当前范围和模式没有命中，必要时调整搜索。",
+    )
+    params_model = GrepParams
+
+    async def execute(self, params: GrepParams):
+        path = self.read_path(params.path)
+        if not path.exists():
+            raise FileNotFoundError()
+        counting = params.output_mode != "content"
+        if shutil.which("rg"):
+            args = rg_command()
+            if params.ignore_case:
+                args.append("-i")
+            args.extend(["--count", "--with-filename", "--null"] if counting else ["--json", "-C", str(params.context)])
+            if params.glob is not None:
+                args.extend(["-g", params.glob])
+            args.extend([*skip_globs(path), "-e", params.pattern, "--", str(path)])
+        else:
+            args = fallback_command(
+                "count" if counting else "grep",
+                {
+                    "pattern": params.pattern,
+                    "path": str(path),
+                    "base": self.base(path),
+                    "glob": params.glob,
+                    "ignore_case": params.ignore_case,
+                    "context": params.context,
+                },
+            )
+        details = await run_process(args, self.root, check=False, limit=262144)
+        if details["exit_code"] not in (0, 1):
+            raise ToolFailure(
+                "search_failed",
+                "搜索模式无效或目标无法访问。" + stderr_hint(details["stderr"]),
+                stderr=details["stderr"],
+            )
+        lines = details["stdout"].splitlines()
+        if details["truncated"] and lines:
+            lines.pop()
+        if counting:
+            counts = {}
+            for line in lines:
+                name, _, number = line.rpartition("\0")
+                if name and number.isdigit():
+                    counts[self.read_path(name)] = int(number)
+            files = newest_first(counts)
+            entries = (
+                [self.display(item) for item in files]
+                if params.output_mode == "files_with_matches"
+                else [f"{self.display(item)}:{counts[item]}" for item in files]
+            )
+            total_matches = sum(counts.values())
+            empty = "没有匹配内容。"
+            unit = "个文件"
+        else:
+            events = {}
+            for line in lines:
+                try:
+                    event = json.loads(line)
+                except ValueError:
+                    continue
+                if event.get("type") not in {"match", "context"}:
+                    continue
+                data = event["data"]
+                if "text" not in data["path"] or "text" not in data["lines"]:
+                    continue
+                name = self.display(self.read_path(data["path"]["text"]))
+                separator = ":" if event["type"] == "match" else "-"
+                events.setdefault(name, {})[data["line_number"]] = (
+                    f"{name}{separator}{data['line_number']}{separator} {data['lines']['text'].rstrip()}",
+                    event["type"] == "match",
+                )
+            entries, total_matches = [], 0
+            for name in sorted(events):
+                previous = None
+                for number in sorted(events[name]):
+                    text, matched = events[name][number]
+                    if params.context and previous is not None and number > previous + 1:
+                        entries.append("--")
+                    entries.append(text)
+                    total_matches += matched
+                    previous = number
+            empty = "没有匹配内容。"
+            unit = "行"
+        if not entries:
+            return empty, {"count": 0, "matches": 0, "truncated": False}
+        truncated = details["truncated"] or len(entries) > params.head_limit
+        shown = entries[: params.head_limit]
+        if truncated:
+            shown.append(
+                f"（共 {len(entries)}{'+' if details['truncated'] else ''} {unit}，仅显示前 {params.head_limit} {unit}；请缩小范围或调整 head_limit）"
+            )
+        return "\n".join(shown), {
+            "count": len(entries),
+            "matches": total_matches,
+            "truncated": truncated,
+            "output_mode": params.output_mode,
+        }

mosscode/tools/search_worker.py

@@ -0,0 +1,243 @@
+"""Standard-library fallback, isolated so regex/search can be timed out.
+
+Output mirrors the ripgrep invocations in search.py: relative paths for glob,
+`--json` match/context events for grep content, `path NUL count` for counts.
+"""
+
+import fnmatch
+import json
+import os
+import re
+import sys
+from collections import deque
+from pathlib import Path
+
+SKIP_DIRS = {".git", ".venv", "venv", "node_modules", "__pycache__"}
+FOLD = os.name == "nt"  # Git for Windows matches ignore patterns case-insensitively.
+
+
+def expand_braces(pattern):
+    """Expand `{a,b}` alternatives (nested too) like rg globs; unbalanced braces stay literal."""
+    depth, start = 0, None
+    for index, char in enumerate(pattern):
+        if char == "{":
+            if depth == 0:
+                start = index
+            depth += 1
+        elif char == "}" and depth:
+            depth -= 1
+            if depth:
+                continue
+            body, rest = pattern[start + 1 : index], pattern[index + 1 :]
+            alternatives, level, last = [], 0, 0
+            for position, inner in enumerate(body):
+                if inner == "{":
+                    level += 1
+                elif inner == "}":
+                    level -= 1
+                elif inner == "," and level == 0:
+                    alternatives.append(body[last:position])
+                    last = position + 1
+            if not alternatives:  # `{x}` has no alternatives: keep it, but expand inside and after it.
+                return [
+                    pattern[:start] + "{" + inner + "}" + tail
+                    for inner in expand_braces(body)
+                    for tail in expand_braces(rest)
+                ]
+            alternatives.append(body[last:])
+            return list(
+                dict.fromkeys(
+                    expanded
+                    for alternative in alternatives
+                    for expanded in expand_braces(pattern[:start] + alternative + rest)
+                )
+            )
+    if depth:  # The first '{' never closed: literal, but later braces may still pair up.
+        return [pattern[: start + 1] + tail for tail in expand_braces(pattern[start + 1 :])]
+    return [pattern]
+
+
+def matches(path, pattern):
+    # Glob '*' matches a single path segment; '**' spans zero or more.
+    parts = path.replace("\\", "/").split("/")
+    patterns = pattern.replace("\\", "/").split("/")
+
+    def match(index, position):
+        if position == len(patterns):
+            return index == len(parts)
+        if patterns[position] == "**":
+            return match(index, position + 1) or (index < len(parts) and match(index + 1, position))
+        return (
+            index < len(parts)
+            and fnmatch.fnmatchcase(parts[index], patterns[position])
+            and match(index + 1, position + 1)
+        )
+
+    return match(0, 0)
+
+
+class Ignore:
+    """The subset of .gitignore semantics that decides most real files:
+    comments, `!` negation, `/` anchoring, trailing-`/` directory patterns, `**`."""
+
+    def __init__(self, rules=()):
+        self.rules = tuple(rules)
+
+    def extend(self, directory: Path) -> "Ignore":
+        try:
+            text = (directory / ".gitignore").read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return self
+        rules = list(self.rules)
+        for line in text.splitlines():
+            line = line.rstrip()
+            if not line or line.startswith("#"):
+                continue
+            negate = line.startswith("!")
+            if negate:
+                line = line[1:]
+            if line.startswith("\\"):
+                line = line[1:]
+            dir_only = line.endswith("/")
+            line = line.rstrip("/")
+            anchored = "/" in line
+            line = line.lstrip("/")
+            if line:
+                rules.append((directory, line.casefold() if FOLD else line, negate, dir_only, anchored))
+        return Ignore(rules)
+
+    def ignored(self, path: Path, is_dir: bool) -> bool:
+        result = False
+        name = path.name.casefold() if FOLD else path.name
+        for base, pattern, negate, dir_only, anchored in self.rules:
+            if dir_only and not is_dir:
+                continue
+            if anchored:
+                try:
+                    relative = path.relative_to(base).as_posix()
+                except ValueError:
+                    continue
+                hit = matches(relative.casefold() if FOLD else relative, pattern)
+            else:
+                hit = fnmatch.fnmatchcase(name, pattern)
+            if hit:
+                result = not negate  # Last matching rule wins.
+        return result
+
+
+def initial_ignore(root: Path, base: Path | None) -> Ignore:
+    """Ignore files from the project root down to the search root (inclusive)."""
+    ignore = Ignore()
+    if base is None or not root.is_relative_to(base):
+        return ignore.extend(root)
+    parts = root.relative_to(base).parts
+    for depth in range(len(parts) + 1):
+        ignore = ignore.extend(base.joinpath(*parts[:depth]))
+    return ignore
+
+
+def files(root: Path, base: Path | None):
+    if root.is_file():
+        yield root
+        return
+    if not root.is_dir():
+        raise FileNotFoundError()
+    boundary = root.resolve()
+    ignores = {root: initial_ignore(root, base)}
+    for directory, folders, names in os.walk(root):
+        current = Path(directory)
+        ignore = ignores.pop(current, None) or Ignore()
+        kept = []
+        for name in folders:
+            path = current / name
+            if (
+                name in SKIP_DIRS
+                or (name == "worktrees" and current.name == ".mosscode")
+                or path.is_symlink()
+                or path.is_junction()
+                or not path.resolve().is_relative_to(boundary)
+                or ignore.ignored(path, True)
+            ):
+                continue
+            kept.append(name)
+            ignores[path] = ignore.extend(path)
+        folders[:] = kept
+        for name in names:
+            path = current / name
+            if ignore.ignored(path, False):
+                continue
+            try:
+                if path.resolve().is_relative_to(boundary):
+                    yield path
+            except (OSError, RuntimeError):
+                continue
+
+
+def grep_file(path, expression, context):
+    """Yield (kind, line_number, text) like rg --json match/context events."""
+    before = deque(maxlen=context)
+    after = 0
+    with path.open(encoding="utf-8") as stream:
+        for number, line in enumerate(stream, 1):
+            if "\0" in line:
+                return
+            if expression.search(line):
+                yield from (("context", n, text) for n, text in before)
+                before.clear()
+                yield "match", number, line
+                after = context
+            elif after:
+                yield "context", number, line
+                after -= 1
+            elif context:
+                before.append((number, line))
+
+
+def main():
+    mode, arguments = sys.argv[1], json.loads(sys.argv[2])
+    root = Path(arguments["path"])
+    base = Path(arguments["base"]) if arguments.get("base") else None
+    flags = re.IGNORECASE if arguments.get("ignore_case") else 0
+    expression = re.compile(arguments["pattern"], flags) if mode != "glob" else None
+    pattern = arguments["pattern"] if mode == "glob" else arguments.get("glob")
+    # Braces are expanded for user patterns only; .gitignore has no brace syntax.
+    patterns = expand_braces(pattern) if pattern else []
+    for path in files(root, base):
+        relative = path.name if root.is_file() else path.relative_to(root).as_posix()
+        if patterns and not any(
+            matches(relative, item) or ("/" not in item and fnmatch.fnmatchcase(path.name, item)) for item in patterns
+        ):
+            continue
+        if mode == "glob":
+            print(relative, flush=True)
+            continue
+        try:
+            if mode == "count":
+                count = sum(1 for kind, _, _ in grep_file(path, expression, 0) if kind == "match")
+                if count:
+                    sys.stdout.write(f"{path}\0{count}\n")
+                    sys.stdout.flush()
+                continue
+            for kind, number, line in grep_file(path, expression, arguments.get("context", 0)):
+                print(
+                    json.dumps(
+                        {
+                            "type": kind,
+                            "data": {"path": {"text": str(path)}, "line_number": number, "lines": {"text": line}},
+                        },
+                        ensure_ascii=False,
+                    ),
+                    flush=True,
+                )
+        except (UnicodeError, PermissionError, IsADirectoryError):
+            continue
+
+
+if __name__ == "__main__":
+    # pipe text encoding is explicit even under legacy Windows code pages.
+    sys.stdout.reconfigure(encoding="utf-8")
+    try:
+        main()
+    except (ValueError, OSError, re.error) as exc:
+        print(type(exc).__name__, file=sys.stderr)
+        raise SystemExit(2) from None

mosscode/tools/shell.py

@@ -0,0 +1,121 @@
+"""Pick the command shell once per registry: Git Bash on Windows when present."""
+
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Shell:
+    kind: str  # "bash", "sh" or "powershell"
+    path: str
+    label: str  # Shown to the model and the user.
+
+    def args(self, command: str) -> list[str]:
+        if self.kind == "powershell":
+            prelude = "[Console]::OutputEncoding=[System.Text.UTF8Encoding]::new($false); $OutputEncoding=[Console]::OutputEncoding; $LASTEXITCODE=$null; "
+            suffix = "\n$mosscodeCommandSucceeded=$?; if ($null -ne $LASTEXITCODE) { exit $LASTEXITCODE }; if (-not $mosscodeCommandSucceeded) { exit 1 }"
+            return [self.path, "-NoLogo", "-NoProfile", "-NonInteractive", "-Command", prelude + command + suffix]
+        if self.kind == "bash" and os.name == "nt":
+            return [self.path, "--noprofile", "--norc", "-c", f'eval "${COMMAND_VARIABLE}"']
+        if self.kind == "bash":
+            return [self.path, "--noprofile", "--norc", "-c", command]
+        return [self.path, "-c", command]
+
+    def env(self, command: str) -> dict[str, str] | None:
+        # MSYS bash re-parses its Windows command line Cygwin-style, which
+        # collapses `\\` inside quoted arguments; the environment is passed verbatim.
+        if self.kind == "bash" and os.name == "nt":
+            return {**os.environ, COMMAND_VARIABLE: command}
+        return None
+
+
+COMMAND_VARIABLE = "MOSSCODE_COMMAND"
+
+
+class ShellNotFound(ValueError):
+    pass
+
+
+def _is_wsl(path: Path) -> bool:
+    # System32\bash.exe starts WSL, a different filesystem and toolchain.
+    system = Path(os.environ.get("SystemRoot", r"C:\Windows"))
+    try:
+        return path.resolve().is_relative_to(system.resolve())
+    except OSError:
+        return True
+
+
+def _unshim(path: Path) -> Path:
+    # Scoop shims are tiny launchers; the real target is in <name>.shim.
+    shim = path.with_suffix(".shim")
+    try:
+        for line in shim.read_text(encoding="utf-8").splitlines():
+            key, _, value = line.partition("=")
+            if key.strip() == "path":
+                return Path(value.strip().strip('"'))
+    except (OSError, UnicodeError):
+        pass
+    return path
+
+
+def git_bash() -> Path | None:
+    candidates = []
+    git = shutil.which("git")
+    if git:
+        # git.exe lives in <root>\cmd, <root>\bin or <root>\mingw64\bin.
+        candidates.extend(parent / "bin" / "bash.exe" for parent in _unshim(Path(git)).resolve().parents[:3])
+    bash = shutil.which("bash")
+    if bash:
+        bash = _unshim(Path(bash)).resolve()
+        # Prefer the <root>\bin wrapper: it puts /usr/bin and /mingw64/bin on PATH.
+        if bash.parent.name.lower() == "bin" and bash.parent.parent.name.lower() == "usr":
+            candidates.append(bash.parents[2] / "bin" / "bash.exe")
+        candidates.append(bash)
+    for variable in ("ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"):
+        if os.environ.get(variable):
+            candidates.append(Path(os.environ[variable]) / "Git" / "bin" / "bash.exe")
+    if os.environ.get("LOCALAPPDATA"):
+        candidates.append(Path(os.environ["LOCALAPPDATA"]) / "Programs" / "Git" / "bin" / "bash.exe")
+    return next((path for path in candidates if path.is_file() and not _is_wsl(path)), None)
+
+
+def _powershell() -> Shell | None:
+    path = shutil.which("pwsh") or shutil.which("powershell")
+    return Shell("powershell", path, "PowerShell") if path else None
+
+
+def resolve_shell(preference: str = "auto") -> Shell:
+    preference = (preference or "auto").strip()
+    lowered = preference.lower()
+    if lowered == "powershell":
+        shell = _powershell()
+        if shell is None:
+            raise ShellNotFound("配置要求使用 PowerShell，但找不到 pwsh 或 powershell。")
+        return shell
+    if lowered in {"auto", "bash"}:
+        if os.name == "nt":
+            found = git_bash()
+            if found is not None:
+                return Shell("bash", str(found), "Git Bash")
+            if lowered == "bash":
+                raise ShellNotFound(
+                    "配置要求使用 bash，但没有找到 Git Bash；可安装 Git for Windows，或在 shell 中填写 bash.exe 的路径。"
+                )
+            shell = _powershell()
+            if shell is None:
+                raise ShellNotFound("找不到 Git Bash，也找不到 PowerShell。")
+            return shell
+        found = shutil.which("bash")
+        if found:
+            return Shell("bash", found, "bash")
+        if lowered == "bash":
+            raise ShellNotFound("配置要求使用 bash，但 PATH 中没有 bash。")
+        return Shell("sh", "/bin/sh", "sh")
+    path = Path(preference).expanduser()
+    if not path.is_file():
+        raise ShellNotFound(f"shell 配置的路径不存在：{path}")
+    if os.name == "nt" and _is_wsl(path):
+        raise ShellNotFound("shell 不支持 System32 下的 WSL bash；请填写 Git Bash 的 bash.exe。")
+    return Shell("bash", str(path), "Git Bash" if os.name == "nt" else "bash")