cecli-dev 0.95.5__py3-none-any.whl

cecli/commands/utils/save_load_manager.py

@@ -0,0 +1,98 @@
+import os
+from pathlib import Path
+from typing import List
+
+
+class SaveLoadManager:
+    """Manager for saving and loading command files."""
+
+    def __init__(self, coder, io):
+        self.coder = coder
+        self.io = io
+
+    def get_saves_directory(self) -> Path:
+        """Get the saves directory, creating it if necessary."""
+        saves_dir = Path(self.coder.abs_root_path(".cecli/saves"))
+        os.makedirs(saves_dir, exist_ok=True)
+        return saves_dir
+
+    def resolve_filepath(self, filename: str) -> Path:
+        """Resolve a filename to an absolute path, using saves directory if needed."""
+        filepath = Path(filename)
+
+        # If it's a simple filename (no directory separators), save to .cecli/saves/
+        if not filepath.is_absolute() and str(filepath) == filepath.name:
+            saves_dir = self.get_saves_directory()
+            filepath = saves_dir / filepath
+
+        return filepath
+
+    def save_commands(self, filename: str) -> Path:
+        """Save commands to reconstruct the current chat session to a file."""
+        filepath = self.resolve_filepath(filename)
+
+        try:
+            # Ensure parent directory exists
+            os.makedirs(filepath.parent, exist_ok=True)
+
+            with open(filepath, "w", encoding=self.io.encoding) as f:
+                f.write("/drop\n")
+                # Write commands to add editable files
+                for fname in sorted(self.coder.abs_fnames):
+                    rel_fname = self.coder.get_rel_fname(fname)
+                    f.write(f"/add {rel_fname}\n")
+
+                # Write commands to add read-only files
+                for fname in sorted(self.coder.abs_read_only_fnames):
+                    # Use absolute path for files outside repo root, relative path for files inside
+                    if Path(fname).is_relative_to(self.coder.root):
+                        rel_fname = self.coder.get_rel_fname(fname)
+                        f.write(f"/read-only {rel_fname}\n")
+                    else:
+                        f.write(f"/read-only {fname}\n")
+                # Write commands to add read-only stubs files
+                for fname in sorted(self.coder.abs_read_only_stubs_fnames):
+                    # Use absolute path for files outside repo root, relative path for files inside
+                    if Path(fname).is_relative_to(self.coder.root):
+                        rel_fname = self.coder.get_rel_fname(fname)
+                        f.write(f"/read-only-stub {rel_fname}\n")
+                    else:
+                        f.write(f"/read-only-stub {fname}\n")
+
+            return filepath
+        except Exception as e:
+            raise IOError(f"Error saving commands to file: {e}")
+
+    def load_commands(self, filename: str) -> List[str]:
+        """Load commands from a file."""
+        filepath = self.resolve_filepath(filename)
+
+        try:
+            with open(filepath, "r", encoding=self.io.encoding, errors="replace") as f:
+                commands = f.readlines()
+            return [
+                cmd.strip() for cmd in commands if cmd.strip() and not cmd.strip().startswith("#")
+            ]
+        except FileNotFoundError:
+            raise FileNotFoundError(f"File not found: {filepath}")
+        except Exception as e:
+            raise IOError(f"Error reading file: {e}")
+
+    def list_files(self) -> List[str]:
+        """Return a list of all filenames (without extensions) in the saves directory.
+
+        Returns:
+            List[str]: List of filenames without extensions, sorted alphabetically
+        """
+        try:
+            saves_dir = self.get_saves_directory()
+
+            if not saves_dir.exists():
+                return []
+
+            # Get all files (not directories) in the saves directory
+            save_files = [f.name for f in saves_dir.iterdir() if f.is_file()]
+            return sorted(save_files)
+        except Exception:
+            # Return empty list on any error
+            return []

cecli/commands/voice.py

@@ -0,0 +1,78 @@
+import os
+from typing import List
+
+import cecli.voice as voice
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+from cecli.llm import litellm
+
+
+class VoiceCommand(BaseCommand):
+    NORM_NAME = "voice"
+    DESCRIPTION = "Record and transcribe voice input"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the voice command with given parameters."""
+        # Get voice parameters from kwargs or coder
+        voice_language = kwargs.get("voice_language") or getattr(coder, "voice_language", None)
+        voice_format = kwargs.get("voice_format") or getattr(coder, "voice_format", None)
+        voice_input_device = kwargs.get("voice_input_device") or getattr(
+            coder, "voice_input_device", None
+        )
+
+        # Get voice instance from kwargs or create new one
+        voice_instance = kwargs.get("voice_instance")
+
+        if not voice_instance:
+            if "OPENAI_API_KEY" not in os.environ:
+                io.tool_error("To use /voice you must provide an OpenAI API key.")
+                return format_command_result(io, "voice", "OpenAI API key required")
+
+            try:
+                voice_instance = voice.Voice(
+                    audio_format=voice_format or "wav", device_name=voice_input_device
+                )
+            except voice.SoundDeviceError:
+                io.tool_error(
+                    "Unable to import `sounddevice` and/or `soundfile`, is portaudio installed?"
+                )
+                return format_command_result(io, "voice", "Sound device error")
+
+        try:
+            io.update_spinner("Recording...")
+            text = await voice_instance.record_and_transcribe(None, language=voice_language)
+        except litellm.OpenAIError as err:
+            io.tool_error(f"Unable to use OpenAI whisper model: {err}")
+            return format_command_result(io, "voice", f"OpenAI error: {err}")
+
+        if text:
+            io.placeholder = text
+
+        if coder.tui and coder.tui():
+            coder.tui().set_input_value(text)
+            coder.tui().refresh()
+
+        return format_command_result(io, "voice", "Voice recorded and transcribed")
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for voice command."""
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the voice command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /voice  # Record and transcribe voice input\n"
+        help_text += (
+            "\nThis command records audio from your microphone and transcribes it using OpenAI's"
+            " Whisper model.\n"
+        )
+        help_text += "Requirements:\n"
+        help_text += "  - OPENAI_API_KEY environment variable must be set\n"
+        help_text += "  - PortAudio library installed (for sounddevice)\n"
+        help_text += "  - sounddevice and soundfile Python packages\n"
+        help_text += "\nThe transcribed text will be placed in the input prompt for editing.\n"
+        return help_text

cecli/commands/weak_model.py

@@ -0,0 +1,123 @@
+from typing import List
+
+import cecli.models as models
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+
+
+class WeakModelCommand(BaseCommand):
+    NORM_NAME = "weak-model"
+    DESCRIPTION = "Switch the Weak Model to a new LLM"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the weak_model command with given parameters."""
+        arg_split = args.split(" ", 1)
+        model_name = arg_split[0].strip()
+        if not model_name:
+            # If no model name provided, show current weak model
+            current_weak_model = coder.main_model.weak_model.name
+            io.tool_output(f"Current weak model: {current_weak_model}")
+            return format_command_result(
+                io, "weak-model", f"Displayed current weak model: {current_weak_model}"
+            )
+
+        # Create a new model with the same main model and editor model, but updated weak model
+        model = models.Model(
+            coder.main_model.name,
+            editor_model=coder.main_model.editor_model.name,
+            weak_model=model_name,
+            io=io,
+        )
+        await models.sanity_check_models(io, model)
+
+        if len(arg_split) > 1:
+            # implement architect coder-like generation call for weak model
+            message = arg_split[1].strip()
+
+            # Store the original model configuration
+            original_main_model = coder.main_model
+            original_edit_format = coder.edit_format
+
+            # Create a temporary coder with the new model
+            from cecli.coders import Coder
+
+            kwargs = dict()
+            kwargs["main_model"] = model
+            kwargs["edit_format"] = coder.edit_format  # Keep the same edit format
+            kwargs["suggest_shell_commands"] = False
+            kwargs["total_cost"] = coder.total_cost
+            kwargs["num_cache_warming_pings"] = 0
+            kwargs["summarize_from_coder"] = False
+
+            new_kwargs = dict(io=io, from_coder=coder)
+            new_kwargs.update(kwargs)
+
+            temp_coder = await Coder.create(**new_kwargs)
+            temp_coder.cur_messages = []
+            temp_coder.done_messages = []
+
+            verbose = kwargs.get("verbose", False)
+            if verbose:
+                temp_coder.show_announcements()
+
+            try:
+                await temp_coder.generate(user_message=message, preproc=False)
+                coder.move_back_cur_messages(
+                    f"Weak model {model_name} made those changes to the files."
+                )
+                coder.total_cost = temp_coder.total_cost
+                coder.coder_commit_hashes = temp_coder.coder_commit_hashes
+
+                # Restore the original model configuration
+                from cecli.commands import SwitchCoderSignal
+
+                raise SwitchCoderSignal(
+                    main_model=original_main_model, edit_format=original_edit_format
+                )
+            except Exception as e:
+                # If there's an error, still restore the original model
+                if not isinstance(e, SwitchCoderSignal):
+                    io.tool_error(str(e))
+                    raise SwitchCoderSignal(
+                        main_model=original_main_model, edit_format=original_edit_format
+                    )
+                else:
+                    # Re-raise SwitchCoderSignal if that's what was thrown
+                    raise
+        else:
+            from cecli.commands import SwitchCoderSignal
+
+            raise SwitchCoderSignal(main_model=model, edit_format=coder.edit_format)
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for weak_model command."""
+        return models.get_chat_model_names()
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the weak_model command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /weak_model <model-name>              # Switch to a new weak model\n"
+        help_text += (
+            "  /weak_model <model-name> <prompt>     # Use a specific weak model for a single"
+            " prompt\n"
+        )
+        help_text += "\nExamples:\n"
+        help_text += (
+            "  /weak_model gpt-4o-mini               # Switch to GPT-4o Mini as weak model\n"
+        )
+        help_text += (
+            "  /weak_model claude-3-haiku            # Switch to Claude 3 Haiku as weak model\n"
+        )
+        help_text += '  /weak_model o1-mini "review this code" # Use o1-mini to review code\n'
+        help_text += (
+            "\nWhen switching weak models, the main model and editor model remain unchanged.\n"
+        )
+        help_text += (
+            "\nIf you provide a prompt after the model name, that weak model will be used\n"
+        )
+        help_text += "just for that prompt, then you'll return to your original weak model.\n"
+        return help_text

cecli/commands/web.py

@@ -0,0 +1,87 @@
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import format_command_result
+from cecli.scrape import Scraper, install_playwright
+
+
+class WebCommand(BaseCommand):
+    NORM_NAME = "web"
+    DESCRIPTION = "Scrape a webpage, convert to markdown and send in a message"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the web command with given parameters."""
+        url = args.strip()
+        if not url:
+            io.tool_error("Please provide a URL to scrape.")
+            return format_command_result(io, "web", "No URL provided")
+
+        io.tool_output(f"Scraping {url}...")
+
+        # Get scraper instance from kwargs or create new one
+        scraper = kwargs.get("scraper")
+
+        if not scraper:
+            # Get disable_playwright from coder args
+            disable_playwright = (
+                getattr(coder.args, "disable_playwright", False) if coder and coder.args else False
+            )
+            if disable_playwright:
+                res = False
+            else:
+                try:
+                    res = await install_playwright(io)
+                    if not res:
+                        io.tool_warning("Unable to initialize playwright.")
+                except Exception:
+                    io.tool_warning("Unable to initialize playwright.")
+                    res = False
+
+            # Get verify_ssl from kwargs or use default
+            verify_ssl = kwargs.get("verify_ssl", True)
+
+            scraper = Scraper(
+                print_error=io.tool_error,
+                playwright_available=res,
+                verify_ssl=verify_ssl,
+            )
+
+        content = await scraper.scrape(url) or ""
+        content = f"Here is the content of {url}:\n\n" + content
+
+        return_content = kwargs.get("return_content", False)
+        if return_content:
+            return content
+
+        io.tool_output("... added to chat.")
+
+        coder.cur_messages += [
+            dict(role="user", content=content),
+            dict(role="assistant", content="Ok."),
+        ]
+
+        return format_command_result(io, "web", f"Scraped and added content from {url} to chat")
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for web command."""
+        # For web command, we could return recent URLs or common patterns
+        # For now, return empty list
+        return []
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the web command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /web <url>  # Scrape a webpage and add its content to the chat\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /web https://example.com  # Scrape example.com\n"
+        help_text += "  /web https://github.com/dwash96/aider-ce  # Scrape cecli GitHub page\n"
+        help_text += (
+            "\nThis command scrapes a webpage, converts it to markdown, and adds it to the chat.\n"
+        )
+        help_text += "It uses Playwright for JavaScript-rendered pages when available.\n"
+        help_text += "Use --disable-playwright to disable Playwright and use simpler scraping.\n"
+        return help_text

cecli/deprecated_args.py

@@ -0,0 +1,185 @@
+import argparse
+
+
+def add_deprecated_model_args(parser, group):
+    """Add deprecated model shortcut arguments to the argparse parser."""
+
+    group.add_argument(
+        "--opus",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--sonnet",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--haiku",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--4",
+        "-4",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--4o",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--mini",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--4-turbo",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--35turbo",
+        "--35-turbo",
+        "--3",
+        "-3",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--deepseek",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--o1-mini",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    group.add_argument(
+        "--o1-preview",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+
+    #########
+    group = parser.add_argument_group("API Keys and Settings (Deprecated)")
+    group.add_argument(
+        "--openai-api-type",
+        help=argparse.SUPPRESS,
+    )
+    group.add_argument(
+        "--openai-api-version",
+        help=argparse.SUPPRESS,
+    )
+    group.add_argument(
+        "--openai-api-deployment-id",
+        help=argparse.SUPPRESS,
+    )
+    group.add_argument(
+        "--openai-organization-id",
+        help=argparse.SUPPRESS,
+    )
+
+    #########
+    group = parser.add_argument_group("History Files (Deprecated)")
+    group.add_argument(
+        "--llm-history-file",
+        help=argparse.SUPPRESS,
+    )
+
+    ##########
+    group = parser.add_argument_group("Analytics")
+    group.add_argument(
+        "--analytics",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help=argparse.SUPPRESS,
+    )
+    group.add_argument(
+        "--analytics-log",
+        metavar="ANALYTICS_LOG_FILE",
+        help=argparse.SUPPRESS,
+    )
+    group.add_argument(
+        "--analytics-disable",
+        action="store_true",
+        help=argparse.SUPPRESS,
+        default=False,
+    )
+    group.add_argument(
+        "--analytics-posthog-host",
+        metavar="ANALYTICS_POSTHOG_HOST",
+        help=argparse.SUPPRESS,
+    )
+    group.add_argument(
+        "--analytics-posthog-project-api-key",
+        metavar="ANALYTICS_POSTHOG_PROJECT_API_KEY",
+        help=argparse.SUPPRESS,
+    )
+
+
+def handle_deprecated_model_args(args, io):
+    """Handle deprecated model shortcut arguments and provide appropriate warnings."""
+    # Define model mapping
+    model_map = {
+        "opus": "claude-3-opus-20240229",
+        "sonnet": "anthropic/claude-3-7-sonnet-20250219",
+        "haiku": "claude-3-5-haiku-20241022",
+        "4": "gpt-4-0613",
+        "4o": "gpt-4o",
+        "mini": "gpt-4o-mini",
+        "4_turbo": "gpt-4-1106-preview",
+        "35turbo": "gpt-3.5-turbo",
+        "deepseek": "deepseek/deepseek-chat",
+        "o1_mini": "o1-mini",
+        "o1_preview": "o1-preview",
+    }
+
+    # Check if any deprecated args are used
+    for arg_name, model_name in model_map.items():
+        arg_name_clean = arg_name.replace("-", "_")
+        if hasattr(args, arg_name_clean) and getattr(args, arg_name_clean):
+            # Find preferred name to display in warning
+            from cecli.models import MODEL_ALIASES
+
+            display_name = model_name
+            # Check if there's a shorter alias for this model
+            for alias, full_name in MODEL_ALIASES.items():
+                if full_name == model_name:
+                    display_name = alias
+                    break
+
+            # Show the warning
+            io.tool_warning(
+                f"The --{arg_name.replace('_', '-')} flag is deprecated and will be removed in a"
+                f" future version. Please use --model {display_name} instead."
+            )
+
+            # Set the model
+            if not args.model:
+                args.model = model_name
+            break

cecli/diffs.py

@@ -0,0 +1,129 @@
+import difflib
+import sys
+
+from .dump import dump  # noqa: F401
+
+
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: python diffs.py file1 file")
+        sys.exit(1)
+
+    file_orig, file_updated = sys.argv[1], sys.argv[2]
+
+    with open(file_orig, "r", encoding="utf-8") as f:
+        lines_orig = f.readlines()
+
+    with open(file_updated, "r", encoding="utf-8") as f:
+        lines_updated = f.readlines()
+
+    for i in range(len(file_updated)):
+        res = diff_partial_update(lines_orig, lines_updated[:i])
+        print(res)
+        input()
+
+
+def create_progress_bar(percentage):
+    block = "█"
+    empty = "░"
+    total_blocks = 30
+    filled_blocks = int(total_blocks * percentage // 100)
+    empty_blocks = total_blocks - filled_blocks
+    bar = block * filled_blocks + empty * empty_blocks
+    return bar
+
+
+def assert_newlines(lines):
+    if not lines:
+        return
+    for line in lines[:-1]:
+        assert line and line[-1] == "\n", line
+
+
+def diff_partial_update(lines_orig, lines_updated, final=False, fname=None):
+    """
+    Given only the first part of an updated file, show the diff while
+    ignoring the block of "deleted" lines that are past the end of the
+    partially complete update.
+    """
+
+    # dump(lines_orig)
+    # dump(lines_updated)
+
+    assert_newlines(lines_orig)
+
+    num_orig_lines = len(lines_orig)
+
+    if final:
+        last_non_deleted = num_orig_lines
+    else:
+        last_non_deleted = find_last_non_deleted(lines_orig, lines_updated)
+
+    # dump(last_non_deleted)
+    if last_non_deleted is None:
+        return ""
+
+    # if num_orig_lines:
+    #     pct = last_non_deleted * 100 / num_orig_lines
+    # else:
+    #     pct = 50
+    # bar = create_progress_bar(pct)
+    # bar = f" {last_non_deleted:3d} / {num_orig_lines:3d} lines [{bar}] {pct:3.0f}%\n"
+
+    lines_orig = lines_orig[:last_non_deleted]
+
+    if not final:
+        # lines_updated = lines_updated[:-1] + [bar]
+        lines_updated = lines_updated[:-1]
+
+    diff = difflib.unified_diff(lines_orig, lines_updated, n=5)
+
+    diff = list(diff)[2:]
+
+    diff = "".join(diff)
+    if not diff.endswith("\n"):
+        diff += "\n"
+
+    for i in range(3, 10):
+        backticks = "`" * i
+        if backticks not in diff:
+            break
+
+    show = "diff\n"
+    if fname:
+        show += f"--- {fname} original\n"
+        show += f"+++ {fname} updated\n"
+
+    show += diff
+
+    show += "\n\n"
+
+    # print(diff)
+
+    return show
+
+
+def find_last_non_deleted(lines_orig, lines_updated):
+    diff = list(difflib.ndiff(lines_orig, lines_updated))
+
+    num_orig = 0
+    last_non_deleted_orig = None
+
+    for line in diff:
+        # print(f"{num_orig:2d} {num_updated:2d} {line}", end="")
+        code = line[0]
+        if code == " ":
+            num_orig += 1
+            last_non_deleted_orig = num_orig
+        elif code == "-":
+            # line only in orig
+            num_orig += 1
+        elif code == "+":
+            # line only in updated
+            pass
+
+    return last_non_deleted_orig
+
+
+if __name__ == "__main__":
+    main()