codebuff-agent 2.1.74__py3-none-any.whl

jupyter_ext/tools/dir_complete.py

@@ -0,0 +1,86 @@
+"""프로젝트 디렉터리 자동완성 — 설정 화면의 디렉터리 칸이 부른다 (이슈 #171).
+
+입력한 경로의 부모 디렉터리 **한 단계만** 읽는다. `@` 파일 멘션 자동완성의 `FileIndex` 는
+요청마다 트리를 통째로 걸어서(최대 10,000 항목) 키 입력마다 부르기에는 무겁다.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Dict, List, Optional
+
+from codebuff_core.directory_policy import COMMON_EXCLUDED_DIRS
+
+MAX_RESULTS = 50
+
+
+def _inside(path: str, roots: List[str]) -> bool:
+    return any(
+        path == root or path.startswith(root.rstrip(os.sep) + os.sep) for root in roots
+    )
+
+
+def _has_agents_md(path: str) -> bool:
+    try:
+        return any(
+            name.lower() == "agents.md" and os.path.isfile(os.path.join(path, name))
+            for name in os.listdir(path)
+        )
+    except OSError:
+        return False
+
+
+def complete_directories(
+    prefix: str,
+    base: str,
+    limit: int = MAX_RESULTS,
+    roots: Optional[List[str]] = None,
+) -> List[Dict]:
+    """`prefix` 에 이어질 디렉터리 후보.
+
+    상대 경로는 `base` 기준이다(저장값 해석과 같은 기준). `/` 로 끝나면 그 디렉터리의
+    자식, 아니면 부모의 자식 중 마지막 조각으로 시작하는 것(대소문자 무시)을 준다.
+    부모가 허용 루트(`base`·홈) 밖이거나 없으면 빈 목록이다. 링크 너머가 허용 루트 밖인
+    후보도 뺀다 — 골라도 그 아래로는 더 못 내려간다.
+
+    `~` 는 풀지 않는다. 저장값 해석(`_get_effective_workspace_root`)과 AGENTS.md 상태 API
+    가 안 풀어서, 여기서만 풀면 후보는 뜨는데 저장한 경로는 서버 루트로 폴백된다.
+    """
+    typed = prefix
+    if not os.path.isabs(typed):
+        typed = os.path.join(base, typed)
+    parent, fragment = os.path.split(typed)
+    if roots is None:
+        roots = [base, os.path.expanduser("~")]
+    real_roots = [os.path.realpath(r) for r in roots]
+    if not os.path.isdir(parent) or not _inside(os.path.realpath(parent), real_roots):
+        return []
+
+    show_hidden = fragment.startswith(".")
+    needle = fragment.lower()
+    try:
+        entries = [e for e in os.scandir(parent) if e.is_dir()]
+    except OSError:
+        return []
+    names = sorted(
+        (
+            e.name
+            for e in entries
+            if e.name.lower().startswith(needle)
+            and e.name not in COMMON_EXCLUDED_DIRS
+            and (show_hidden or not e.name.startswith("."))
+            and (not e.is_symlink() or _inside(os.path.realpath(e.path), real_roots))
+        ),
+        key=str.lower,
+    )[:limit]
+    result = []
+    for name in names:
+        path = os.path.normpath(os.path.join(parent, name))
+        result.append(
+            {
+                "path": path,
+                "git": os.path.exists(os.path.join(path, ".git")),
+                "agentsMd": _has_agents_md(path),
+            }
+        )
+    return result

jupyter_ext/tools/file_finder.py

@@ -0,0 +1,303 @@
+"""File finder with fzf-style subsequence matching.
+
+Provides a cached file index with both prefix and fuzzy matching,
+shared by the @ file-mention autocomplete handler and the file_find agent tool.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from codebuff_core.directory_policy import FILE_INDEX_EXCLUDED_DIRS as _EXCLUDE_DIRS
+
+
+def _fzf_score(query: str, candidate: str) -> float | None:
+    """fzf-style subsequence match. Returns None if no match."""
+    q, c = query.lower(), candidate.lower()
+    qi = ci = 0
+    positions: list[int] = []
+    while qi < len(q) and ci < len(c):
+        if q[qi] == c[ci]:
+            positions.append(ci)
+            qi += 1
+        ci += 1
+    if qi < len(q):
+        return None
+    score = 100.0
+    # Consecutive character bonus
+    consecutive = sum(
+        1 for i in range(1, len(positions)) if positions[i] == positions[i - 1] + 1
+    )
+    score += consecutive * 10
+    # Start-of-string bonus
+    if positions and positions[0] == 0:
+        score += 15
+    # Gap penalty
+    total_gap = sum(
+        positions[i] - positions[i - 1] - 1
+        for i in range(1, len(positions))
+        if positions[i] > positions[i - 1] + 1
+    )
+    score -= total_gap * 3
+    # Length difference penalty
+    score -= (len(candidate) - len(query)) * 1
+    return score
+
+
+class FileIndex:
+    """Caches a directory tree in memory and provides fuzzy search."""
+
+    def __init__(
+        self,
+        base_dir: str | Path,
+        ttl: int = 30,
+        max_files: int = 10_000,
+    ):
+        self._base_dir = Path(base_dir).resolve()
+        self._ttl = ttl
+        self._max_files = max_files
+        self._entries: list[str] = []  # relative paths
+        self._built_at: float = 0.0
+
+    # ------------------------------------------------------------------
+    # Index management
+    # ------------------------------------------------------------------
+
+    def _maybe_rebuild(self) -> None:
+        if time.monotonic() - self._built_at < self._ttl and self._entries:
+            return
+        self._build_index()
+
+    def _build_index(self) -> None:
+        entries: list[str] = []
+        base = str(self._base_dir)
+        for dirpath, dirnames, filenames in os.walk(base):
+            # Prune excluded directories in-place
+            dirnames[:] = [
+                d for d in dirnames if d not in _EXCLUDE_DIRS and not d.startswith(".")
+            ]
+
+            rel_dir = os.path.relpath(dirpath, base)
+            if rel_dir == ".":
+                rel_dir = ""
+
+            # Add directory entry (with trailing /)
+            if rel_dir:
+                entries.append(rel_dir + "/")
+
+            for fname in filenames:
+                if fname.startswith("."):
+                    continue
+                if rel_dir:
+                    entries.append(os.path.join(rel_dir, fname))
+                else:
+                    entries.append(fname)
+
+                if len(entries) >= self._max_files:
+                    break
+            if len(entries) >= self._max_files:
+                break
+
+        self._entries = entries
+        self._built_at = time.monotonic()
+
+    # ------------------------------------------------------------------
+    # Search methods
+    # ------------------------------------------------------------------
+
+    def fuzzy_search(
+        self,
+        query: str,
+        max_results: int = 20,
+        supported_exts: set[str] | None = None,
+        include_dirs: bool = True,
+    ) -> list[dict]:
+        """Find files by fuzzy matching on the query string.
+
+        If query contains '/', the part before the last '/' is used as a
+        directory filter and only the basename portion is fuzzy-matched.
+
+        Returns list of dicts: [{path, score, type}, ...]
+        """
+        self._maybe_rebuild()
+        if not query:
+            return []
+
+        # Split directory filter from basename query
+        dir_filter = ""
+        basename_query = query
+        if "/" in query:
+            last_slash = query.rfind("/")
+            dir_filter = query[:last_slash]
+            basename_query = query[last_slash + 1 :]
+            if not basename_query:
+                # query like "src/" → fall back to prefix search
+                return self.prefix_search(query, max_results, supported_exts)
+
+        # Filter candidates
+        candidates: list[str] = []
+        for entry in self._entries:
+            is_dir = entry.endswith("/")
+
+            if not include_dirs and is_dir:
+                continue
+
+            if not is_dir and supported_exts is not None:
+                ext = os.path.splitext(entry)[1]
+                if ext not in supported_exts:
+                    continue
+
+            if dir_filter and not entry.startswith(dir_filter):
+                continue
+
+            candidates.append(entry)
+
+        if not candidates:
+            return []
+
+        # fzf-style subsequence matching on basename
+        scored: list[tuple[str, float]] = []
+        for entry in candidates:
+            basename = os.path.basename(entry.rstrip("/"))
+            s = _fzf_score(basename_query, basename)
+            if s is None:
+                continue
+            # Depth penalty: shallower files preferred
+            depth = entry.count("/") - (1 if entry.endswith("/") else 0)
+            s -= depth * 1.0
+            scored.append((entry, s))
+
+        # Sort by score descending
+        scored.sort(key=lambda x: -x[1])
+
+        results: list[dict] = []
+        for entry, score in scored[:max_results]:
+            is_dir = entry.endswith("/")
+            results.append(
+                {
+                    "path": entry.rstrip("/") if is_dir else entry,
+                    "score": round(score, 1),
+                    "type": "directory" if is_dir else "file",
+                }
+            )
+        return results
+
+    def prefix_search(
+        self,
+        prefix: str,
+        max_results: int = 20,
+        supported_exts: set[str] | None = None,
+    ) -> list[dict]:
+        """Find files/dirs matching a path prefix (existing glob behavior)."""
+        self._maybe_rebuild()
+
+        # Normalize: ensure no trailing slash for matching (unless root)
+        norm_prefix = prefix.rstrip("/") if prefix != "/" else ""
+        results: list[dict] = []
+
+        for entry in self._entries:
+            is_dir = entry.endswith("/")
+            entry_clean = entry.rstrip("/")
+
+            # Match: entry starts with prefix
+            if not entry_clean.startswith(norm_prefix):
+                continue
+
+            # Only direct children if prefix looks like a directory
+            if prefix.endswith("/") or not prefix:
+                remainder = entry_clean[len(norm_prefix) :].lstrip("/")
+                if "/" in remainder:
+                    continue
+
+            if not is_dir and supported_exts is not None:
+                ext = os.path.splitext(entry)[1]
+                if ext not in supported_exts:
+                    continue
+
+            results.append(
+                {
+                    "path": entry_clean,
+                    "score": 100.0,
+                    "type": "directory" if is_dir else "file",
+                }
+            )
+            if len(results) >= max_results:
+                break
+
+        # Sort: directories first, then alphabetical
+        results.sort(key=lambda r: (r["type"] != "directory", r["path"].lower()))
+        return results
+
+
+# ----------------------------------------------------------------------
+# Navigate File (IntelliJ 식 파일 이름 검색)
+# ----------------------------------------------------------------------
+
+# 키 입력마다 요청이 오므로 인덱스를 루트별로 한 벌만 두고 TTL 로 갱신한다.
+_SHARED_INDEXES: dict[str, FileIndex] = {}
+
+
+def shared_file_index(base_dir: str | Path) -> FileIndex:
+    key = str(Path(base_dir).resolve())
+    index = _SHARED_INDEXES.get(key)
+    if index is None:
+        index = _SHARED_INDEXES[key] = FileIndex(key, max_files=50_000)
+    return index
+
+
+# 머리글자(IntelliJ 의 camel hump) 매칭 가산점. "ACT" 는 AppConfigTests 의 머리글자라
+# 어디든 부분열로만 맞는 factory.py 보다 위에 와야 하고, 머리글자가 "act" 로 시작하는
+# AppConfigTests 가 머리글자 a·c·s·t 사이에 흩어져 맞는 AccessControlService 보다 위다.
+_INITIALS_PREFIX_BONUS = 80.0
+_INITIALS_BONUS = 50.0
+_SEPARATORS = "._-/ "
+
+
+def _initials(name: str) -> str:
+    """이름 첫 글자, 소문자 뒤 대문자, 구분자 뒤 글자를 모은다 (소문자로)."""
+    out = []
+    for i, ch in enumerate(name):
+        prev = name[i - 1] if i else ""
+        if (
+            i == 0
+            or (ch.isupper() and prev.islower())
+            or (prev in _SEPARATORS and ch not in _SEPARATORS)
+        ):
+            out.append(ch.lower())
+    return "".join(out)
+
+
+def _is_subsequence(query: str, text: str) -> bool:
+    it = iter(text)
+    return all(ch in it for ch in query)
+
+
+def navigate_files(
+    base_dir: str | Path, query: str, max_results: int = 50
+) -> list[dict]:
+    """파일 이름 퍼지 검색. 확장자를 거르지 않고 디렉터리는 뺀다."""
+    query = query.strip()
+    if not query:
+        return []
+    # `폴더/이름`: FileIndex 의 폴더 필터는 루트부터 맞추므로 쓰지 않고, 이름만 검색한 뒤
+    # 폴더 부분이 경로 어디에든 있는 것만 남긴다 (IntelliJ 와 같다)
+    dir_hint, _, name_query = query.rpartition("/")
+    name_query = name_query.lower()
+    if not name_query:
+        return []
+    results = shared_file_index(base_dir).fuzzy_search(
+        name_query, max_results=max(500, max_results), include_dirs=False
+    )
+    if dir_hint:
+        hint = dir_hint.strip("/").lower() + "/"
+        results = [r for r in results if hint in "/" + r["path"].lower()]
+    for r in results:
+        initials = _initials(os.path.basename(r["path"]))
+        if initials.startswith(name_query):
+            r["score"] = round(r["score"] + _INITIALS_PREFIX_BONUS, 1)
+        elif _is_subsequence(name_query, initials):
+            r["score"] = round(r["score"] + _INITIALS_BONUS, 1)
+    results.sort(key=lambda r: -r["score"])
+    return results[:max_results]

jupyter_ext/tools/file_tools.py

@@ -0,0 +1,244 @@
+"""파일 작업 도구."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .base import BaseTool, ToolResult
+
+
+class FileReadTool(BaseTool):
+    """파일 내용 읽기 도구."""
+
+    def __init__(self, contents_manager: Any, base_path: str = "."):
+        self._contents_manager = contents_manager
+        self._base_path = Path(base_path)
+
+    @property
+    def name(self) -> str:
+        return "file_read"
+
+    @property
+    def description(self) -> str:
+        return """Read the contents of a file.
+Returns the file content as text. For binary files, returns an error."""
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "The file path to read (relative to workspace)",
+                },
+                "encoding": {
+                    "type": "string",
+                    "description": "File encoding (default: utf-8)",
+                    "default": "utf-8",
+                },
+            },
+            "required": ["path"],
+        }
+
+    @property
+    def risk_level(self) -> str:
+        return "low"
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        """파일 내용을 읽습니다."""
+        path = kwargs.get("path", "")
+        encoding = kwargs.get("encoding", "utf-8")
+
+        if not path:
+            return ToolResult(success=False, error="경로가 필요합니다")
+
+        try:
+            file_path = self._base_path / path
+            if not file_path.exists():
+                return ToolResult(success=False, error=f"파일을 찾을 수 없음: {path}")
+
+            if not file_path.is_file():
+                return ToolResult(success=False, error=f"파일이 아님: {path}")
+
+            content = file_path.read_text(encoding=encoding)
+            return ToolResult(
+                success=True,
+                data={"content": content, "path": str(path)},
+                metadata={"size": len(content), "encoding": encoding},
+            )
+
+        except UnicodeDecodeError:
+            return ToolResult(
+                success=False, error=f"텍스트로 읽을 수 없는 파일: {path}"
+            )
+        except Exception as e:
+            return ToolResult(success=False, error=f"파일 읽기 오류: {str(e)}")
+
+
+class FileWriteTool(BaseTool):
+    """파일 내용 쓰기 도구."""
+
+    def __init__(self, contents_manager: Any, base_path: str = "."):
+        self._contents_manager = contents_manager
+        self._base_path = Path(base_path)
+
+    @property
+    def name(self) -> str:
+        return "file_write"
+
+    @property
+    def description(self) -> str:
+        return """Write content to a file.
+Creates the file if it doesn't exist. Creates parent directories if needed."""
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "The file path to write (relative to workspace)",
+                },
+                "content": {
+                    "type": "string",
+                    "description": "The content to write",
+                },
+                "encoding": {
+                    "type": "string",
+                    "description": "File encoding (default: utf-8)",
+                    "default": "utf-8",
+                },
+                "append": {
+                    "type": "boolean",
+                    "description": "Append to file instead of overwriting",
+                    "default": False,
+                },
+            },
+            "required": ["path", "content"],
+        }
+
+    @property
+    def risk_level(self) -> str:
+        return "high"
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        """파일 내용을 씁니다."""
+        path = kwargs.get("path", "")
+        content = kwargs.get("content", "")
+        encoding = kwargs.get("encoding", "utf-8")
+        append = kwargs.get("append", False)
+
+        if not path:
+            return ToolResult(success=False, error="경로가 필요합니다")
+
+        try:
+            file_path = self._base_path / path
+
+            # 필요시 상위 디렉토리 생성
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            mode = "a" if append else "w"
+            with open(file_path, mode, encoding=encoding) as f:
+                f.write(content)
+
+            return ToolResult(
+                success=True,
+                data={"path": str(path), "operation": "append" if append else "write"},
+                metadata={"size": len(content)},
+            )
+
+        except Exception as e:
+            return ToolResult(success=False, error=f"파일 쓰기 오류: {str(e)}")
+
+
+class FileListTool(BaseTool):
+    """디렉토리 내용 목록 도구."""
+
+    def __init__(self, contents_manager: Any, base_path: str = "."):
+        self._contents_manager = contents_manager
+        self._base_path = Path(base_path)
+
+    @property
+    def name(self) -> str:
+        return "file_list"
+
+    @property
+    def description(self) -> str:
+        return """List files and directories in a path.
+Returns a list of file/directory names with their types."""
+
+    @property
+    def parameters(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "The directory path to list (relative to workspace)",
+                    "default": ".",
+                },
+                "recursive": {
+                    "type": "boolean",
+                    "description": "List recursively",
+                    "default": False,
+                },
+                "pattern": {
+                    "type": "string",
+                    "description": "Glob pattern to filter files (e.g., '*.py')",
+                },
+            },
+        }
+
+    @property
+    def risk_level(self) -> str:
+        return "low"
+
+    async def execute(self, **kwargs: Any) -> ToolResult:
+        """디렉토리 내용을 나열합니다."""
+        path = kwargs.get("path", ".")
+        recursive = kwargs.get("recursive", False)
+        pattern = kwargs.get("pattern")
+
+        try:
+            dir_path = self._base_path / path
+            if not dir_path.exists():
+                return ToolResult(success=False, error=f"경로를 찾을 수 없음: {path}")
+
+            if not dir_path.is_dir():
+                return ToolResult(success=False, error=f"디렉토리가 아님: {path}")
+
+            entries = []
+
+            if pattern:
+                if recursive:
+                    files = dir_path.rglob(pattern)
+                else:
+                    files = dir_path.glob(pattern)
+            else:
+                if recursive:
+                    files = dir_path.rglob("*")
+                else:
+                    files = dir_path.iterdir()
+
+            for entry in files:
+                rel_path = entry.relative_to(self._base_path)
+                entries.append(
+                    {
+                        "name": entry.name,
+                        "path": str(rel_path),
+                        "type": "directory" if entry.is_dir() else "file",
+                        "size": entry.stat().st_size if entry.is_file() else None,
+                    }
+                )
+
+            return ToolResult(
+                success=True,
+                data={"entries": entries, "path": str(path)},
+                metadata={"count": len(entries)},
+            )
+
+        except Exception as e:
+            return ToolResult(success=False, error=f"디렉토리 목록 조회 오류: {str(e)}")