wcgw 5.5.4__py3-none-any.whl

wcgw/client/modes.py

@@ -0,0 +1,240 @@
+from dataclasses import dataclass
+from typing import Any, Literal, NamedTuple
+
+from ..types_ import Modes, ModesConfig
+
+
+class BashCommandMode(NamedTuple):
+    bash_mode: Literal["normal_mode", "restricted_mode"]
+    allowed_commands: Literal["all", "none"]
+
+    def serialize(self) -> dict[str, Any]:
+        return {"bash_mode": self.bash_mode, "allowed_commands": self.allowed_commands}
+
+    @classmethod
+    def deserialize(cls, data: dict[str, Any]) -> "BashCommandMode":
+        return cls(data["bash_mode"], data["allowed_commands"])
+
+
+class FileEditMode(NamedTuple):
+    allowed_globs: Literal["all"] | list[str]
+
+    def serialize(self) -> dict[str, Any]:
+        return {"allowed_globs": self.allowed_globs}
+
+    @classmethod
+    def deserialize(cls, data: dict[str, Any]) -> "FileEditMode":
+        return cls(data["allowed_globs"])
+
+
+class WriteIfEmptyMode(NamedTuple):
+    allowed_globs: Literal["all"] | list[str]
+
+    def serialize(self) -> dict[str, Any]:
+        return {"allowed_globs": self.allowed_globs}
+
+    @classmethod
+    def deserialize(cls, data: dict[str, Any]) -> "WriteIfEmptyMode":
+        return cls(data["allowed_globs"])
+
+
+@dataclass
+class ModeImpl:
+    bash_command_mode: BashCommandMode
+    file_edit_mode: FileEditMode
+    write_if_empty_mode: WriteIfEmptyMode
+
+
+def code_writer_prompt(
+    allowed_file_edit_globs: Literal["all"] | list[str],
+    all_write_new_globs: Literal["all"] | list[str],
+    allowed_commands: Literal["all"] | list[str],
+) -> str:
+    base = """
+You are now running in "code_writer" mode.
+"""
+
+    path_prompt = """
+    - You are allowed to edit files in the provided repository only.
+    """
+
+    if allowed_file_edit_globs != "all":
+        if allowed_file_edit_globs:
+            path_prompt = f"""
+    - You are allowed to edit files for files matching only the following globs: {", ".join(allowed_file_edit_globs)}
+"""
+        else:
+            path_prompt = """
+    - You are not allowed to edit files.
+"""
+    base += path_prompt
+
+    path_prompt = """
+    - You are allowed to write files in the provided repository only.
+    """
+
+    if all_write_new_globs != "all":
+        if all_write_new_globs:
+            path_prompt = f"""
+    - You are allowed to write files files matching only the following globs: {", ".join(allowed_file_edit_globs)}
+"""
+        else:
+            path_prompt = """
+    - You are not allowed to write files.
+"""
+    base += path_prompt
+
+    run_command_common = """
+    - Do not use Ctrl-c interrupt commands without asking the user, because often the programs don't show any update but they still are running.
+    - Do not use echo/cat to write any file, always use FileWriteOrEdit tool to create/update files.
+    - Do not provide code snippets unless asked by the user, instead directly add/edit the code.
+    - You should use the provided bash execution, reading and writing file tools to complete objective.
+    - Do not use artifacts if you have access to the repository and not asked by the user to provide artifacts/snippets. Directly create/update using wcgw tools.
+"""
+
+    command_prompt = f"""
+    - You are only allowed to run commands for project setup, code writing, editing, updating, testing, running and debugging related to the project.
+    - Do not run anything that adds or removes packages, changes system configuration or environment.
+{run_command_common}
+"""
+    if allowed_commands != "all":
+        if allowed_commands:
+            command_prompt = f"""
+    - You are only allowed to run the following commands: {", ".join(allowed_commands)}
+{run_command_common}
+"""
+        else:
+            command_prompt = """
+    - You are not allowed to run any commands.
+"""
+
+    base += command_prompt
+    return base
+
+
+WCGW_PROMPT = """
+# Instructions
+
+    - You should use the provided bash execution, reading and writing file tools to complete objective.
+    - Do not provide code snippets unless asked by the user, instead directly add/edit the code.
+    - Do not install new tools/packages before ensuring no such tools/package or an alternative already exists.
+    - Do not use artifacts if you have access to the repository and not asked by the user to provide artifacts/snippets. Directly create/update using wcgw tools
+    - Do not use Ctrl-c or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
+    - Do not use echo/cat to write any file, always use FileWriteOrEdit tool to create/update files.
+    - You can share task summary directly without creating any file.
+    - Provide as many file paths as you need in ReadFiles in one go.
+
+Additional instructions:
+    Always run `pwd` if you get any file or directory not found error to make sure you're not lost, or to get absolute cwd.
+
+
+"""
+ARCHITECT_PROMPT = """
+# Instructions
+You are now running in "architect" mode. This means
+- You are not allowed to edit or update any file. You are not allowed to create any file. 
+- You are not allowed to run any commands that may change disk, system configuration, packages or environment. Only read-only commands are allowed.
+- Only run commands that allows you to explore the repository, understand the system or read anything of relevance. 
+- Do not use Ctrl-c or interrupt commands without asking the user, because often the programs don't show any update but they still are running.
+- You are not allowed to change directory (bash will run in -r mode)
+- Share only snippets when any implementation is requested.
+- Provide as many file paths as you need in ReadFiles in one go.
+
+# Disallowed tools (important!)
+- FileWriteOrEdit
+
+# Response instructions
+Respond only after doing the following:
+- Read as many relevant files as possible. 
+- Be comprehensive in your understanding and search of relevant files.
+- First understand about the project by getting the folder structure (ignoring .git, node_modules, venv, etc.)
+- Share minimal snippets higlighting the changes (avoid large number of lines in the snippets, use ... comments)
+"""
+
+
+DEFAULT_MODES: dict[Modes, ModeImpl] = {
+    "wcgw": ModeImpl(
+        bash_command_mode=BashCommandMode("normal_mode", "all"),
+        write_if_empty_mode=WriteIfEmptyMode("all"),
+        file_edit_mode=FileEditMode("all"),
+    ),
+    "architect": ModeImpl(
+        bash_command_mode=BashCommandMode("restricted_mode", "all"),
+        write_if_empty_mode=WriteIfEmptyMode([]),
+        file_edit_mode=FileEditMode([]),
+    ),
+    "code_writer": ModeImpl(
+        bash_command_mode=BashCommandMode("normal_mode", "all"),
+        write_if_empty_mode=WriteIfEmptyMode("all"),
+        file_edit_mode=FileEditMode("all"),
+    ),
+}
+
+
+def modes_to_state(
+    mode: ModesConfig,
+) -> tuple[BashCommandMode, FileEditMode, WriteIfEmptyMode, Modes]:
+    # First get default mode config
+    if isinstance(mode, str):
+        mode_impl = DEFAULT_MODES[mode]  # converts str to Modes enum
+        mode_name: Modes = mode
+    else:
+        # For CodeWriterMode, use code_writer as base and override
+        mode_impl = DEFAULT_MODES["code_writer"]
+        # Override with custom settings from CodeWriterMode
+        mode_impl = ModeImpl(
+            bash_command_mode=BashCommandMode(
+                mode_impl.bash_command_mode.bash_mode,
+                "all" if mode.allowed_commands else "none",
+            ),
+            file_edit_mode=FileEditMode(mode.allowed_globs),
+            write_if_empty_mode=WriteIfEmptyMode(mode.allowed_globs),
+        )
+        mode_name = "code_writer"
+    return (
+        mode_impl.bash_command_mode,
+        mode_impl.file_edit_mode,
+        mode_impl.write_if_empty_mode,
+        mode_name,
+    )
+
+
+WCGW_KT = """Use `ContextSave` tool to do a knowledge transfer of the task in hand.
+Write detailed description in order to do a KT.
+Save all information necessary for a person to understand the task and the problems.
+
+Format the `description` field using Markdown with the following sections.
+- "# Objective" section containing project and task objective.
+- "# All user instructions" section should be provided containing all instructions user shared in the conversation.
+- "# Current status of the task" should be provided containing only what is already achieved, not what's remaining.
+- "# Pending issues with snippets" section containing snippets of pending errors, traceback, file snippets, commands, etc. But no comments or solutions.
+- Be very verbose in the all issues with snippets section providing as much error context as possible.
+- "# Build and development instructions" section containing instructions to build or run project or run tests, or envrionment related information. Only include what's known. Leave empty if unknown.
+- Any other relevant sections following the above.
+- After the tool completes succesfully, tell me the task id and the file path the tool generated (important!)
+- This tool marks end of your conversation, do not run any further tools after calling this.
+
+Provide all relevant file paths in order to understand and solve the the task. Err towards providing more file paths than fewer.
+
+(Note to self: this conversation can then be resumed later asking "Resume wcgw task `<generated id>`" which should call Initialize tool)
+"""
+
+
+ARCHITECT_KT = """Use `ContextSave` tool to do a knowledge transfer of the task in hand.
+Write detailed description in order to do a KT.
+Save all information necessary for a person to understand the task and the problems.
+
+Format the `description` field using Markdown with the following sections.
+- "# Objective" section containing project and task objective.
+- "# All user instructions" section should be provided containing all instructions user shared in the conversation.
+- "# Designed plan" should be provided containing the designed plan as discussed.
+- Any other relevant sections following the above.
+- After the tool completes succesfully, tell me the task id and the file path the tool generated (important!)
+- This tool marks end of your conversation, do not run any further tools after calling this.
+
+Provide all relevant file paths in order to understand and solve the the task. Err towards providing more file paths than fewer.
+
+(Note to self: this conversation can then be resumed later asking "Resume wcgw task `<generated id>`" which should call Initialize tool)
+"""
+
+KTS = {"wcgw": WCGW_KT, "architect": ARCHITECT_KT, "code_writer": WCGW_KT}

wcgw/client/repo_ops/display_tree.py

@@ -0,0 +1,116 @@
+import io
+from pathlib import Path
+from typing import List, Set
+
+
+class DirectoryTree:
+    def __init__(self, root: Path, max_files: int = 10):
+        """
+        Initialize the DirectoryTree with a root path and maximum number of files to display
+
+        Args:
+            root_path: The root directory path to start from
+            max_files: Maximum number of files to display in unexpanded directories
+        """
+        self.root = root
+        self.max_files = max_files
+        self.expanded_files: Set[Path] = set()
+        self.expanded_dirs: Set[Path] = set()
+
+        if not self.root.exists():
+            raise ValueError(f"Root path {root} does not exist")
+
+        if not self.root.is_dir():
+            raise ValueError(f"Root path {root} is not a directory")
+
+    def expand(self, rel_path: str) -> None:
+        """
+        Expand a specific file in the tree
+
+        Args:
+            rel_path: Relative path from root to the file to expand
+        """
+        abs_path = self.root / rel_path
+
+        if not abs_path.exists():
+            return
+
+        if not abs_path.is_file():
+            return
+
+        if not str(abs_path).startswith(str(self.root)):
+            return
+
+        self.expanded_files.add(abs_path)
+
+        # Add all parent directories to expanded dirs
+        current = abs_path.parent
+        while str(current) >= str(self.root):
+            if current not in self.expanded_dirs:
+                self.expanded_dirs.add(current)
+            if current == current.parent:
+                break
+            current = current.parent
+
+    def _list_directory(self, dir_path: Path) -> List[Path]:
+        """List contents of a directory, sorted with directories first"""
+        contents = list(dir_path.iterdir())
+        return sorted(contents, key=lambda x: (not x.is_dir(), x.name.lower()))
+
+    def _count_hidden_items(
+        self, dir_path: Path, shown_items: List[Path]
+    ) -> tuple[int, int]:
+        """Count hidden files and directories in a directory"""
+        all_items = set(self._list_directory(dir_path))
+        shown_items_set = set(shown_items)
+        hidden_items = all_items - shown_items_set
+
+        hidden_files = sum(1 for p in hidden_items if p.is_file())
+        hidden_dirs = sum(1 for p in hidden_items if p.is_dir())
+
+        return hidden_files, hidden_dirs
+
+    def display(self) -> str:
+        """Display the directory tree with expanded state"""
+        writer = io.StringIO()
+
+        def _display_recursive(
+            current_path: Path, indent: int = 0, depth: int = 0
+        ) -> None:
+            # Print current directory name with a trailing slash for directories
+            if current_path == self.root:
+                writer.write(f"{current_path}/\n")
+            else:
+                writer.write(f"{' ' * indent}{current_path.name}/\n")
+
+            # Don't recurse beyond depth 1 unless path contains expanded files
+            if depth > 0 and current_path not in self.expanded_dirs:
+                return
+
+            # Get directory contents
+            contents = self._list_directory(current_path)
+            shown_items = []
+
+            for item in contents:
+                # Show items only if:
+                # 1. They are expanded files
+                # 2. They are parents of expanded items
+                should_show = item in self.expanded_files or item in self.expanded_dirs
+
+                if should_show:
+                    shown_items.append(item)
+                    if item.is_dir():
+                        _display_recursive(item, indent + 2, depth + 1)
+                    else:
+                        writer.write(f"{' ' * (indent + 2)}{item.name}\n")
+
+            # Show hidden items count if any items were hidden
+            hidden_files, hidden_dirs = self._count_hidden_items(
+                current_path, shown_items
+            )
+            if hidden_files > 0 or hidden_dirs > 0:
+                writer.write(f"{' ' * (indent + 2)}...\n")
+
+        _display_recursive(self.root, depth=0)
+
+        return writer.getvalue()

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/path_prob.py

@@ -0,0 +1,58 @@
+from typing import Dict, List, Tuple
+
+import tokenizers  # type: ignore[import-untyped]
+
+
+class FastPathAnalyzer:
+    def __init__(self, model_path: str, vocab_path: str) -> None:
+        """Initialize with vocabulary."""
+        # Load vocabulary and probabilities
+        self.vocab_probs: Dict[str, float] = {}
+        with open(vocab_path, "r") as f:
+            for line in f:
+                parts = line.strip().split()
+                if len(parts) == 2:
+                    token, prob = parts
+                    try:
+                        self.vocab_probs[token] = float(prob)
+                    except ValueError:
+                        continue
+
+        self.encoder = tokenizers.Tokenizer.from_file(model_path)
+
+    def tokenize_batch(self, texts: List[str]) -> List[List[str]]:
+        """Tokenize multiple texts at once."""
+        encodings = self.encoder.encode_batch(texts)
+        return [encoding.tokens for encoding in encodings]
+
+    def detokenize(self, tokens: List[str]) -> str:
+        """Convert tokens back to text, handling special tokens."""
+        return self.encoder.decode(tokens)  # type: ignore[no-any-return]
+
+    def calculate_path_probabilities_batch(
+        self, paths: List[str]
+    ) -> List[Tuple[float, List[str], List[str]]]:
+        """Calculate log probability for multiple paths at once."""
+        # Batch tokenize all paths
+        all_tokens = self.tokenize_batch(paths)
+
+        results = []
+        for tokens in all_tokens:
+            # Calculate sum of log probabilities for each path
+            log_prob_sum = 0.0
+            unknown_tokens = []
+            for token in tokens:
+                if token in self.vocab_probs:
+                    log_prob_sum += self.vocab_probs[token]
+                else:
+                    unknown_tokens.append(token)
+
+            results.append((log_prob_sum, tokens, unknown_tokens))
+
+        return results
+
+    def calculate_path_probability(
+        self, path: str
+    ) -> Tuple[float, List[str], List[str]]:
+        """Calculate log probability for a single path."""
+        return self.calculate_path_probabilities_batch([path])[0]