tau-coding-agent 0.1.0__py3-none-any.whl

tau/tui/diff.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import difflib
+import re
+from typing import Callable
+
+# Matches a standard unified diff line: prefix (+/-/ ) followed by optional
+# line number then content.
+_UNIFIED_LINE = re.compile(r"^([+\- ])(\s*\d*)\s?(.*)$")
+
+
+def _is_diff(text: str) -> bool:
+    """Heuristic: return True if text looks like a unified diff."""
+    lines = text.splitlines()
+    has_marker = any(l.startswith(("---", "+++", "@@")) for l in lines[:20])
+    has_change = any(l.startswith(("+", "-")) and len(l) > 1 for l in lines[:20])
+    return has_marker and has_change
+
+
+def _word_diff(old: str, new: str, inverse: Callable[[str], str]) -> tuple[str, str]:
+    """Highlight changed words with inverse video."""
+    old_words = re.split(r"(\s+)", old)
+    new_words = re.split(r"(\s+)", new)
+    sm = difflib.SequenceMatcher(None, old_words, new_words, autojunk=False)
+
+    old_out, new_out = [], []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        old_chunk = "".join(old_words[i1:i2])
+        new_chunk = "".join(new_words[j1:j2])
+        if tag == "equal":
+            old_out.append(old_chunk)
+            new_out.append(new_chunk)
+        elif tag == "replace":
+            old_out.append(inverse(old_chunk) if old_chunk.strip() else old_chunk)
+            new_out.append(inverse(new_chunk) if new_chunk.strip() else new_chunk)
+        elif tag == "delete":
+            old_out.append(inverse(old_chunk) if old_chunk.strip() else old_chunk)
+        elif tag == "insert":
+            new_out.append(inverse(new_chunk) if new_chunk.strip() else new_chunk)
+
+    return "".join(old_out), "".join(new_out)
+
+
+def render_diff(
+    diff_text: str,
+    added: Callable[[str], str],
+    removed: Callable[[str], str],
+    context: Callable[[str], str],
+    hunk: Callable[[str], str],
+    inverse: Callable[[str], str],
+) -> list[str]:
+    """
+    Render a unified diff string with ANSI colors.
+
+    - Header lines (---, +++) and hunk markers (@@): styled with ``hunk``
+    - Added lines (+): styled with ``added``
+    - Removed lines (-): styled with ``removed``
+    - Context lines ( ): styled with ``context``
+    - Adjacent single-line add/remove pairs get intra-line word highlighting
+      via ``inverse``.
+    """
+    raw_lines = diff_text.splitlines()
+    result: list[str] = []
+    i = 0
+
+    while i < len(raw_lines):
+        line = raw_lines[i]
+
+        # Header / hunk marker
+        if line.startswith(("---", "+++", "@@", "diff ", "index ", "new file", "deleted file")):
+            result.append(hunk(line))
+            i += 1
+            continue
+
+        if line.startswith("-"):
+            # Collect consecutive removed lines
+            removed_lines: list[str] = []
+            while i < len(raw_lines) and raw_lines[i].startswith("-"):
+                removed_lines.append(raw_lines[i][1:])
+                i += 1
+
+            # Collect consecutive added lines that immediately follow
+            added_lines: list[str] = []
+            while i < len(raw_lines) and raw_lines[i].startswith("+"):
+                added_lines.append(raw_lines[i][1:])
+                i += 1
+
+            # Intra-line diff only when it's a 1:1 change
+            if len(removed_lines) == 1 and len(added_lines) == 1:
+                old_hi, new_hi = _word_diff(removed_lines[0], added_lines[0], inverse)
+                result.append(removed("-" + old_hi))
+                result.append(added("+" + new_hi))
+            else:
+                for l in removed_lines:
+                    result.append(removed("-" + l))
+                for l in added_lines:
+                    result.append(added("+" + l))
+            continue
+
+        if line.startswith("+"):
+            result.append(added(line))
+            i += 1
+            continue
+
+        if line.startswith(" "):
+            result.append(context(line))
+            i += 1
+            continue
+
+        # Unrecognised line — pass through dimmed
+        result.append(context(line))
+        i += 1
+
+    return result

tau/tui/fuzzy.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass
+class FuzzyMatch:
+    matches: bool
+    score: float
+
+
+def fuzzy_match(query: str, text: str) -> FuzzyMatch:
+    """
+    Match if all query characters appear in order (not necessarily consecutive).
+    Lower score = better match.  Rewards consecutive runs and word-boundary hits.
+    """
+    q = query.lower()
+    t = text.lower()
+
+    def _match(q: str) -> FuzzyMatch:
+        if not q:
+            return FuzzyMatch(True, 0)
+        if len(q) > len(t):
+            return FuzzyMatch(False, 0)
+
+        qi = 0
+        score = 0.0
+        last = -1
+        consecutive = 0
+
+        for i, ch in enumerate(t):
+            if qi < len(q) and ch == q[qi]:
+                is_boundary = i == 0 or bool(re.match(r"[\s\-_./:]", t[i - 1]))
+                if last == i - 1:
+                    consecutive += 1
+                    score -= consecutive * 5
+                else:
+                    consecutive = 0
+                    if last >= 0:
+                        score += (i - last - 1) * 2
+                if is_boundary:
+                    score -= 10
+                score += i * 0.1
+                last = i
+                qi += 1
+
+        if qi < len(q):
+            return FuzzyMatch(False, 0)
+        if q == t:
+            score -= 100
+        return FuzzyMatch(True, score)
+
+    result = _match(q)
+    if result.matches:
+        return result
+
+    # Try swapped alphanumeric order (e.g. "v3" matches "3v")
+    m = re.match(r"^(?P<a>[a-z]+)(?P<d>[0-9]+)$", q) or re.match(r"^(?P<d>[0-9]+)(?P<a>[a-z]+)$", q)
+    if m:
+        swapped = (m.group("d") + m.group("a")) if "a" in m.groupdict() else ""
+        if swapped:
+            alt = _match(swapped)
+            if alt.matches:
+                return FuzzyMatch(True, alt.score + 5)
+
+    return result
+
+
+def fuzzy_filter(items: list, query: str, get_text) -> list:
+    """
+    Filter and sort items by fuzzy match quality (best matches first).
+    Supports space-separated tokens — all tokens must match.
+    `get_text` is a callable that extracts the searchable string from an item.
+    """
+    if not query.strip():
+        return items
+
+    tokens = [t for t in query.strip().split() if t]
+    if not tokens:
+        return items
+
+    scored: list[tuple[object, float]] = []
+    for item in items:
+        text = get_text(item)
+        total = 0.0
+        ok = True
+        for token in tokens:
+            m = fuzzy_match(token, text)
+            if m.matches:
+                total += m.score
+            else:
+                ok = False
+                break
+        if ok:
+            scored.append((item, total))
+
+    scored.sort(key=lambda x: x[1])
+    return [item for item, _ in scored]