aider-ce 0.88.20__py3-none-any.whl

aider/sessions.py

@@ -0,0 +1,256 @@
+"""Session management utilities for Aider."""
+
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from aider import models
+
+
+class SessionManager:
+    """Manages chat session saving, listing, and loading."""
+
+    def __init__(self, coder, io):
+        self.coder = coder
+        self.io = io
+
+    def _get_session_directory(self) -> Path:
+        """Get the session directory, creating it if necessary."""
+        session_dir = Path(self.coder.abs_root_path(".aider/sessions"))
+        os.makedirs(session_dir, exist_ok=True)
+        return session_dir
+
+    def save_session(self, session_name: str, output=True) -> bool:
+        """Save the current chat session to a named file."""
+        if not session_name:
+            if output:
+                self.io.tool_error("Please provide a session name.")
+            return False
+
+        session_name = session_name.replace(".json", "")
+        session_dir = self._get_session_directory()
+        session_file = session_dir / f"{session_name}.json"
+
+        if session_file.exists():
+            if output:
+                self.io.tool_warning(f"Session '{session_name}' already exists. Overwriting.")
+
+        try:
+            session_data = self._build_session_data(session_name)
+            with open(session_file, "w", encoding="utf-8") as f:
+                json.dump(session_data, f, indent=2)
+
+            if output:
+                self.io.tool_output(f"Session saved: {session_file}")
+
+            return True
+
+        except Exception as e:
+            self.io.tool_error(f"Error saving session: {e}")
+            return False
+
+    def list_sessions(self) -> List[Dict]:
+        """List all saved sessions with metadata."""
+        session_dir = self._get_session_directory()
+        session_files = list(session_dir.glob("*.json"))
+
+        if not session_files:
+            self.io.tool_output("No saved sessions found.")
+            return []
+
+        sessions = []
+        for session_file in sorted(session_files, key=lambda x: x.stat().st_mtime, reverse=True):
+            try:
+                with open(session_file, "r", encoding="utf-8") as f:
+                    session_data = json.load(f)
+
+                session_info = {
+                    "name": session_file.stem,
+                    "file": session_file,
+                    "model": session_data.get("model", "unknown"),
+                    "edit_format": session_data.get("edit_format", "unknown"),
+                    "num_messages": len(
+                        session_data.get("chat_history", {}).get("done_messages", [])
+                    ) + len(session_data.get("chat_history", {}).get("cur_messages", [])),
+                    "num_files": (
+                        len(session_data.get("files", {}).get("editable", []))
+                        + len(session_data.get("files", {}).get("read_only", []))
+                        + len(session_data.get("files", {}).get("read_only_stubs", []))
+                    ),
+                }
+                sessions.append(session_info)
+
+            except Exception as e:
+                self.io.tool_output(f"  {session_file.stem} [error reading: {e}]")
+
+        return sessions
+
+    def load_session(self, session_identifier: str) -> bool:
+        """Load a saved session by name or file path."""
+        if not session_identifier:
+            self.io.tool_error("Please provide a session name or file path.")
+            return False
+
+        # Try to find the session file
+        session_file = self._find_session_file(session_identifier)
+        if not session_file:
+            return False
+
+        try:
+            with open(session_file, "r", encoding="utf-8") as f:
+                session_data = json.load(f)
+        except Exception as e:
+            self.io.tool_error(f"Error loading session: {e}")
+            return False
+
+        # Verify session format
+        if not isinstance(session_data, dict) or "version" not in session_data:
+            self.io.tool_error("Invalid session format.")
+            return False
+
+        # Apply session data
+        return self._apply_session_data(session_data, session_file)
+
+    def _build_session_data(self, session_name) -> Dict:
+        """Build session data dictionary from current coder state."""
+        # Get relative paths for all files
+        editable_files = [
+            self.coder.get_rel_fname(abs_fname) for abs_fname in self.coder.abs_fnames
+        ]
+        read_only_files = [
+            self.coder.get_rel_fname(abs_fname) for abs_fname in self.coder.abs_read_only_fnames
+        ]
+        read_only_stubs_files = [
+            self.coder.get_rel_fname(abs_fname)
+            for abs_fname in self.coder.abs_read_only_stubs_fnames
+        ]
+
+        return {
+            "version": 1,
+            "session_name": session_name,
+            "model": self.coder.main_model.name,
+            "weak_model": self.coder.main_model.weak_model.name,
+            "editor_model": self.coder.main_model.editor_model.name,
+            "editor_edit_format": self.coder.main_model.editor_edit_format,
+            "edit_format": self.coder.edit_format,
+            "chat_history": {
+                "done_messages": self.coder.done_messages,
+                "cur_messages": self.coder.cur_messages,
+            },
+            "files": {
+                "editable": editable_files,
+                "read_only": read_only_files,
+                "read_only_stubs": read_only_stubs_files,
+            },
+            "settings": {
+                "auto_commits": self.coder.auto_commits,
+                "auto_lint": self.coder.auto_lint,
+                "auto_test": self.coder.auto_test,
+            },
+        }
+
+    def _find_session_file(self, session_identifier: str) -> Optional[Path]:
+        """Find session file by name or path."""
+        # Check if it's a direct file path
+        session_file = Path(session_identifier)
+        if session_file.exists():
+            return session_file
+
+        # Check if it's a session name in the sessions directory
+        session_dir = self._get_session_directory()
+
+        # Try with .json extension
+        if not session_identifier.endswith(".json"):
+            session_file = session_dir / f"{session_identifier}.json"
+            if session_file.exists():
+                return session_file
+
+        session_file = session_dir / f"{session_identifier}"
+        if session_file.exists():
+            return session_file
+
+        self.io.tool_error(f"Session not found: {session_identifier}")
+        self.io.tool_output("Use /list-sessions to see available sessions.")
+        return None
+
+    def _apply_session_data(self, session_data: Dict, session_file: Path) -> bool:
+        """Apply session data to current coder state."""
+        try:
+            # Clear current state
+            self.coder.abs_fnames = set()
+            self.coder.abs_read_only_fnames = set()
+            self.coder.abs_read_only_stubs_fnames = set()
+            self.coder.done_messages = []
+            self.coder.cur_messages = []
+
+            # Load chat history
+            chat_history = session_data.get("chat_history", {})
+            self.coder.done_messages = chat_history.get("done_messages", [])
+            self.coder.cur_messages = chat_history.get("cur_messages", [])
+
+            # Load files
+            files = session_data.get("files", {})
+            for rel_fname in files.get("editable", []):
+                abs_fname = self.coder.abs_root_path(rel_fname)
+                if os.path.exists(abs_fname):
+                    self.coder.abs_fnames.add(abs_fname)
+                else:
+                    self.io.tool_warning(f"File not found, skipping: {rel_fname}")
+
+            for rel_fname in files.get("read_only", []):
+                abs_fname = self.coder.abs_root_path(rel_fname)
+                if os.path.exists(abs_fname):
+                    self.coder.abs_read_only_fnames.add(abs_fname)
+                else:
+                    self.io.tool_warning(f"File not found, skipping: {rel_fname}")
+
+            for rel_fname in files.get("read_only_stubs", []):
+                abs_fname = self.coder.abs_root_path(rel_fname)
+                if os.path.exists(abs_fname):
+                    self.coder.abs_read_only_stubs_fnames.add(abs_fname)
+                else:
+                    self.io.tool_warning(f"File not found, skipping: {rel_fname}")
+
+            if session_data.get("model"):
+                self.coder.main_model = models.Model(
+                    session_data.get("model", self.coder.args.model),
+                    weak_model=session_data.get("weak_model", self.coder.args.weak_model),
+                    editor_model=session_data.get("editor_model", self.coder.args.editor_model),
+                    editor_edit_format=session_data.get(
+                        "editor_edit_format", self.coder.args.editor_edit_format
+                    ),
+                    verbose=self.coder.args.verbose,
+                )
+
+            # Load settings
+            settings = session_data.get("settings", {})
+            if "auto_commits" in settings:
+                self.coder.auto_commits = settings["auto_commits"]
+            if "auto_lint" in settings:
+                self.coder.auto_lint = settings["auto_lint"]
+            if "auto_test" in settings:
+                self.coder.auto_test = settings["auto_test"]
+
+            self.io.tool_output(
+                f"Session loaded: {session_data.get('session_name', session_file.stem)}"
+            )
+            self.io.tool_output(
+                f"Model: {session_data.get('model', 'unknown')}, Edit format:"
+                f" {session_data.get('edit_format', 'unknown')}"
+            )
+
+            # Show summary
+            num_messages = len(self.coder.done_messages) + len(self.coder.cur_messages)
+            num_files = (
+                len(self.coder.abs_fnames)
+                + len(self.coder.abs_read_only_fnames)
+                + len(self.coder.abs_read_only_stubs_fnames)
+            )
+            self.io.tool_output(f"Loaded {num_messages} messages and {num_files} files")
+
+            return True
+
+        except Exception as e:
+            self.io.tool_error(f"Error applying session data: {e}")
+            return False

aider/special.py

@@ -0,0 +1,203 @@
+import os
+
+ROOT_IMPORTANT_FILES = [
+    # Version Control
+    ".gitignore",
+    ".gitattributes",
+    # Documentation
+    "README",
+    "README.md",
+    "README.txt",
+    "README.rst",
+    "CONTRIBUTING",
+    "CONTRIBUTING.md",
+    "CONTRIBUTING.txt",
+    "CONTRIBUTING.rst",
+    "LICENSE",
+    "LICENSE.md",
+    "LICENSE.txt",
+    "CHANGELOG",
+    "CHANGELOG.md",
+    "CHANGELOG.txt",
+    "CHANGELOG.rst",
+    "SECURITY",
+    "SECURITY.md",
+    "SECURITY.txt",
+    "CODEOWNERS",
+    # Package Management and Dependencies
+    "requirements.txt",
+    "Pipfile",
+    "Pipfile.lock",
+    "pyproject.toml",
+    "setup.py",
+    "setup.cfg",
+    "package.json",
+    "package-lock.json",
+    "yarn.lock",
+    "npm-shrinkwrap.json",
+    "Gemfile",
+    "Gemfile.lock",
+    "composer.json",
+    "composer.lock",
+    "pom.xml",
+    "build.gradle",
+    "build.gradle.kts",
+    "build.sbt",
+    "go.mod",
+    "go.sum",
+    "Cargo.toml",
+    "Cargo.lock",
+    "mix.exs",
+    "rebar.config",
+    "project.clj",
+    "Podfile",
+    "Cartfile",
+    "dub.json",
+    "dub.sdl",
+    # Configuration and Settings
+    ".env",
+    ".env.example",
+    ".editorconfig",
+    "tsconfig.json",
+    "jsconfig.json",
+    ".babelrc",
+    "babel.config.js",
+    ".eslintrc",
+    ".eslintignore",
+    ".prettierrc",
+    ".stylelintrc",
+    "tslint.json",
+    ".pylintrc",
+    ".flake8",
+    ".rubocop.yml",
+    ".scalafmt.conf",
+    ".dockerignore",
+    ".gitpod.yml",
+    "sonar-project.properties",
+    "renovate.json",
+    "dependabot.yml",
+    ".pre-commit-config.yaml",
+    "mypy.ini",
+    "tox.ini",
+    ".yamllint",
+    "pyrightconfig.json",
+    # Build and Compilation
+    "webpack.config.js",
+    "rollup.config.js",
+    "parcel.config.js",
+    "gulpfile.js",
+    "Gruntfile.js",
+    "build.xml",
+    "build.boot",
+    "project.json",
+    "build.cake",
+    "MANIFEST.in",
+    # Testing
+    "pytest.ini",
+    "phpunit.xml",
+    "karma.conf.js",
+    "jest.config.js",
+    "cypress.json",
+    ".nycrc",
+    ".nycrc.json",
+    # CI/CD
+    ".travis.yml",
+    ".gitlab-ci.yml",
+    "Jenkinsfile",
+    "azure-pipelines.yml",
+    "bitbucket-pipelines.yml",
+    "appveyor.yml",
+    "circle.yml",
+    ".circleci/config.yml",
+    ".github/dependabot.yml",
+    "codecov.yml",
+    ".coveragerc",
+    # Docker and Containers
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.override.yml",
+    # Cloud and Serverless
+    "serverless.yml",
+    "firebase.json",
+    "now.json",
+    "netlify.toml",
+    "vercel.json",
+    "app.yaml",
+    "terraform.tf",
+    "main.tf",
+    "cloudformation.yaml",
+    "cloudformation.json",
+    "ansible.cfg",
+    "kubernetes.yaml",
+    "k8s.yaml",
+    # Database
+    "schema.sql",
+    "liquibase.properties",
+    "flyway.conf",
+    # Framework-specific
+    "next.config.js",
+    "nuxt.config.js",
+    "vue.config.js",
+    "angular.json",
+    "gatsby-config.js",
+    "gridsome.config.js",
+    # API Documentation
+    "swagger.yaml",
+    "swagger.json",
+    "openapi.yaml",
+    "openapi.json",
+    # Development environment
+    ".nvmrc",
+    ".ruby-version",
+    ".python-version",
+    "Vagrantfile",
+    # Quality and metrics
+    ".codeclimate.yml",
+    "codecov.yml",
+    # Documentation
+    "mkdocs.yml",
+    "_config.yml",
+    "book.toml",
+    "readthedocs.yml",
+    ".readthedocs.yaml",
+    # Package registries
+    ".npmrc",
+    ".yarnrc",
+    # Linting and formatting
+    ".isort.cfg",
+    ".markdownlint.json",
+    ".markdownlint.yaml",
+    # Security
+    ".bandit",
+    ".secrets.baseline",
+    # Misc
+    ".pypirc",
+    ".gitkeep",
+    ".npmignore",
+]
+
+
+# Normalize the lists once
+NORMALIZED_ROOT_IMPORTANT_FILES = set(os.path.normpath(path) for path in ROOT_IMPORTANT_FILES)
+
+
+def is_important(file_path):
+    file_name = os.path.basename(file_path)
+    dir_name = os.path.normpath(os.path.dirname(file_path))
+    normalized_path = os.path.normpath(file_path)
+
+    # Check for GitHub Actions workflow files
+    if dir_name == os.path.normpath(".github/workflows") and file_name.endswith(".yml"):
+        return True
+
+    return normalized_path in NORMALIZED_ROOT_IMPORTANT_FILES
+
+
+def filter_important_files(file_paths):
+    """
+    Filter a list of file paths to return only those that are commonly important in codebases.
+
+    :param file_paths: List of file paths to check
+    :return: List of file paths that match important file patterns
+    """
+    return list(filter(is_important, file_paths))

aider/tools/__init__.py

@@ -0,0 +1,72 @@
+# flake8: noqa: F401
+# Import tool modules into the aider.tools namespace
+
+# Import all tool modules
+from . import (
+    command,
+    command_interactive,
+    delete_block,
+    delete_line,
+    delete_lines,
+    extract_lines,
+    finished,
+    git_branch,
+    git_diff,
+    git_log,
+    git_remote,
+    git_show,
+    git_status,
+    grep,
+    indent_lines,
+    insert_block,
+    list_changes,
+    ls,
+    make_editable,
+    make_readonly,
+    remove,
+    replace_all,
+    replace_line,
+    replace_lines,
+    replace_text,
+    show_numbered_context,
+    undo_change,
+    update_todo_list,
+    view,
+    view_files_matching,
+    view_files_with_symbol,
+)
+
+# List of all available tool modules for dynamic discovery
+TOOL_MODULES = [
+    command,
+    command_interactive,
+    delete_block,
+    delete_line,
+    delete_lines,
+    extract_lines,
+    finished,
+    git_branch,
+    git_diff,
+    git_log,
+    git_remote,
+    git_show,
+    git_status,
+    grep,
+    indent_lines,
+    insert_block,
+    list_changes,
+    ls,
+    make_editable,
+    make_readonly,
+    remove,
+    replace_all,
+    replace_line,
+    replace_lines,
+    replace_text,
+    show_numbered_context,
+    undo_change,
+    update_todo_list,
+    view,
+    view_files_matching,
+    view_files_with_symbol,
+]

aider/tools/command.py

@@ -0,0 +1,105 @@
+# Import necessary functions
+from aider.run_cmd import run_cmd_subprocess
+
+schema = {
+    "type": "function",
+    "function": {
+        "name": "Command",
+        "description": "Execute a shell command.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command_string": {
+                    "type": "string",
+                    "description": "The shell command to execute.",
+                },
+            },
+            "required": ["command_string"],
+        },
+    },
+}
+
+# Normalized tool name for lookup
+NORM_NAME = "command"
+
+
+async def _execute_command(coder, command_string):
+    """
+    Execute a non-interactive shell command after user confirmation.
+    """
+    try:
+        # Ask for confirmation before executing.
+        # allow_never=True enables the 'Always' option.
+        # confirm_ask handles remembering the 'Always' choice based on the subject.
+
+        confirmed = (
+            True
+            if coder.skip_cli_confirmations
+            else await coder.io.confirm_ask(
+                "Allow execution of this command?",
+                subject=command_string,
+                explicit_yes_required=True,  # Require explicit 'yes' or 'always'
+                allow_never=True,  # Enable the 'Always' option
+                group_response="Command Tool",
+            )
+        )
+
+        await coder.io.recreate_input()
+
+        if not confirmed:
+            # This happens if the user explicitly says 'no' this time.
+            # If 'Always' was chosen previously, confirm_ask returns True directly.
+            coder.io.tool_output(f"Skipped execution of shell command: {command_string}")
+            return "Shell command execution skipped by user."
+
+        # Proceed with execution if confirmed is True
+        coder.io.tool_output(f"⚙️ Executing non-interactive shell command: {command_string}")
+
+        # Use run_cmd_subprocess for non-interactive execution
+        exit_status, combined_output = run_cmd_subprocess(
+            command_string, verbose=coder.verbose, cwd=coder.root  # Execute in the project root
+        )
+
+        # Format the output for the result message, include more content
+        output_content = combined_output or ""
+        # Use the existing token threshold constant as the character limit for truncation
+        output_limit = coder.large_file_token_threshold
+        if len(output_content) > output_limit:
+            # Truncate and add a clear message using the constant value
+            output_content = (
+                output_content[:output_limit]
+                + f"\n... (output truncated at {output_limit} characters, based on"
+                " large_file_token_threshold)"
+            )
+
+        if exit_status == 0:
+            return f"Shell command executed successfully (exit code 0). Output:\n{output_content}"
+        else:
+            return f"Shell command failed with exit code {exit_status}. Output:\n{output_content}"
+
+    except Exception as e:
+        coder.io.tool_error(
+            f"Error executing non-interactive shell command '{command_string}': {str(e)}"
+        )
+        # Optionally include traceback for debugging if verbose
+        # if coder.verbose:
+        #     coder.io.tool_error(traceback.format_exc())
+        return f"Error executing command: {str(e)}"
+
+
+async def process_response(coder, params):
+    """
+    Process the Command tool response.
+
+    Args:
+        coder: The Coder instance
+        params: Dictionary of parameters
+
+    Returns:
+        str: Result message
+    """
+    command_string = params.get("command_string")
+    if command_string is not None:
+        return await _execute_command(coder, command_string)
+    else:
+        return "Error: Missing 'command_string' parameter for Command"