pi-mono-coding 0.1.0__py3-none-any.whl

pi_coding/utils/edit_diff.py

@@ -0,0 +1,374 @@
+"""
+Shared diff computation utilities for the edit tool.
+Used by both edit.py (for execution) and tool-execution.py (for preview rendering).
+
+Python port of edit-diff.ts — uses difflib instead of npm's 'diff' package.
+"""
+
+from __future__ import annotations
+
+import difflib
+import os
+import re
+from dataclasses import dataclass
+from typing import Literal, Optional
+
+
+def detect_line_ending(content: str) -> Literal["\r\n", "\n"]:
+    """Detect the dominant line ending in content."""
+    crlf_idx = content.find("\r\n")
+    lf_idx = content.find("\n")
+    if lf_idx == -1:
+        return "\n"
+    if crlf_idx == -1:
+        return "\n"
+    return "\r\n" if crlf_idx < lf_idx else "\n"
+
+
+def normalize_to_lf(text: str) -> str:
+    """Normalize all line endings to LF."""
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def restore_line_endings(text: str, ending: str) -> str:
+    """Restore line endings to the specified type."""
+    return text.replace("\n", "\r\n") if ending == "\r\n" else text
+
+
+def normalize_for_fuzzy_match(text: str) -> str:
+    """
+    Normalize text for fuzzy matching. Applies progressive transformations:
+    - Strip trailing whitespace from each line
+    - Normalize smart quotes to ASCII equivalents
+    - Normalize Unicode dashes/hyphens to ASCII hyphen
+    - Normalize special Unicode spaces to regular space
+    """
+    # Strip trailing whitespace per line
+    result = "\n".join(line.rstrip() for line in text.split("\n"))
+    # Smart single quotes → '
+    result = re.sub("[\u2018\u2019\u201a\u201b]", "'", result)
+    # Smart double quotes → "
+    result = re.sub('[\u201c\u201d\u201e\u201f]', '"', result)
+    # Various dashes/hyphens → -
+    # U+2010 hyphen, U+2011 non-breaking hyphen, U+2012 figure dash,
+    # U+2013 en-dash, U+2014 em-dash, U+2015 horizontal bar, U+2212 minus
+    result = re.sub("[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]", "-", result)
+    # Special spaces → regular space
+    # U+00A0 NBSP, U+2002-U+200A various spaces, U+202F narrow NBSP,
+    # U+205F medium math space, U+3000 ideographic space
+    result = re.sub("[\u00a0\u2002-\u200a\u202f\u205f\u3000]", " ", result)
+    return result
+
+
+@dataclass
+class FuzzyMatchResult:
+    """Result of a fuzzy text match."""
+
+    found: bool
+    """Whether a match was found."""
+
+    index: int
+    """The index where the match starts (in the content used for replacement)."""
+
+    match_length: int
+    """Length of the matched text."""
+
+    used_fuzzy_match: bool
+    """Whether fuzzy matching was used (False = exact match)."""
+
+    content_for_replacement: str
+    """The content to use for replacement operations.
+    When exact match: original content.  When fuzzy match: normalized content."""
+
+
+def fuzzy_find_text(content: str, old_text: str) -> FuzzyMatchResult:
+    """
+    Find *old_text* in *content*, trying exact match first, then fuzzy match.
+
+    When fuzzy matching is used, the returned ``content_for_replacement`` is the
+    fuzzy-normalized version of the content (trailing whitespace stripped,
+    Unicode quotes/dashes normalised to ASCII).
+    """
+    # Try exact match first
+    exact_index = content.find(old_text)
+    if exact_index != -1:
+        return FuzzyMatchResult(
+            found=True,
+            index=exact_index,
+            match_length=len(old_text),
+            used_fuzzy_match=False,
+            content_for_replacement=content,
+        )
+
+    # Try fuzzy match – work entirely in normalized space
+    fuzzy_content = normalize_for_fuzzy_match(content)
+    fuzzy_old_text = normalize_for_fuzzy_match(old_text)
+    fuzzy_index = fuzzy_content.find(fuzzy_old_text)
+
+    if fuzzy_index == -1:
+        return FuzzyMatchResult(
+            found=False,
+            index=-1,
+            match_length=0,
+            used_fuzzy_match=False,
+            content_for_replacement=content,
+        )
+
+    # When fuzzy matching, we work in the normalized space for replacement.
+    # This means the output will have normalized whitespace/quotes/dashes,
+    # which is acceptable since we're fixing minor formatting differences anyway.
+    return FuzzyMatchResult(
+        found=True,
+        index=fuzzy_index,
+        match_length=len(fuzzy_old_text),
+        used_fuzzy_match=True,
+        content_for_replacement=fuzzy_content,
+    )
+
+
+def strip_bom(content: str) -> tuple[str, str]:
+    """Strip UTF-8 BOM if present.
+
+    Returns:
+        A ``(bom, text)`` tuple where *bom* is the BOM character (or ``""``)
+        and *text* is the content without it.
+    """
+    if content.startswith("\ufeff"):
+        return ("\ufeff", content[1:])
+    return ("", content)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers for line-level diffing (replaces npm 'diff' package)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class _DiffPart:
+    """Internal representation of a diff part, analogous to Diff.diffLines output."""
+
+    value: str
+    added: bool = False
+    removed: bool = False
+
+
+def _diff_lines(old_content: str, new_content: str) -> list[_DiffPart]:
+    """Compute line-level diffs using :mod:`difflib`, returning a list of
+    :class:`_DiffPart` objects compatible with the npm ``Diff.diffLines`` shape.
+    """
+    old_lines = old_content.splitlines(True)
+    new_lines = new_content.splitlines(True)
+
+    matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
+    parts: list[_DiffPart] = []
+
+    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+            parts.append(_DiffPart(value="".join(old_lines[i1:i2])))
+        elif tag == "replace":
+            parts.append(_DiffPart(value="".join(old_lines[i1:i2]), removed=True))
+            parts.append(_DiffPart(value="".join(new_lines[j1:j2]), added=True))
+        elif tag == "delete":
+            parts.append(_DiffPart(value="".join(old_lines[i1:i2]), removed=True))
+        elif tag == "insert":
+            parts.append(_DiffPart(value="".join(new_lines[j1:j2]), added=True))
+
+    return parts
+
+
+# ---------------------------------------------------------------------------
+# Public diff generation
+# ---------------------------------------------------------------------------
+
+def generate_diff_string(
+    old_content: str,
+    new_content: str,
+    context_lines: int = 4,
+) -> dict[str, str | int | None]:
+    """Generate a unified diff string with line numbers and context.
+
+    Returns:
+        A dict with keys ``"diff"`` (str) and ``"first_changed_line"``
+        (int | None).
+    """
+    parts = _diff_lines(old_content, new_content)
+    output: list[str] = []
+
+    old_lines = old_content.split("\n")
+    new_lines = new_content.split("\n")
+    max_line_num = max(len(old_lines), len(new_lines))
+    line_num_width = len(str(max_line_num))
+
+    old_line_num = 1
+    new_line_num = 1
+    last_was_change = False
+    first_changed_line: Optional[int] = None
+
+    for i, part in enumerate(parts):
+        raw = part.value.split("\n")
+        if raw and raw[-1] == "":
+            raw.pop()
+
+        if part.added or part.removed:
+            # Capture the first changed line (in the new file)
+            if first_changed_line is None:
+                first_changed_line = new_line_num
+
+            # Show the change
+            for line in raw:
+                if part.added:
+                    line_num_str = str(new_line_num).rjust(line_num_width)
+                    output.append(f"+{line_num_str} {line}")
+                    new_line_num += 1
+                else:  # removed
+                    line_num_str = str(old_line_num).rjust(line_num_width)
+                    output.append(f"-{line_num_str} {line}")
+                    old_line_num += 1
+            last_was_change = True
+        else:
+            # Context lines – only show a few before/after changes
+            next_part_is_change = (
+                i < len(parts) - 1
+                and (parts[i + 1].added or parts[i + 1].removed)
+            )
+
+            if last_was_change or next_part_is_change:
+                lines_to_show = list(raw)
+                skip_start = 0
+                skip_end = 0
+
+                if not last_was_change:
+                    # Show only last N lines as leading context
+                    skip_start = max(0, len(raw) - context_lines)
+                    lines_to_show = raw[skip_start:]
+
+                if not next_part_is_change and len(lines_to_show) > context_lines:
+                    # Show only first N lines as trailing context
+                    skip_end = len(lines_to_show) - context_lines
+                    lines_to_show = lines_to_show[:context_lines]
+
+                # Add ellipsis if we skipped lines at start
+                if skip_start > 0:
+                    output.append(f" {''.rjust(line_num_width)} ...")
+                    old_line_num += skip_start
+                    new_line_num += skip_start
+
+                for line in lines_to_show:
+                    line_num_str = str(old_line_num).rjust(line_num_width)
+                    output.append(f" {line_num_str} {line}")
+                    old_line_num += 1
+                    new_line_num += 1
+
+                # Add ellipsis if we skipped lines at end
+                if skip_end > 0:
+                    output.append(f" {''.rjust(line_num_width)} ...")
+                    old_line_num += skip_end
+                    new_line_num += skip_end
+            else:
+                # Skip these context lines entirely
+                old_line_num += len(raw)
+                new_line_num += len(raw)
+
+            last_was_change = False
+
+    return {"diff": "\n".join(output), "first_changed_line": first_changed_line}
+
+
+# ---------------------------------------------------------------------------
+# High-level edit-diff entry point
+# ---------------------------------------------------------------------------
+
+@dataclass
+class EditDiffResult:
+    """Result of a successful diff computation."""
+
+    diff: str
+    first_changed_line: Optional[int]
+
+
+@dataclass
+class EditDiffError:
+    """Result when diff computation encounters an error."""
+
+    error: str
+
+
+def compute_edit_diff(
+    path: str,
+    old_text: str,
+    new_text: str,
+    cwd: str,
+) -> EditDiffResult | EditDiffError:
+    """Compute the diff for an edit operation without applying it.
+
+    Used for preview rendering in the TUI before the tool executes.
+    """
+    # Resolve path relative to cwd
+    absolute_path = path if os.path.isabs(path) else os.path.join(cwd, path)
+
+    try:
+        # Check if file exists and is readable
+        if not os.path.isfile(absolute_path) or not os.access(absolute_path, os.R_OK):
+            return EditDiffError(error=f"File not found: {path}")
+
+        # Read the file
+        with open(absolute_path, encoding="utf-8") as f:
+            raw_content = f.read()
+
+        # Strip BOM before matching (LLM won't include invisible BOM in old_text)
+        _, content = strip_bom(raw_content)
+
+        normalized_content = normalize_to_lf(content)
+        normalized_old_text = normalize_to_lf(old_text)
+        normalized_new_text = normalize_to_lf(new_text)
+
+        # Find the old text using fuzzy matching (tries exact first, then fuzzy)
+        match_result = fuzzy_find_text(normalized_content, normalized_old_text)
+
+        if not match_result.found:
+            return EditDiffError(
+                error=(
+                    f"Could not find the exact text in {path}. "
+                    "The old text must match exactly including all whitespace and newlines."
+                ),
+            )
+
+        # Count occurrences using fuzzy-normalized content for consistency
+        fuzzy_content = normalize_for_fuzzy_match(normalized_content)
+        fuzzy_old_text = normalize_for_fuzzy_match(normalized_old_text)
+        occurrences = fuzzy_content.count(fuzzy_old_text)
+
+        if occurrences > 1:
+            return EditDiffError(
+                error=(
+                    f"Found {occurrences} occurrences of the text in {path}. "
+                    "The text must be unique. Please provide more context to make it unique."
+                ),
+            )
+
+        # Compute the new content using the matched position
+        # When fuzzy matching was used, content_for_replacement is the normalized version
+        base_content = match_result.content_for_replacement
+        new_content = (
+            base_content[: match_result.index]
+            + normalized_new_text
+            + base_content[match_result.index + match_result.match_length :]
+        )
+
+        # Check if it would actually change anything
+        if base_content == new_content:
+            return EditDiffError(
+                error=(
+                    f"No changes would be made to {path}. "
+                    "The replacement produces identical content."
+                ),
+            )
+
+        # Generate the diff
+        result = generate_diff_string(base_content, new_content)
+        return EditDiffResult(
+            diff=str(result["diff"]),
+            first_changed_line=int(result["first_changed_line"]) if result["first_changed_line"] is not None else None,
+        )
+
+    except Exception as err:
+        return EditDiffError(error=str(err))

pi_coding/utils/git.py

@@ -0,0 +1,201 @@
+from dataclasses import dataclass
+import subprocess
+import re
+from urllib.parse import urlparse
+from typing import Optional
+
+@dataclass
+class GitSource:
+    """Parsed git URL information."""
+    repo: str
+    host: str
+    path: str
+    type: str = "git"
+    ref: Optional[str] = None
+    pinned: bool = False
+
+def split_ref(url: str) -> dict:
+    """Split a git URL into repo and ref parts."""
+    # Handle SCP-like URLs: git@github.com:user/repo@ref
+    scp_match = re.match(r"^git@([^:]+):(.+)$", url)
+    if scp_match:
+        host = scp_match.group(1)
+        path_with_maybe_ref = scp_match.group(2)
+        if "@" in path_with_maybe_ref:
+            repo_path, ref = path_with_maybe_ref.split("@", 1)
+            if repo_path and ref:
+                return {
+                    "repo": f"git@{host}:{repo_path}",
+                    "ref": ref
+                }
+        return {"repo": url}
+
+    # Handle URLs with protocols: https://github.com/user/repo@ref
+    if "://" in url:
+        try:
+            parsed = urlparse(url)
+            path_with_maybe_ref = parsed.path.lstrip("/")
+            if "@" in path_with_maybe_ref:
+                repo_path, ref = path_with_maybe_ref.split("@", 1)
+                if repo_path and ref:
+                    # Reconstruct URL without ref
+                    new_path = f"/{repo_path}"
+                    new_url = parsed._replace(path=new_path).geturl()
+                    return {
+                        "repo": new_url.rstrip("/"),
+                        "ref": ref
+                    }
+            return {"repo": url}
+        except Exception:
+            return {"repo": url}
+
+    # Handle shorthand: github.com/user/repo@ref
+    if "/" in url:
+        host, path_with_maybe_ref = url.split("/", 1)
+        if "@" in path_with_maybe_ref:
+            repo_path, ref = path_with_maybe_ref.split("@", 1)
+            if repo_path and ref:
+                return {
+                    "repo": f"{host}/{repo_path}",
+                    "ref": ref
+                }
+    
+    return {"repo": url}
+
+def parse_generic_git_url(url: str) -> Optional[GitSource]:
+    """Parse a git URL that doesn't match hosted patterns."""
+    split = split_ref(url)
+    repo_without_ref = split["repo"]
+    ref = split.get("ref")
+    
+    repo = repo_without_ref
+    host = ""
+    path = ""
+
+    scp_match = re.match(r"^git@([^:]+):(.+)$", repo_without_ref)
+    if scp_match:
+        host = scp_match.group(1)
+        path = scp_match.group(2)
+    elif any(repo_without_ref.startswith(p) for p in ["https://", "http://", "ssh://", "git://"]):
+        try:
+            parsed = urlparse(repo_without_ref)
+            host = parsed.hostname or ""
+            path = parsed.path.lstrip("/")
+        except Exception:
+            return None
+    else:
+        if "/" not in repo_without_ref:
+            return None
+        host, path = repo_without_ref.split("/", 1)
+        if "." not in host and host != "localhost":
+            return None
+        repo = f"https://{repo_without_ref}"
+
+    normalized_path = path.replace(".git", "").lstrip("/")
+    if not host or not normalized_path or len(normalized_path.split("/")) < 2:
+        return None
+
+    return GitSource(
+        repo=repo,
+        host=host,
+        path=normalized_path,
+        ref=ref,
+        pinned=bool(ref)
+    )
+
+def parse_git_url(source: str) -> Optional[GitSource]:
+    """
+    Parse git source into a GitSource.
+    
+    Supports:
+    - git@github.com:user/repo
+    - https://github.com/user/repo
+    - git:github.com/user/repo
+    - Any of the above with @ref suffix
+    """
+    trimmed = source.strip()
+    has_git_prefix = trimmed.startswith("git:")
+    url = trimmed[4:].strip() if has_git_prefix else trimmed
+
+    # Without git: prefix, only accept explicit protocol URLs or SCP-like
+    if not has_git_prefix and not re.match(r"^(https?|ssh|git)://", url, re.I) and not url.startswith("git@"):
+        return None
+
+    # The TS implementation uses hosted-git-info which handles many shorthands.
+    # For this Python port, we'll focus on the core requirements and generic parsing.
+    # Since we don't have a direct equivalent of hosted-git-info in stdlib,
+    # and the task asks for a port of the logic, we'll use parse_generic_git_url
+    # which covers the requested formats.
+    
+    return parse_generic_git_url(url)
+
+def get_current_branch(cwd: Optional[str] = None) -> Optional[str]:
+    """Get current git branch."""
+    try:
+        result = subprocess.run(
+            ["git", "symbolic-ref", "--short", "HEAD"],
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+            
+        result = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+            
+        return None
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+def get_repo_status(cwd: Optional[str] = None) -> dict[str, bool]:
+    """Get repo status."""
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        output = result.stdout
+        lines = output.splitlines()
+        
+        has_unstaged_changes = False
+        has_staged_changes = False
+        has_untracked_files = False
+        
+        for line in lines:
+            if len(line) < 2:
+                continue
+            index_status = line[0]
+            worktree_status = line[1]
+            
+            if index_status == "?":
+                has_untracked_files = True
+            if index_status not in (" ", "?"):
+                has_staged_changes = True
+            if worktree_status not in (" ", "?"):
+                has_unstaged_changes = True
+                
+        is_clean = not (has_unstaged_changes or has_staged_changes or has_untracked_files)
+        
+        return {
+            "has_unstaged_changes": has_unstaged_changes,
+            "has_staged_changes": has_staged_changes,
+            "has_untracked_files": has_untracked_files,
+            "is_clean": is_clean
+        }
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return {
+            "has_unstaged_changes": False,
+            "has_staged_changes": False,
+            "has_untracked_files": False,
+            "is_clean": False
+        }

pi_coding/utils/path_utils.py

@@ -0,0 +1,129 @@
+"""Path resolution utilities — Python port of path-utils.ts.
+
+Handles macOS-specific filename quirks (NFD normalization, curly quotes,
+narrow no-break spaces in screenshot timestamps, etc.).
+"""
+
+import os
+import re
+import unicodedata
+
+# Matches various Unicode space characters that should be normalized to ASCII space.
+UNICODE_SPACES = re.compile(
+    "[\u00A0\u2000-\u200A\u202F\u205F\u3000]"
+)
+
+_NARROW_NO_BREAK_SPACE = "\u202F"
+
+# Matches " AM." or " PM." preceded by a regular space (macOS screenshot timestamps).
+_AM_PM_RE = re.compile(r" (AM|PM)\.")
+
+
+def normalize_unicode_spaces(s: str) -> str:
+    """Replace exotic Unicode whitespace characters with plain ASCII space."""
+    return UNICODE_SPACES.sub(" ", s)
+
+
+def try_macos_screenshot_path(file_path: str) -> str:
+    """Return *file_path* with narrow no-break space before AM/PM.
+
+    macOS screenshot filenames use U+202F (narrow no-break space) before the
+    AM/PM marker, but users typically type a regular space.
+    """
+    return _AM_PM_RE.sub(f"{_NARROW_NO_BREAK_SPACE}\\1.", file_path)
+
+
+def try_nfd_variant(file_path: str) -> str:
+    """Return the NFD (decomposed) form of *file_path*.
+
+    macOS (HFS+/APFS) stores filenames in NFD form, so converting user input
+    to NFD can resolve mismatches caused by composed characters.
+    """
+    return unicodedata.normalize("NFD", file_path)
+
+
+def try_curly_quote_variant(file_path: str) -> str:
+    """Replace straight apostrophes with right single quotation marks.
+
+    macOS uses U+2019 (') in screenshot names such as ``Capture d\u2019\u00e9cran``,
+    but users typically type U+0027 (').
+    """
+    return file_path.replace("'", "\u2019")
+
+
+def file_exists(file_path: str) -> bool:
+    """Return ``True`` if *file_path* exists on disk (file or directory)."""
+    try:
+        os.stat(file_path)
+        return True
+    except OSError:
+        return False
+
+
+def normalize_at_prefix(file_path: str) -> str:
+    """Strip a leading ``@`` prefix from *file_path*."""
+    if file_path.startswith("@"):
+        return file_path[1:]
+    return file_path
+
+
+def expand_path(file_path: str) -> str:
+    """Expand ``~`` to the user's home directory and normalize Unicode spaces."""
+    normalized = normalize_unicode_spaces(normalize_at_prefix(file_path))
+    if normalized == "~":
+        return os.path.expanduser("~")
+    if normalized.startswith("~/"):
+        return os.path.expanduser("~") + normalized[1:]
+    return normalized
+
+
+def resolve_to_cwd(file_path: str, cwd: str) -> str:
+    """Resolve *file_path* relative to *cwd*.
+
+    Handles ``~`` expansion and absolute paths.
+    """
+    expanded = expand_path(file_path)
+    if os.path.isabs(expanded):
+        return expanded
+    return os.path.normpath(os.path.join(cwd, expanded))
+
+
+def resolve_read_path(file_path: str, cwd: str) -> str:
+    """Resolve *file_path* for reading, trying macOS filename variants.
+
+    Attempts the following variants in order until one exists on disk:
+
+    1. Direct resolved path
+    2. macOS AM/PM narrow no-break space variant
+    3. NFD (decomposed) variant
+    4. Curly quote variant (U+2019)
+    5. Combined NFD + curly quote variant
+
+    If none exist, the original resolved path is returned.
+    """
+    resolved = resolve_to_cwd(file_path, cwd)
+
+    if file_exists(resolved):
+        return resolved
+
+    # Try macOS AM/PM variant (narrow no-break space before AM/PM)
+    am_pm_variant = try_macos_screenshot_path(resolved)
+    if am_pm_variant != resolved and file_exists(am_pm_variant):
+        return am_pm_variant
+
+    # Try NFD variant (macOS stores filenames in NFD form)
+    nfd_variant = try_nfd_variant(resolved)
+    if nfd_variant != resolved and file_exists(nfd_variant):
+        return nfd_variant
+
+    # Try curly quote variant (macOS uses U+2019 in screenshot names)
+    curly_variant = try_curly_quote_variant(resolved)
+    if curly_variant != resolved and file_exists(curly_variant):
+        return curly_variant
+
+    # Try combined NFD + curly quote (for French macOS screenshots like "Capture d'écran")
+    nfd_curly_variant = try_curly_quote_variant(nfd_variant)
+    if nfd_curly_variant != resolved and file_exists(nfd_curly_variant):
+        return nfd_curly_variant
+
+    return resolved