wcgw 3.0.6__py3-none-any.whl → 4.0.0__py3-none-any.whl

wcgw/client/repo_ops/file_stats.py

@@ -0,0 +1,152 @@
+import hashlib
+import json
+import os
+import sys
+from typing import Any, Callable, Dict, TypeVar, cast
+
+T = TypeVar("T")  # Type variable for generic functions
+F = TypeVar("F", bound=Callable[..., Any])  # Type variable for decorated functions
+
+
+class FileStats:
+    """Track read, edit, and write counts for a single file."""
+
+    def __init__(self) -> None:
+        self.read_count: int = 0
+        self.edit_count: int = 0
+        self.write_count: int = 0
+
+    def increment_read(self) -> None:
+        """Increment the read counter."""
+        self.read_count += 1
+
+    def increment_edit(self) -> None:
+        """Increment the edit counter."""
+        self.edit_count += 1
+
+    def increment_write(self) -> None:
+        """Increment the write counter."""
+        self.write_count += 1
+
+    def to_dict(self) -> Dict[str, int]:
+        """Convert to a dictionary for serialization."""
+        return {
+            "read_count": self.read_count,
+            "edit_count": self.edit_count,
+            "write_count": self.write_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FileStats":
+        """Create from a serialized dictionary."""
+        stats = cls()
+        stats.read_count = data.get("read_count", 0)
+        stats.edit_count = data.get("edit_count", 0)
+        stats.write_count = data.get("write_count", 0)
+        return stats
+
+
+class WorkspaceStats:
+    """Track file operations statistics for an entire workspace."""
+
+    def __init__(self) -> None:
+        self.files: Dict[str, FileStats] = {}  # filepath -> FileStats
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to a dictionary for serialization."""
+        return {"files": {k: v.to_dict() for k, v in self.files.items()}}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "WorkspaceStats":
+        """Create from a serialized dictionary."""
+        stats = cls()
+        files_data = data.get("files", {})
+        stats.files = {k: FileStats.from_dict(v) for k, v in files_data.items()}
+        return stats
+
+
+def safe_stats_operation(func: F) -> F:
+    """
+    Decorator to safely perform stats operations without affecting core functionality.
+    If an exception occurs, it logs the error but allows the program to continue.
+    """
+
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            # Log the error but continue with the operation
+            print(f"Warning: Stats tracking error - {e}", file=sys.stderr)
+            return None
+
+    # This is a workaround for proper typing with decorators
+    return cast(F, wrapper)
+
+
+def get_stats_path(workspace_path: str) -> str:
+    """
+    Get the path to the stats file for a workspace using a hash-based approach.
+
+    Args:
+        workspace_path: The full path of the workspace directory.
+
+    Returns:
+        The path to the stats file.
+    """
+    # Normalize the path
+    workspace_path = os.path.normpath(os.path.expanduser(workspace_path))
+
+    # Get the basename of the workspace path for readability
+    workspace_name = os.path.basename(workspace_path)
+    if not workspace_name:  # In case of root directory
+        workspace_name = "root"
+
+    # Create a hash of the full path
+    path_hash = hashlib.md5(workspace_path.encode()).hexdigest()
+
+    # Combine to create a unique identifier that's still somewhat readable
+    filename = f"{workspace_name}_{path_hash}.json"
+
+    # Create directory if it doesn't exist
+    xdg_data_dir = os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share"))
+    stats_dir = os.path.join(xdg_data_dir, "wcgw/workspace_stats")
+    os.makedirs(stats_dir, exist_ok=True)
+
+    return os.path.join(stats_dir, filename)
+
+
+@safe_stats_operation
+def load_workspace_stats(workspace_path: str) -> WorkspaceStats:
+    """
+    Load the stats for a workspace, or create empty stats if not exists.
+
+    Args:
+        workspace_path: The full path of the workspace directory.
+
+    Returns:
+        WorkspaceStats object containing file operation statistics.
+    """
+    stats_path = get_stats_path(workspace_path)
+    if os.path.exists(stats_path):
+        try:
+            with open(stats_path, "r") as f:
+                return WorkspaceStats.from_dict(json.load(f))
+        except (json.JSONDecodeError, KeyError, ValueError):
+            # Handle corrupted file
+            return WorkspaceStats()
+    else:
+        return WorkspaceStats()
+
+
+@safe_stats_operation
+def save_workspace_stats(workspace_path: str, stats: WorkspaceStats) -> None:
+    """
+    Save the stats for a workspace.
+
+    Args:
+        workspace_path: The full path of the workspace directory.
+        stats: WorkspaceStats object to save.
+    """
+    stats_path = get_stats_path(workspace_path)
+    with open(stats_path, "w") as f:
+        json.dump(stats.to_dict(), f, indent=2)

wcgw/client/repo_ops/repo_context.py

@@ -4,8 +4,10 @@ from pathlib import Path  # Still needed for other parts
 from typing import Optional
 
 from pygit2 import GitError, Repository
+from pygit2.enums import SortMode
 
 from .display_tree import DirectoryTree
+from .file_stats import load_workspace_stats
 from .path_prob import FastPathAnalyzer
 
 curr_folder = Path(__file__).parent
@@ -82,19 +84,84 @@ def get_all_files_max_depth(
     return all_files
 
 
+def get_recent_git_files(repo: Repository, count: int = 10) -> list[str]:
+    """
+    Get the most recently modified files from git history
+
+    Args:
+        repo: The git repository
+        count: Number of recent files to return
+
+    Returns:
+        List of relative paths to recently modified files
+    """
+    # Track seen files to avoid duplicates
+    seen_files: set[str] = set()
+    recent_files: list[str] = []
+
+    try:
+        # Get the HEAD reference and walk through recent commits
+        head = repo.head
+        for commit in repo.walk(head.target, SortMode.TOPOLOGICAL | SortMode.TIME):
+            # Skip merge commits which have multiple parents
+            if len(commit.parents) > 1:
+                continue
+
+            # If we have a parent, get the diff between the commit and its parent
+            if commit.parents:
+                parent = commit.parents[0]
+                diff = repo.diff(parent, commit)  # type: ignore[attr-defined]
+            else:
+                # For the first commit, get the diff against an empty tree
+                diff = commit.tree.diff_to_tree(context_lines=0)
+
+            # Process each changed file in the diff
+            for patch in diff:
+                file_path = patch.delta.new_file.path
+
+                # Skip if we've already seen this file or if the file was deleted
+                repo_path_parent = Path(repo.path).parent
+                if (
+                    file_path in seen_files
+                    or not (repo_path_parent / file_path).exists()
+                ):
+                    continue
+
+                seen_files.add(file_path)
+                recent_files.append(file_path)
+
+                # If we have enough files, stop
+                if len(recent_files) >= count:
+                    return recent_files
+
+    except Exception:
+        # Handle git errors gracefully
+        pass
+
+    return recent_files
+
+
 def get_repo_context(file_or_repo_path: str, max_files: int) -> tuple[str, Path]:
     file_or_repo_path_ = Path(file_or_repo_path).absolute()
 
     repo = find_ancestor_with_git(file_or_repo_path_)
+    recent_git_files: list[str] = []
 
+    # Determine the context directory
     if repo is not None:
         context_dir = Path(repo.path).parent
+        # Get recent git files - get at least 50 or the max_files count, whichever is larger
+        recent_files_count = max(10, max_files)
+        recent_git_files = get_recent_git_files(repo, recent_files_count)
     else:
         if file_or_repo_path_.is_file():
             context_dir = file_or_repo_path_.parent
         else:
             context_dir = file_or_repo_path_
 
+    # Load workspace stats from the context directory
+    workspace_stats = load_workspace_stats(str(context_dir))
+
     all_files = get_all_files_max_depth(str(context_dir), 10, repo)
 
     # Calculate probabilities in batch
@@ -106,10 +173,61 @@ def get_repo_context(file_or_repo_path: str, max_files: int) -> tuple[str, Path]
         path for path, _ in sorted(path_with_scores, key=lambda x: x[1], reverse=True)
     ]
 
-    top_files = sorted_files[:max_files]
+    # Start with recent git files, then add other important files
+    top_files = []
+
+    # If we have workspace stats, prioritize the most active files first
+    active_files = []
+    if workspace_stats is not None:
+        # Get files with activity score (weighted count of operations)
+        scored_files = []
+        for file_path, file_stats in workspace_stats.files.items():
+            try:
+                # Convert to relative path if possible
+                if str(context_dir) in file_path:
+                    rel_path = os.path.relpath(file_path, str(context_dir))
+                else:
+                    rel_path = file_path
+
+                # Calculate activity score - weight reads more for this functionality
+                activity_score = (
+                    file_stats.read_count * 2
+                    + (file_stats.edit_count)
+                    + (file_stats.write_count)
+                )
+
+                # Only include files that still exist
+                if rel_path in all_files or os.path.exists(file_path):
+                    scored_files.append((rel_path, activity_score))
+            except (ValueError, OSError):
+                # Skip files that cause path resolution errors
+                continue
+
+        # Sort by activity score (highest first) and get top 5
+        active_files = [
+            f for f, _ in sorted(scored_files, key=lambda x: x[1], reverse=True)[:5]
+        ]
+
+        # Add active files first
+        for file in active_files:
+            if file not in top_files and file in all_files:
+                top_files.append(file)
+
+    # Add recent git files next - these should be prioritized
+    for file in recent_git_files:
+        if file not in top_files and file in all_files:
+            top_files.append(file)
+
+    # Use statistical sorting for the remaining files, but respect max_files limit
+    # and ensure we don't add duplicates
+    if len(top_files) < max_files:
+        # Only add statistically important files that aren't already in top_files
+        for file in sorted_files:
+            if file not in top_files and len(top_files) < max_files:
+                top_files.append(file)
 
     directory_printer = DirectoryTree(context_dir, max_files=max_files)
-    for file in top_files:
+    for file in top_files[:max_files]:
         directory_printer.expand(file)
 
     return directory_printer.display(), context_dir
@@ -127,7 +245,7 @@ if __name__ == "__main__":
     # Profile using cProfile for overall function statistics
     profiler = cProfile.Profile()
     profiler.enable()
-    result = get_repo_context(folder, 200)[0]
+    result = get_repo_context(folder, 50)[0]
     profiler.disable()
 
     # Print cProfile stats
@@ -139,7 +257,7 @@ if __name__ == "__main__":
     # Profile using line_profiler for line-by-line statistics
     lp = LineProfiler()
     lp_wrapper = lp(get_repo_context)
-    lp_wrapper(folder, 200)
+    lp_wrapper(folder, 50)
 
     print("\n=== Line-by-line profiling ===")
     lp.print_stats()

wcgw/client/tool_prompts.py

@@ -5,11 +5,10 @@ from typing import Any
 from ..types_ import (
     BashCommand,
     ContextSave,
-    FileEdit,
+    FileWriteOrEdit,
     Initialize,
     ReadFiles,
     ReadImage,
-    WriteIfEmpty,
 )
 
 with open(os.path.join(os.path.dirname(__file__), "diff-instructions.txt")) as f:
@@ -62,15 +61,9 @@ TOOL_PROMPTS = [
         description="""
 - Read full file content of one or more files.
 - Provide absolute paths only (~ allowed)
-""",
-    ),
-    Prompts(
-        inputSchema=WriteIfEmpty.model_json_schema(),
-        name="WriteIfEmpty",
-        description="""
-- Write content to an empty or non-existent file. Provide file path and content. Use this instead of BashCommand for writing new files.
-- Provide absolute path only.
-- For editing existing files, use FileEdit instead of this tool.
+- Only if the task requires line numbers understanding:
+    - You may populate "show_line_numbers_reason" with your reason, by default null/empty means no line numbers are shown.
+    - You may extract a range of lines. E.g., `/path/to/file:1-10` for lines 1-10. You can drop start or end like `/path/to/file:1-` or `/path/to/file:-10` 
 """,
     ),
     Prompts(
@@ -79,12 +72,16 @@ TOOL_PROMPTS = [
         description="Read an image from the shell.",
     ),
     Prompts(
-        inputSchema=FileEdit.model_json_schema(),
-        name="FileEdit",
+        inputSchema=FileWriteOrEdit.model_json_schema(),
+        name="FileWriteOrEdit",
         description="""
-- Use absolute path only.
-- Use SEARCH/REPLACE blocks to edit the file.
-- If the edit fails due to block not matching, please retry with correct block till it matches. Re-read the file to ensure you've all the lines correct.
+- Writes or edits a file based on the percentage of changes.
+- Use absolute path only (~ allowed).
+- First write down percentage of lines that need to be replaced in the file (between 0-100) in percentage_to_change
+- percentage_to_change should be low if mostly new code is to be added. It should be high if a lot of things are to be replaced.
+- If percentage_to_change > 50, provide full file content in file_content_or_search_replace_blocks
+- If percentage_to_change <= 50, file_content_or_search_replace_blocks should be search/replace blocks.
+
 """
         + diffinstructions,
     ),