cade-cli 0.3.3__py3-none-any.whl

cadecoder/tools/filesystem.py

@@ -0,0 +1,315 @@
+"""Filesystem operations for CadeCoder."""
+
+import difflib
+import fnmatch
+import os
+import re
+from pathlib import Path
+
+from cadecoder.core.errors import FileOpsError, FileSystemError
+from cadecoder.core.logging import log
+
+# --- File Finding and Discovery ---
+
+
+def find_files(
+    directory: Path,
+    ignore_patterns: list[str] | None = None,
+    include_directories: bool = False,
+    recursive: bool = True,
+) -> list[Path]:
+    """Find files (and optionally directories) recursively, respecting ignore patterns."""
+    found_paths: list[Path] = []
+    normalized_ignore_patterns = ignore_patterns or []
+
+    if not directory.is_dir():
+        log.warning(f"Directory not found or not accessible: {directory}")
+        return []
+
+    # Heuristic: patterns without typical glob wildcards are treated as potential directory names
+    # for the component-wise check. All patterns are still used for full/name glob matching.
+    ignorable_dir_components = {
+        pattern
+        for pattern in normalized_ignore_patterns
+        if "*" not in pattern and "?" not in pattern and "[" not in pattern and "]" not in pattern
+    }
+
+    items_to_iterate = list(directory.rglob("*")) if recursive else list(directory.glob("*"))
+
+    for item in items_to_iterate:
+        relative_path = item.relative_to(directory)
+
+        # Stage 1: Check if the item is within an explicitly named ignored directory component
+        is_in_ignored_dir_component = False
+        # Check item.name itself if it's a directory and matches a dir component pattern
+        if item.is_dir() and item.name in ignorable_dir_components:
+            is_in_ignored_dir_component = True
+        else:  # Check parent parts if the item itself (if a dir) wasn't a direct match
+            # For a file like 'some_dir/another_dir/file.txt', parts are ('some_dir', 'another_dir', 'file.txt')
+            # We check parts[:-1] which would be ('some_dir', 'another_dir')
+            for part in relative_path.parts[:-1]:
+                if part in ignorable_dir_components:
+                    is_in_ignored_dir_component = True
+                    break
+
+        if is_in_ignored_dir_component:
+            continue
+
+        # Stage 2: Check full relative path and item name against all original glob patterns.
+        # This handles file-specific patterns (e.g., *.pyc) and more complex/wildcarded directory patterns.
+        is_glob_ignored = False
+        for pattern in normalized_ignore_patterns:
+            # Use POSIX separators for matching, even on Windows, for the full relative path
+            relative_path_posix = str(relative_path).replace(os.sep, "/")
+            if fnmatch.fnmatch(relative_path_posix, pattern) or fnmatch.fnmatch(item.name, pattern):
+                is_glob_ignored = True
+                log.debug(
+                    f"Ignoring '{relative_path}' due to glob pattern '{pattern}' matching either full path or item name."
+                )
+                break
+        if is_glob_ignored:
+            continue
+
+        # If not ignored by any rule, add it based on its type
+        if item.is_file():
+            found_paths.append(item)
+        elif item.is_dir() and include_directories:
+            # Only add if explicitly requested and it passed all ignore checks
+            found_paths.append(item)
+
+    return found_paths
+
+
+# --- File Reading and Writing ---
+
+
+def read_text_file(file_path: Path) -> str:
+    """Read a text file, attempting common encodings."""
+    encodings = ["utf-8", "latin-1", "cp1252"]
+    for encoding in encodings:
+        try:
+            with file_path.open("r", encoding=encoding) as f:
+                return f.read()
+        except UnicodeDecodeError:
+            continue
+        except Exception as e:
+            log.warning(f"Error reading file {file_path} with encoding {encoding}: {e}")
+            # Propagate other errors (e.g., permission denied)
+            raise
+
+    # If all encodings fail
+    log.warning(f"Could not decode file {file_path} with standard encodings.")
+    # Return empty string or raise a custom error?
+    # For robustness, let's try reading as binary and decoding with replacement
+    try:
+        with file_path.open("rb") as f:
+            binary_content = f.read()
+        return binary_content.decode("utf-8", errors="replace")
+    except Exception as e:
+        log.error(f"Failed to read file {file_path} even as binary: {e}")
+        raise FileSystemError(f"Could not read file: {file_path}") from e
+
+
+def write_text_file(file_path: Path, content: str) -> None:
+    """
+    Write text content to a file, overwriting if it exists.
+
+    Security: The target path is first resolved and verified to be within the
+    project's root directory (the current working directory).  Any attempt to
+    write outside this root—whether through '..' path traversal, absolute paths,
+    or symlink resolution—results in a FileSystemError.
+    """
+    try:
+        # Resolve both the project root and the requested file path
+        project_root = Path.cwd().resolve()
+        resolved_path = file_path.expanduser().resolve()
+
+        # Ensure the resolved path is within the project root
+        if project_root not in resolved_path.parents and resolved_path != project_root:
+            raise FileSystemError(f"Refusing to write outside project root: '{file_path}'.")
+
+        # Ensure parent directory exists
+        resolved_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write content to file
+        with resolved_path.open("w", encoding="utf-8") as f:
+            f.write(content)
+        log.debug(f"Successfully wrote content to {resolved_path}")
+    except FileSystemError:
+        # Re‑raise custom filesystem errors without modification
+        raise
+    except OSError as e:
+        log.error(f"Failed to write to file {file_path}: {e}")
+        raise FileSystemError(f"Could not write file: {file_path}") from e
+    except Exception as e:
+        log.error(f"An unexpected error occurred writing to file {file_path}: {e}")
+        raise FileSystemError(f"Could not write file: {file_path}") from e
+
+
+# --- File Existence Checks ---
+
+
+def file_exists(file_path: Path) -> bool:
+    """Check if a file exists and is a file."""
+    return file_path.is_file()
+
+
+def dir_exists(dir_path: Path) -> bool:
+    """Check if a directory exists and is a directory."""
+    return dir_path.is_dir()
+
+
+# --- Diff Generation ---
+
+
+def _generate_diff_base(
+    lines1: list[str],
+    lines2: list[str],
+    fromfile: str,
+    tofile: str,
+    context_lines: int = 3,
+) -> str:
+    """Base function for generating unified diffs."""
+    try:
+        diff = difflib.unified_diff(
+            lines1,
+            lines2,
+            fromfile=fromfile,
+            tofile=tofile,
+            n=context_lines,
+            lineterm="",  # Avoid extra newlines in diff output
+        )
+        return "\n".join(diff)
+    except Exception as e:
+        log.error(f"Failed to generate diff: {e}")
+        raise FileOpsError(f"Could not generate diff: {e}") from e
+
+
+def generate_diff(path1: Path, path2: Path, context_lines: int = 3) -> str:
+    """Generates a unified diff between two files."""
+    try:
+        content1 = read_text_file(path1).splitlines()
+        content2 = read_text_file(path2).splitlines()
+        return _generate_diff_base(content1, content2, str(path1), str(path2), context_lines)
+    except FileOpsError:
+        raise
+    except Exception as e:
+        log.error(f"Failed to generate diff between {path1} and {path2}: {e}")
+        raise FileOpsError(f"Could not generate diff: {e}") from e
+
+
+def generate_diff_from_content(
+    original_content: str,
+    new_content: str,
+    filename: str = "file",
+    context_lines: int = 3,
+) -> str:
+    """Generates a unified diff between two strings of content."""
+    lines1 = original_content.splitlines()
+    lines2 = new_content.splitlines()
+    return _generate_diff_base(
+        lines1,
+        lines2,
+        f"a/{filename}",  # Standard diff format convention
+        f"b/{filename}",  # Standard diff format convention
+        context_lines,
+    )
+
+
+# --- Patch Application ---
+
+
+def apply_patch(original_content: str, patch_content: str) -> str:
+    """Applies a unified diff patch to string content.
+
+    Note: This is a basic implementation using difflib. It might not handle
+          all patch complexities (fuzziness, binary files, etc.).
+          Consider using a dedicated patch library for more robustness if needed.
+
+    Args:
+        original_content: The original string content.
+        patch_content: The unified diff patch string.
+
+    Returns:
+        The patched string content.
+
+    Raises:
+        FileOpsError: If the patch cannot be applied cleanly.
+    """
+    # Basic check for patch format
+    if not patch_content.strip() or not patch_content.startswith(("+++", "---")):
+        log.warning("Patch content appears empty or invalid.")
+        # Decide whether to return original or raise error
+        # For safety, let's return original if patch is clearly empty
+        if not patch_content.strip():
+            return original_content
+        raise FileOpsError("Invalid patch format provided.")
+
+    # difflib.patch expects list of lines
+    original_lines = original_content.splitlines(keepends=True)
+    patch_content.splitlines(keepends=True)
+
+    # Use difflib._patch_apply which underlies the `patch` command-line tool logic
+    # It's an internal function but provides the core logic.
+    # It returns a tuple: (new_lines, boolean_list_of_success)
+    try:
+        # difflib does not provide a public patch application API.
+        # We'll use difflib.restore to reconstruct the new content from the diff.
+        # This only works for diffs generated by difflib.unified_diff or ndiff.
+        # We check if the patch is a unified diff and apply accordingly.
+
+        # Try to use difflib.restore for ndiff-style diffs
+        if patch_content.startswith("---") or patch_content.startswith("+++"):
+            # Unified diff: use difflib.unified_diff to get the diff, but no direct apply
+            # We'll use patch-like logic to apply the diff
+            try:
+                patched_lines = list(
+                    difflib.restore(
+                        difflib.unified_diff(
+                            original_lines,
+                            [],  # empty, just to get the diff format
+                            lineterm="",
+                        ),
+                        2,  # 2 = get the "to" file
+                    )
+                )
+                # However, this doesn't actually apply the patch_content, so we need to use ndiff
+                # Instead, let's use ndiff and restore if possible
+                diff_lines = patch_content.splitlines(keepends=True)
+                patched_lines = list(difflib.restore(diff_lines, 2))
+                log.debug("Patch applied using difflib.restore.")
+                return "".join(patched_lines)
+            except Exception as e:
+                log.error(f"Error applying patch with difflib.restore: {e}")
+                raise FileOpsError(f"Failed during patch application process: {e}") from e
+        else:
+            log.error("Patch format not supported for difflib.restore.")
+            raise FileOpsError("Patch format not supported for difflib.restore.")
+
+    except Exception as e:
+        # Catch potential errors from the internal function
+        log.error(f"Error applying patch: {e}")
+        raise FileOpsError(f"Failed during patch application process: {e}") from e
+
+
+# --- Code Extraction ---
+
+
+def extract_code_from_markdown(markdown_content: str) -> str | None:
+    """Extracts the first code block content from markdown text.
+
+    Handles common code block markers like ``` and ```<language>.
+    Returns None if no code block is found.
+    """
+    # Regex to find fenced code blocks, possibly with language specifier
+    # It captures the content inside the first block found.
+    # DOTALL flag makes . match newlines.
+    match = re.search(r"^```(?:\w+)?\n(.*?)\n^```", markdown_content, re.MULTILINE | re.DOTALL)
+
+    if match:
+        return match.group(1).strip()  # Return the captured group content
+    else:
+        log.debug("No markdown code block found in content.")
+        # Should we return the whole content if no block found?
+        # For now, return None if no explicit block.
+        return None

cadecoder/tools/git.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Git operations for the CadeCoder chat application.
+"""
+
+import pathlib
+import subprocess
+
+from cadecoder.core.logging import log
+
+
+def get_project_root() -> pathlib.Path:
+    """Get the project root directory."""
+    return pathlib.Path.cwd()
+
+
+PROJECT_ROOT = get_project_root()
+
+
+def _sanitize_branch_name(name: str) -> str:
+    """Sanitizes a string to be a valid Git branch name."""
+    if not name:
+        return "unnamed-chat-branch"
+
+    name = name.replace(" ", "-").replace("/", "-")
+    name = name.replace("..", "-").replace(".lock", "")
+
+    sanitized = "".join(c if c.isalnum() or c in "-_" else "-" for c in name)
+
+    if sanitized.startswith("-"):
+        sanitized = "b-" + sanitized[1:] if len(sanitized) > 1 else "b-branch"
+
+    while "--" in sanitized:
+        sanitized = sanitized.replace("--", "-")
+
+    sanitized = sanitized.strip("-")
+
+    if sanitized.endswith("."):
+        sanitized = sanitized[:-1] + "-dot"
+
+    if not sanitized:
+        return "sanitized-empty-branch"
+
+    if len(sanitized) > 100:
+        sanitized = sanitized[:100]
+    if "@{" in sanitized:
+        sanitized = sanitized.replace("@{", "at-")
+
+    return sanitized
+
+
+def run_git_command(git_command_args: list[str]) -> tuple[str, str | None]:
+    """
+    Runs a Git command and returns its output.
+
+    Args:
+        git_command_args: Git command and arguments (e.g., ["status", "--short"]).
+
+    Returns:
+        Tuple of (stdout, stderr_message). stderr_message is None on success.
+    """
+    command = ["git"] + git_command_args
+    command_str = " ".join(command)
+
+    try:
+        log.debug(f"Running git command: {command_str}")
+        result = subprocess.run(
+            command,
+            cwd=str(PROJECT_ROOT),
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+        stdout_val = result.stdout.strip()
+
+        if result.returncode != 0:
+            err_msg = (
+                result.stderr.strip()
+                if result.stderr
+                else (
+                    stdout_val
+                    if stdout_val
+                    else f"Command '{command_str}' failed: exit code {result.returncode}"
+                )
+            )
+            return stdout_val, err_msg
+
+        return stdout_val, None
+
+    except Exception as e:
+        log.error(f"Unexpected error running git command: {e}")
+        return "", f"Error running command '{command_str}': {str(e)}"
+
+
+def create_or_switch_branch(chat_id: str, chat_name: str) -> tuple[str, str | None, str | None]:
+    """
+    Creates or switches to a Git branch for the chat session.
+
+    Returns:
+        Tuple of (message_to_display, error_message_if_any, branch_name).
+    """
+    base_name = chat_name if chat_name and chat_name.lower() != "new chat" else chat_id
+    branch_name = _sanitize_branch_name(f"cadechat/{base_name}")
+
+    list_stdout, _ = run_git_command(["branch", "--list", branch_name])
+    branch_exists_locally = branch_name in list_stdout.replace("*", "").strip().split("\n")
+
+    if branch_exists_locally:
+        stdout, err = run_git_command(["checkout", branch_name])
+        if err:
+            return stdout, f"Failed to switch to branch '{branch_name}': {err}", None
+        return f"Switched to existing branch: {branch_name}", None, branch_name
+    else:
+        stdout, err = run_git_command(["checkout", "-b", branch_name])
+        if err:
+            return stdout, f"Failed to create branch '{branch_name}': {err}", None
+        return f"Created and switched to new branch: {branch_name}", None, branch_name
+
+
+def get_status() -> tuple[str, str | None]:
+    """Gets repository status using 'git status --short'."""
+    return run_git_command(["status", "--short"])
+
+
+def stage_files(files: list[str] | None = None) -> tuple[str, str | None]:
+    """Stages specified files or all changes if no files are provided."""
+    cmd_args = ["add", "--"] + files if files else ["add", "."]
+    stdout, stderr = run_git_command(cmd_args)
+
+    if stderr:
+        return stdout, f"Error staging files: {stderr}"
+    if not files:
+        return "All changes staged.", None
+    return f"Staged: {', '.join(files)}", None
+
+
+def _explain_pre_commit_failure(error_message: str) -> str:
+    """Provides a basic explanation for common pre-commit errors."""
+    explanation = "Pre-commit hook failed."
+    if "lint" in error_message.lower():
+        explanation += " Linting issues found. Please fix code style."
+    elif (
+        "unstaged" in error_message.lower() or "no changes added to commit" in error_message.lower()
+    ):
+        explanation += " Unstaged changes or no changes added. Stage first."
+    else:
+        explanation += " Check pre-commit scripts and error messages."
+    return explanation
+
+
+def commit_staged_changes(message: str, max_iterations: int = 2) -> tuple[str, str | None]:
+    """Attempts to commit staged changes."""
+    stdout, stderr = run_git_command(["commit", "-m", message])
+
+    if stderr:
+        is_hook_failure = "hook" in stderr.lower() or "failed" in stderr.lower()
+        if is_hook_failure and max_iterations > 1:
+            explanation = _explain_pre_commit_failure(stderr)
+            no_v_stdout, no_v_stderr = run_git_command(["commit", "--no-verify", "-m", message])
+            if no_v_stderr:
+                full_err_msg = (
+                    f"Initial commit failed: {stderr}\n{explanation}\n"
+                    f"Commit with --no-verify also failed: {no_v_stderr}"
+                )
+                return stdout, full_err_msg
+            success_msg = (
+                f"Initial commit failed: {stderr}\n{explanation}\n"
+                f"Successfully committed with --no-verify."
+            )
+            return no_v_stdout or success_msg, None
+        return stdout, stderr
+
+    return stdout or "Changes committed successfully.", None
+
+
+def reset_local_changes() -> tuple[str, str | None]:
+    """Resets uncommitted changes by stashing them."""
+    branch_name, _ = get_current_branch_name()
+    s_branch = _sanitize_branch_name(branch_name or "unknownbranch")
+    proj_id = PROJECT_ROOT.name
+    stash_msg = f"cadecoder-chat-stash/{proj_id}/{s_branch}"
+
+    stdout, stderr = run_git_command(["stash", "push", "-u", "-m", stash_msg])
+
+    if stderr:
+        return stdout, f"Error stashing changes: {stderr}"
+    if "No local changes to save" in stdout:
+        return "No local changes to reset (stash).", None
+    return f"Uncommitted changes stashed: '{stash_msg}'.", None
+
+
+def get_current_branch_name() -> tuple[str, str | None]:
+    """Gets the current active Git branch name."""
+    return run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
+
+
+def reset_chat():
+    """Use git stash to reset changes."""
+    stdout, stderr = run_git_command(["stash"])
+    if stderr:
+        print(f"Error during git stash: {stderr}")
+    else:
+        print("Chat context changes stashed (reset).")
+    return stdout, stderr
+
+
+def clear_chat_context():
+    """Clear current chat context."""
+    print("Chat context cleared (SQLite history preserved).")
+    return "Context cleared"
+
+
+def stage_command(files=None):
+    """Stage files command."""
+    return stage_files(files)
+
+
+def commit_command(message):
+    """Commit command."""
+    return commit_staged_changes(message)