cecli-dev 0.93.1__py3-none-any.whl

cecli/coders/wholefile_coder.py

@@ -0,0 +1,143 @@
+from pathlib import Path
+
+from cecli import diffs
+
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+
+
+class WholeFileCoder(Coder):
+    """A coder that operates on entire files for code modifications."""
+
+    edit_format = "whole"
+    prompt_format = "wholefile"
+
+    def render_incremental_response(self, final):
+        try:
+            return self.get_edits(mode="diff")
+        except ValueError:
+            return self.get_multi_response_content_in_progress()
+
+    def get_edits(self, mode="update"):
+        content = self.get_multi_response_content_in_progress()
+
+        chat_files = self.get_inchat_relative_files()
+
+        output = []
+        lines = content.splitlines(keepends=True)
+
+        edits = []
+
+        saw_fname = None
+        fname = None
+        fname_source = None
+        new_lines = []
+        for i, line in enumerate(lines):
+            if line.startswith(self.fence[0]) or line.startswith(self.fence[1]):
+                if fname is not None:
+                    # ending an existing block
+                    saw_fname = None
+
+                    full_path = self.abs_root_path(fname)
+
+                    if mode == "diff":
+                        output += self.do_live_diff(full_path, new_lines, True)
+                    else:
+                        edits.append((fname, fname_source, new_lines))
+
+                    fname = None
+                    fname_source = None
+                    new_lines = []
+                    continue
+
+                # fname==None ... starting a new block
+                if i > 0:
+                    fname_source = "block"
+                    fname = lines[i - 1].strip()
+                    fname = fname.strip("*")  # handle **filename.py**
+                    fname = fname.rstrip(":")
+                    fname = fname.strip("`")
+                    fname = fname.lstrip("#")
+                    fname = fname.strip()
+
+                    # Issue #1232
+                    if len(fname) > 250:
+                        fname = ""
+
+                    # Did gpt prepend a bogus dir? It especially likes to
+                    # include the path/to prefix from the one-shot example in
+                    # the prompt.
+                    if fname and fname not in chat_files and Path(fname).name in chat_files:
+                        fname = Path(fname).name
+                if not fname:  # blank line? or ``` was on first line i==0
+                    if saw_fname:
+                        fname = saw_fname
+                        fname_source = "saw"
+                    elif len(chat_files) == 1:
+                        fname = chat_files[0]
+                        fname_source = "chat"
+                    else:
+                        # TODO: sense which file it is by diff size
+                        raise ValueError(
+                            f"No filename provided before {self.fence[0]} in file listing"
+                        )
+
+            elif fname is not None:
+                new_lines.append(line)
+            else:
+                for word in line.strip().split():
+                    word = word.rstrip(".:,;!")
+                    for chat_file in chat_files:
+                        quoted_chat_file = f"`{chat_file}`"
+                        if word == quoted_chat_file:
+                            saw_fname = chat_file
+
+                output.append(line)
+
+        if mode == "diff":
+            if fname is not None:
+                # ending an existing block
+                full_path = (Path(self.root) / fname).absolute()
+                output += self.do_live_diff(full_path, new_lines, False)
+            return "\n".join(output)
+
+        if fname:
+            edits.append((fname, fname_source, new_lines))
+
+        seen = set()
+        refined_edits = []
+        # process from most reliable filename, to least reliable
+        for source in ("block", "saw", "chat"):
+            for fname, fname_source, new_lines in edits:
+                if fname_source != source:
+                    continue
+                # if a higher priority source already edited the file, skip
+                if fname in seen:
+                    continue
+
+                seen.add(fname)
+                refined_edits.append((fname, fname_source, new_lines))
+
+        return refined_edits
+
+    def apply_edits(self, edits):
+        for path, fname_source, new_lines in edits:
+            full_path = self.abs_root_path(path)
+            new_lines = "".join(new_lines)
+            self.io.write_text(full_path, new_lines)
+
+    def do_live_diff(self, full_path, new_lines, final):
+        if Path(full_path).exists():
+            orig_lines = self.io.read_text(full_path)
+            if orig_lines is not None:
+                orig_lines = orig_lines.splitlines(keepends=True)
+
+                show_diff = diffs.diff_partial_update(
+                    orig_lines,
+                    new_lines,
+                    final=final,
+                ).splitlines()
+                return show_diff
+
+        output = ["```"] + new_lines + ["```"]
+        return output

cecli/coders/wholefile_func_coder.py

@@ -0,0 +1,133 @@
+from cecli import diffs
+
+from ..dump import dump  # noqa: F401
+from .base_coder import Coder
+
+
+class WholeFileFunctionCoder(Coder):
+    prompt_format = "wholefile_func"
+    functions = [
+        dict(
+            name="write_file",
+            description="create or update one or more files",
+            parameters=dict(
+                type="object",
+                required=["explanation", "files"],
+                properties=dict(
+                    explanation=dict(
+                        type="string",
+                        description=(
+                            "Step by step plan for the changes to be made to the code (future"
+                            " tense, markdown format)"
+                        ),
+                    ),
+                    files=dict(
+                        type="array",
+                        items=dict(
+                            type="object",
+                            required=["path", "content"],
+                            properties=dict(
+                                path=dict(
+                                    type="string",
+                                    description="Path of file to write",
+                                ),
+                                content=dict(
+                                    type="string",
+                                    description="Content to write to the file",
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+    ]
+
+    def __init__(self, *args, **kwargs):
+        raise RuntimeError("Deprecated, needs to be refactored to support get_edits/apply_edits")
+
+        super().__init__(*args, **kwargs)
+
+    def add_assistant_reply_to_cur_messages(self, edited):
+        if edited:
+            self.cur_messages += [
+                dict(role="assistant", content=self.gpt_prompts.redacted_edit_message)
+            ]
+        else:
+            self.cur_messages += [dict(role="assistant", content=self.partial_response_content)]
+
+    def render_incremental_response(self, final=False):
+        if self.partial_response_content:
+            return self.partial_response_content
+
+        args = self.parse_partial_args()
+
+        if not args:
+            return
+
+        explanation = args.get("explanation")
+        files = args.get("files", [])
+
+        res = ""
+        if explanation:
+            res += f"{explanation}\n\n"
+
+        for i, file_upd in enumerate(files):
+            path = file_upd.get("path")
+            if not path:
+                continue
+            content = file_upd.get("content")
+            if not content:
+                continue
+
+            this_final = (i < len(files) - 1) or final
+            res += self.live_diffs(path, content, this_final)
+
+        return res
+
+    def live_diffs(self, fname, content, final):
+        lines = content.splitlines(keepends=True)
+
+        # ending an existing block
+        full_path = self.abs_root_path(fname)
+
+        content = self.io.read_text(full_path)
+        if content is None:
+            orig_lines = []
+        else:
+            orig_lines = content.splitlines()
+
+        show_diff = diffs.diff_partial_update(
+            orig_lines,
+            lines,
+            final,
+            fname=fname,
+        ).splitlines()
+
+        return "\n".join(show_diff)
+
+    async def _update_files(self):
+        name = self.partial_response_function_call.get("name")
+        if name and name != "write_file":
+            raise ValueError(f'Unknown function_call name="{name}", use name="write_file"')
+
+        args = self.parse_partial_args()
+        if not args:
+            return
+
+        files = args.get("files", [])
+
+        edited = set()
+        for file_upd in files:
+            path = file_upd.get("path")
+            if not path:
+                raise ValueError(f"Missing path parameter: {file_upd}")
+
+            content = file_upd.get("content")
+            if not content:
+                raise ValueError(f"Missing content parameter: {file_upd}")
+
+            if await self.allowed_to_edit(path, content):
+                edited.add(path)
+
+        return edited

cecli/commands/__init__.py

@@ -0,0 +1,192 @@
+"""
+Command system for cecli.
+
+This package contains individual command implementations that follow the
+BaseCommand pattern for modular, testable command execution.
+"""
+
+from .add import AddCommand
+from .agent import AgentCommand
+from .architect import ArchitectCommand
+from .ask import AskCommand
+from .clear import ClearCommand
+from .code import CodeCommand
+from .command_prefix import CommandPrefixCommand
+from .commit import CommitCommand
+from .context import ContextCommand
+from .context_blocks import ContextBlocksCommand
+from .context_management import ContextManagementCommand
+from .copy import CopyCommand
+from .copy_context import CopyContextCommand
+from .core import Commands, SwitchCoderSignal
+from .diff import DiffCommand
+
+# Import and register commands
+from .drop import DropCommand
+from .editor import EditCommand, EditorCommand
+from .exit import ExitCommand
+from .git import GitCommand
+from .help import HelpCommand
+from .history_search import HistorySearchCommand
+from .lint import LintCommand
+from .list_sessions import ListSessionsCommand
+from .load import LoadCommand
+from .load_session import LoadSessionCommand
+from .load_skill import LoadSkillCommand
+from .ls import LsCommand
+from .map import MapCommand
+from .map_refresh import MapRefreshCommand
+from .model import ModelCommand
+from .models import ModelsCommand
+from .multiline_mode import MultilineModeCommand
+from .paste import PasteCommand
+from .quit import QuitCommand
+from .read_only import ReadOnlyCommand
+from .read_only_stub import ReadOnlyStubCommand
+from .reasoning_effort import ReasoningEffortCommand
+from .remove_skill import RemoveSkillCommand
+from .report import ReportCommand
+from .reset import ResetCommand
+from .run import RunCommand
+from .save import SaveCommand
+from .save_session import SaveSessionCommand
+from .settings import SettingsCommand
+from .test import TestCommand
+from .think_tokens import ThinkTokensCommand
+from .tokens import TokensCommand
+from .undo import UndoCommand
+from .utils.base_command import BaseCommand
+from .utils.helpers import (
+    CommandError,
+    expand_subdir,
+    format_command_result,
+    get_available_files,
+    glob_filtered_to_repo,
+    parse_quoted_filenames,
+    quote_filename,
+    validate_file_access,
+)
+from .utils.registry import CommandRegistry
+from .voice import VoiceCommand
+from .weak_model import WeakModelCommand
+from .web import WebCommand
+
+# Register commands
+CommandRegistry.register(DropCommand)
+CommandRegistry.register(ClearCommand)
+CommandRegistry.register(LsCommand)
+CommandRegistry.register(DiffCommand)
+CommandRegistry.register(ResetCommand)
+CommandRegistry.register(CopyCommand)
+CommandRegistry.register(PasteCommand)
+CommandRegistry.register(SettingsCommand)
+CommandRegistry.register(ReportCommand)
+CommandRegistry.register(TokensCommand)
+CommandRegistry.register(UndoCommand)
+CommandRegistry.register(GitCommand)
+CommandRegistry.register(RunCommand)
+CommandRegistry.register(HelpCommand)
+CommandRegistry.register(CommitCommand)
+CommandRegistry.register(ModelsCommand)
+CommandRegistry.register(ExitCommand)
+CommandRegistry.register(QuitCommand)
+CommandRegistry.register(VoiceCommand)
+CommandRegistry.register(MapCommand)
+CommandRegistry.register(MapRefreshCommand)
+CommandRegistry.register(MultilineModeCommand)
+CommandRegistry.register(EditorCommand)
+CommandRegistry.register(EditCommand)
+CommandRegistry.register(HistorySearchCommand)
+CommandRegistry.register(ThinkTokensCommand)
+CommandRegistry.register(LoadCommand)
+CommandRegistry.register(SaveCommand)
+CommandRegistry.register(ReasoningEffortCommand)
+CommandRegistry.register(SaveSessionCommand)
+CommandRegistry.register(ListSessionsCommand)
+CommandRegistry.register(LoadSessionCommand)
+CommandRegistry.register(ReadOnlyCommand)
+CommandRegistry.register(ReadOnlyStubCommand)
+CommandRegistry.register(AddCommand)
+CommandRegistry.register(ModelCommand)
+CommandRegistry.register(WeakModelCommand)
+CommandRegistry.register(WebCommand)
+CommandRegistry.register(LintCommand)
+CommandRegistry.register(TestCommand)
+CommandRegistry.register(ContextManagementCommand)
+CommandRegistry.register(ContextBlocksCommand)
+CommandRegistry.register(AskCommand)
+CommandRegistry.register(CodeCommand)
+CommandRegistry.register(ArchitectCommand)
+CommandRegistry.register(ContextCommand)
+CommandRegistry.register(AgentCommand)
+CommandRegistry.register(CopyContextCommand)
+CommandRegistry.register(CommandPrefixCommand)
+CommandRegistry.register(LoadSkillCommand)
+CommandRegistry.register(RemoveSkillCommand)
+
+
+__all__ = [
+    "BaseCommand",
+    "CommandRegistry",
+    "CommandError",
+    "quote_filename",
+    "parse_quoted_filenames",
+    "glob_filtered_to_repo",
+    "validate_file_access",
+    "format_command_result",
+    "get_available_files",
+    "expand_subdir",
+    "DropCommand",
+    "ClearCommand",
+    "LsCommand",
+    "DiffCommand",
+    "ResetCommand",
+    "CopyCommand",
+    "PasteCommand",
+    "SettingsCommand",
+    "ReportCommand",
+    "TokensCommand",
+    "UndoCommand",
+    "GitCommand",
+    "RunCommand",
+    "HelpCommand",
+    "CommitCommand",
+    "ModelsCommand",
+    "ExitCommand",
+    "QuitCommand",
+    "VoiceCommand",
+    "MapCommand",
+    "MapRefreshCommand",
+    "MultilineModeCommand",
+    "EditorCommand",
+    "EditCommand",
+    "HistorySearchCommand",
+    "ThinkTokensCommand",
+    "LoadCommand",
+    "SaveCommand",
+    "ReasoningEffortCommand",
+    "SaveSessionCommand",
+    "ListSessionsCommand",
+    "LoadSessionCommand",
+    "ReadOnlyCommand",
+    "ReadOnlyStubCommand",
+    "AddCommand",
+    "ModelCommand",
+    "WeakModelCommand",
+    "WebCommand",
+    "LintCommand",
+    "TestCommand",
+    "ContextManagementCommand",
+    "ContextBlocksCommand",
+    "AskCommand",
+    "CodeCommand",
+    "ArchitectCommand",
+    "ContextCommand",
+    "AgentCommand",
+    "CopyContextCommand",
+    "CommandPrefixCommand",
+    "LoadSkillCommand",
+    "RemoveSkillCommand",
+    "SwitchCoderSignal",
+    "Commands",
+]

cecli/commands/add.py

@@ -0,0 +1,226 @@
+import os
+import re
+from pathlib import Path
+from typing import List
+
+from cecli.commands.utils.base_command import BaseCommand
+from cecli.commands.utils.helpers import (
+    format_command_result,
+    parse_quoted_filenames,
+    quote_filename,
+)
+from cecli.utils import is_image_file, run_fzf
+
+
+class AddCommand(BaseCommand):
+    NORM_NAME = "add"
+    DESCRIPTION = "Add files to the chat so cecli can edit them or review them in detail"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the add command with given parameters."""
+        if not args.strip():
+            all_files = coder.get_all_relative_files()
+            files_in_chat = coder.get_inchat_relative_files()
+            addable_files = sorted(set(all_files) - set(files_in_chat))
+            if not addable_files:
+                io.tool_output("No files available to add.")
+                return format_command_result(io, "add", "No files available to add")
+            selected_files = run_fzf(addable_files, multi=True, coder=coder)
+            if not selected_files:
+                return format_command_result(io, "add", "No files selected")
+            args = " ".join([quote_filename(f) for f in selected_files])
+
+        all_matched_files = set()
+
+        filenames = parse_quoted_filenames(args)
+        for word in filenames:
+            if Path(word).is_absolute():
+                fname = Path(word)
+            else:
+                fname = Path(coder.root) / word
+
+            if coder.repo and coder.repo.ignored_file(fname):
+                io.tool_warning(f"Skipping {fname} due to cecli.ignore or --subtree-only.")
+                continue
+
+            if fname.exists():
+                if fname.is_file():
+                    all_matched_files.add(str(fname))
+                    continue
+                # an existing dir, escape any special chars so they won't be globs
+                word = re.sub(r"([\*\?\[\]])", r"[\1]", word)
+
+            matched_files = cls.glob_filtered_to_repo(coder, word)
+            if matched_files:
+                all_matched_files.update(matched_files)
+                continue
+
+            if "*" in str(fname) or "?" in str(fname):
+                io.tool_error(f"No match, and cannot create file with wildcard characters: {fname}")
+                continue
+
+            if fname.exists() and fname.is_dir() and coder.repo:
+                io.tool_error(f"Directory {fname} is not in git.")
+                io.tool_output(f"You can add to git with: /git add {fname}")
+                continue
+
+            if await io.confirm_ask(f"No files matched '{word}'. Do you want to create {fname}?"):
+                try:
+                    fname.parent.mkdir(parents=True, exist_ok=True)
+                    fname.touch()
+                    all_matched_files.add(str(fname))
+                except OSError as e:
+                    io.tool_error(f"Error creating file {fname}: {e}")
+
+        for matched_file in sorted(all_matched_files):
+            abs_file_path = coder.abs_root_path(matched_file)
+
+            if not abs_file_path.startswith(coder.root) and not is_image_file(matched_file):
+                io.tool_error(f"Can not add {abs_file_path}, which is not within {coder.root}")
+                continue
+
+            if (
+                coder.repo
+                and coder.repo.git_ignored_file(matched_file)
+                and not coder.add_gitignore_files
+            ):
+                io.tool_error(f"Can't add {matched_file} which is in gitignore")
+                continue
+
+            if abs_file_path in coder.abs_fnames:
+                io.tool_error(f"{matched_file} is already in the chat as an editable file")
+                continue
+            elif abs_file_path in coder.abs_read_only_stubs_fnames:
+                if coder.repo and coder.repo.path_in_repo(matched_file):
+                    coder.abs_read_only_stubs_fnames.remove(abs_file_path)
+                    coder.abs_fnames.add(abs_file_path)
+                    io.tool_output(
+                        f"Moved {matched_file} from read-only (stub) to editable files in the chat"
+                    )
+                else:
+                    io.tool_error(f"Cannot add {matched_file} as it's not part of the repository")
+            elif abs_file_path in coder.abs_read_only_fnames:
+                if coder.repo and coder.repo.path_in_repo(matched_file):
+                    coder.abs_read_only_fnames.remove(abs_file_path)
+                    coder.abs_fnames.add(abs_file_path)
+                    io.tool_output(
+                        f"Moved {matched_file} from read-only to editable files in the chat"
+                    )
+                else:
+                    io.tool_error(f"Cannot add {matched_file} as it's not part of the repository")
+            else:
+                if is_image_file(matched_file) and not coder.main_model.info.get("supports_vision"):
+                    io.tool_error(
+                        f"Cannot add image file {matched_file} as the"
+                        f" {coder.main_model.name} does not support images."
+                    )
+                    continue
+                content = io.read_text(abs_file_path)
+                if content is None:
+                    io.tool_error(f"Unable to read {matched_file}")
+                else:
+                    coder.abs_fnames.add(abs_file_path)
+                    fname = coder.get_rel_fname(abs_file_path)
+                    io.tool_output(f"Added {fname} to the chat")
+                    coder.check_added_files()
+
+                    # Recalculate context block tokens if using agent mode
+                    if hasattr(coder, "use_enhanced_context") and coder.use_enhanced_context:
+                        if hasattr(coder, "_calculate_context_block_tokens"):
+                            coder._calculate_context_block_tokens()
+
+        if coder.repo_map:
+            map_tokens = coder.repo_map.max_map_tokens
+            map_mul_no_files = coder.repo_map.map_mul_no_files
+        else:
+            map_tokens = 0
+            map_mul_no_files = 1
+
+        from cecli.commands import SwitchCoderSignal
+
+        raise SwitchCoderSignal(
+            edit_format=coder.edit_format,
+            summarize_from_coder=False,
+            from_coder=coder,
+            map_tokens=map_tokens,
+            map_mul_no_files=map_mul_no_files,
+            show_announcements=False,
+        )
+
+    @classmethod
+    def glob_filtered_to_repo(cls, coder, pattern: str) -> List[str]:
+        """Glob pattern and filter results to repository files."""
+        if not pattern.strip():
+            return []
+        try:
+            if os.path.isabs(pattern):
+                # Handle absolute paths
+                raw_matched_files = [Path(pattern)]
+            else:
+                try:
+                    raw_matched_files = list(Path(coder.root).glob(pattern))
+                except (IndexError, AttributeError):
+                    raw_matched_files = []
+        except ValueError:
+            # This error will be handled by the caller
+            raw_matched_files = []
+
+        matched_files = []
+        for fn in raw_matched_files:
+            matched_files += cls.expand_subdir(fn)
+
+        matched_files = [
+            fn.relative_to(coder.root) for fn in matched_files if fn.is_relative_to(coder.root)
+        ]
+
+        # if repo, filter against it
+        if coder.repo:
+            git_files = coder.repo.get_tracked_files()
+            matched_files = [fn for fn in matched_files if str(fn) in git_files]
+
+        return list(map(str, matched_files))
+
+    @staticmethod
+    def expand_subdir(file_path: Path) -> List[Path]:
+        """Expand a directory path to all files within it."""
+        if file_path.is_file():
+            return [file_path]
+
+        if file_path.is_dir():
+            files = []
+            for file in file_path.rglob("*"):
+                if file.is_file():
+                    files.append(file)
+            return files
+
+        return []
+
+    @classmethod
+    def get_completions(cls, io, coder, args) -> List[str]:
+        """Get completion options for add command."""
+        files = set(coder.get_all_relative_files())
+        files = files - set(coder.get_inchat_relative_files())
+        files = [quote_filename(fn) for fn in files]
+        return files
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the add command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /add              # Interactive file selection using fuzzy finder\n"
+        help_text += "  /add <files>      # Add specific files or glob patterns\n"
+        help_text += "\nExamples:\n"
+        help_text += "  /add              # Use fuzzy finder to select files\n"
+        help_text += "  /add *.py         # Add all Python files\n"
+        help_text += "  /add main.py      # Add main.py\n"
+        help_text += '  /add "file with spaces.py"  # Add file with spaces\n'
+        help_text += (
+            "\nThis command adds files to the chat so cecli can edit them or review them in"
+            " detail.\n"
+        )
+        help_text += "If a file doesn't exist, you'll be asked if you want to create it.\n"
+        help_text += "Files can be moved from read-only to editable status.\n"
+        help_text += "Image files can be added if the model supports vision.\n"
+        return help_text