cecli-dev 0.99.5__tar.gz → 0.99.6__tar.gz

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/.pre-commit-config.yaml

@@ -1,21 +1,21 @@
 repos:
   - repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
+    rev: 9.0.0a3
     hooks:
       - id: isort
         args: ["--profile", "black"]
   - repo: https://github.com/psf/black
-    rev: 23.3.0
+    rev: 26.3.1
     hooks:
       - id: black
         args: ["--line-length", "100", "--preview"]
   - repo: https://github.com/pycqa/flake8
-    rev: 7.1.0
+    rev: 7.3.0
     hooks:
       - id: flake8
         args: ["--show-source"]
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.6
+    rev: v2.4.2
     hooks:
       - id: codespell
         args: ["--skip", "cecli/website/docs/languages.md"]

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.5
+Version: 0.99.6
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -27,7 +27,6 @@ Requires-Dist: prompt_toolkit
 Requires-Dist: backoff>=2.2.1
 Requires-Dist: pathspec>=0.12.1
 Requires-Dist: diskcache>=5.6.3
-Requires-Dist: grep_ast
 Requires-Dist: packaging>=25.0
 Requires-Dist: sounddevice>=0.5.2
 Requires-Dist: soundfile>=0.13.1
@@ -59,6 +58,8 @@ Requires-Dist: importlib-metadata>=7.2.1
 Requires-Dist: tomli>=2.3.0; python_version <= "3.10"
 Requires-Dist: tree-sitter==0.23.2; python_version < "3.10"
 Requires-Dist: tree-sitter>=0.25.1; python_version >= "3.10"
+Requires-Dist: tree-sitter-language-pack<=0.13.0
+Requires-Dist: tree_sitter_languages==1.10.2; python_version <= "3.12"
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-asyncio; extra == "dev"

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/benchmark/benchmark.py

@@ -292,9 +292,7 @@ def main(
 
     if not dry and "CECLI_DOCKER" not in os.environ:
         logger.warning("Warning: Benchmarking runs unvetted code. Run in a docker container.")
-        logger.warning(
-            "Set CECLI_DOCKER in the environment to by-pass this check at your own risk."
-        )
+        logger.warning("Set CECLI_DOCKER in the environment to bypass this check at your own risk.")
         return
 
     # Check dirs exist

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.99.3.dev"
+__version__ = "0.99.6.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.5'
-__version_tuple__ = version_tuple = (0, 99, 5)
+__version__ = version = '0.99.6'
+__version_tuple__ = version_tuple = (0, 99, 6)
 
-__commit_id__ = commit_id = 'g4a4e977c3'
+__commit_id__ = commit_id = 'g835b8b50f'

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/cecli/coders/agent_coder.py

@@ -582,6 +582,7 @@ class AgentCoder(Coder):
 
         # Add post-message context blocks (priority 250 - between CUR and REMINDER)
         ConversationService.get_chunks(self).add_post_message_context_blocks()
+        ConversationService.get_chunks(self).add_randomized_cta()
 
         return ConversationService.get_manager(self).get_messages_dict()
 

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/cecli/coders/base_coder.py

@@ -1131,8 +1131,9 @@ class Coder:
                     "other_files": other_files,
                     "mentioned_fnames": mentioned_fnames,
                     "all_abs_files": all_abs_files,
-                    "read_only_count": len(set(self.abs_read_only_fnames)) + len(
-                        set(self.abs_read_only_stubs_fnames)
+                    "read_only_count": (
+                        len(set(self.abs_read_only_fnames))
+                        + len(set(self.abs_read_only_stubs_fnames))
                     ),
                 }
             )

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/cecli/commands/load_mcp.py

@@ -6,7 +6,7 @@ from cecli.commands.utils.helpers import format_command_result
 
 class LoadMcpCommand(BaseCommand):
     NORM_NAME = "load-mcp"
-    DESCRIPTION = "Load a MCP server by name"
+    DESCRIPTION = "Load MCP server(s) by name, or use '*' to load all enabled servers"
 
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
@@ -21,17 +21,34 @@ class LoadMcpCommand(BaseCommand):
 
         server_names = args.strip().split()
         results = []
-        for server_name in server_names:
-            server = coder.mcp_manager.get_server(server_name)
-            if server is None:
-                results.append(f"MCP server {server_name} does not exist.")
-                continue
 
-            did_connect = await coder.mcp_manager.connect_server(server.name)
-            if did_connect:
-                results.append(f"Loaded server: {server_name}")
-            else:
-                results.append(f"Unable to load server: {server_name}")
+        # Handle '*' wildcard to load all servers enabled by default
+        if server_names == ["*"]:
+            for server in coder.mcp_manager.servers:
+                if server in coder.mcp_manager.connected_servers:
+                    results.append(f"Server already loaded: {server.name}")
+                    continue
+                auto_connect = server.config.get("enabled", True)
+                if not auto_connect:
+                    results.append(f"Skipping server (not enabled by default): {server.name}")
+                    continue
+                did_connect = await coder.mcp_manager.connect_server(server.name)
+                if did_connect:
+                    results.append(f"Loaded server: {server.name}")
+                else:
+                    results.append(f"Unable to load server: {server.name}")
+        else:
+            for server_name in server_names:
+                server = coder.mcp_manager.get_server(server_name)
+                if server is None:
+                    results.append(f"MCP server {server_name} does not exist.")
+                    continue
+
+                did_connect = await coder.mcp_manager.connect_server(server.name)
+                if did_connect:
+                    results.append(f"Loaded server: {server_name}")
+                else:
+                    results.append(f"Unable to load server: {server_name}")
 
         try:
             return format_command_result(io, cls.NORM_NAME, "\n".join(results))
@@ -67,8 +84,8 @@ class LoadMcpCommand(BaseCommand):
         help_text = super().get_help()
         help_text += "\nUsage:\n"
         help_text += "  /load-mcp <mcp-name>...  # Load one or more mcps by name\n"
+        help_text += "  /load-mcp *              # Load all mcps enabled by default\n"
         help_text += "\nExamples:\n"
         help_text += "  /load-mcp context7  # Load the context7 mcp\n"
         help_text += "  /load-mcp github context7  # Load both github and context7 mcps\n"
-        help_text += "\nThis command loads one or more MCP servers by name.\n"
-        return help_text
+        help_text += "  /load-mcp *          # Load all mcps enabled by default\n"

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/cecli/commands/remove_mcp.py

@@ -6,7 +6,7 @@ from cecli.commands.utils.helpers import format_command_result
 
 class RemoveMcpCommand(BaseCommand):
     NORM_NAME = "remove-mcp"
-    DESCRIPTION = "Remove a MCP server by name"
+    DESCRIPTION = "Remove a MCP server by name, or use '*' to remove all"
 
     @classmethod
     async def execute(cls, io, coder, args, **kwargs):
@@ -21,12 +21,23 @@ class RemoveMcpCommand(BaseCommand):
 
         server_names = args.strip().split()
         results = []
-        for server_name in server_names:
-            was_disconnected = await coder.mcp_manager.disconnect_server(server_name)
-            if was_disconnected:
-                results.append(f"Removed server: {server_name}")
+
+        # Handle '*' wildcard to disconnect all servers
+        if server_names == ["*"]:
+            connected = [s for s in coder.mcp_manager.servers if s.is_connected]
+            if not connected:
+                results.append("No MCP servers connected, nothing to remove.")
             else:
-                results.append(f"Unable to remove server: {server_name}")
+                for server in connected:
+                    await coder.mcp_manager.disconnect_server(server.name)
+                    results.append(f"Removed server: {server.name}")
+        else:
+            for server_name in server_names:
+                was_disconnected = await coder.mcp_manager.disconnect_server(server_name)
+                if was_disconnected:
+                    results.append(f"Removed server: {server_name}")
+                else:
+                    results.append(f"Unable to remove server: {server_name}")
 
         try:
             return format_command_result(io, cls.NORM_NAME, "\n".join(results))
@@ -59,7 +70,8 @@ class RemoveMcpCommand(BaseCommand):
         help_text = super().get_help()
         help_text += "\nUsage:\n"
         help_text += "  /remove-mcp <mcp-name>...  # Remove one or more mcps by name\n"
+        help_text += "  /remove-mcp *              # Remove all connected mcps\n"
         help_text += "\nExamples:\n"
         help_text += "  /remove-mcp context7  # Remove the context7 mcp\n"
         help_text += "  /remove-mcp github context7  # Remove both github and context7 mcps\n"
-        help_text += "\nThis command removes one or more MCP servers by name.\n"
+        help_text += "  /remove-mcp *          # Remove all connected mcps\n"

{cecli_dev-0.99.5 → cecli_dev-0.99.6}/cecli/helpers/conversation/integration.py

@@ -1,4 +1,5 @@
 import json
+import random
 import weakref
 from typing import Any, Dict, List
 from uuid import UUID
@@ -93,7 +94,9 @@ class ConversationChunks:
         ):
             msg = dict(
                 role="user",
-                content=coder.fmt_system_prompt(coder.gpt_prompts.system_reminder),
+                content=self._shuffle_reminders(
+                    coder.fmt_system_prompt(coder.gpt_prompts.system_reminder)
+                ),
             )
             ConversationService.get_manager(coder).add_message(
                 message_dict=msg,
@@ -103,6 +106,62 @@ class ConversationChunks:
                 mark_for_delete=0,
             )
 
+    def add_randomized_cta(self) -> None:
+        coder = self.get_coder()
+        if not coder:
+            return
+
+        message = random.choice(
+            [
+                "Given the above, please call any tools necessary to make progress on your task",
+                (
+                    "Based on the information provided, please execute the appropriate tools to"
+                    " move the task forward."
+                ),
+                "With this context in mind, please proceed with your work.",
+                (
+                    "In light of the above, please utilize the required tools to continue with this"
+                    " request."
+                ),
+                (
+                    "Continue making progress. If you have reached the goal, summarize the results."
+                    " Otherwise, call the next necessary tool."
+                ),
+                (
+                    "Please use the proper tools to fulfill the next steps of this task based on"
+                    " the current data."
+                ),
+                (
+                    "You’ve got what you need, please invoke the right tools to keep making"
+                    " progress towards our goal."
+                ),
+                (
+                    "Considering what we've established, please use the available tools to complete"
+                    " the current objective."
+                ),
+                (
+                    "Given this information, please use the available tools to proceed with the"
+                    " assignment."
+                ),
+                "Please take the next logical steps to make headway on this task.",
+            ]
+        )
+
+        msg = dict(
+            role="user",
+            content="\n\n" + message,
+        )
+
+        ConversationService.get_manager(coder).add_message(
+            message_dict=msg,
+            tag=MessageTag.REMINDER,
+            hash_key=("main", "randomized_cta"),
+            force=True,
+            mark_for_delete=0,
+            promotion=2 * ConversationService.get_manager(coder).DEFAULT_TAG_PROMOTION_VALUE,
+            mark_for_demotion=1,
+        )
+
     def cleanup_files(self) -> None:
         """
         Clean up ConversationFiles and remove corresponding messages from ConversationManager
@@ -903,6 +962,35 @@ class ConversationChunks:
                 force=True,
             )
 
+    def _shuffle_reminders(self, content: str) -> str:
+        """
+        If the string is a critical_reminders block, shuffle all bulleted points
+        to prevent the model from developing 'boilerplate blindness.'
+        """
+        if not content.strip().startswith('<context name="critical_reminders">'):
+            return content
+
+        lines = content.splitlines()
+
+        # 1. Identify indices of lines starting with a hyphen (and the content itself)
+        # We use strip() to handle indentation within the XML block
+        list_info = [(i, line) for i, line in enumerate(lines) if line.strip().startswith("-")]
+
+        if not list_info:
+            return content
+
+        # 2. Extract and shuffle the list items
+        indices = [item[0] for item in list_info]
+        bullet_contents = [item[1] for item in list_info]
+        random.shuffle(bullet_contents)
+
+        # 3. Reconstruct the block by placing shuffled items back into the original indices
+        new_lines = list(lines)
+        for index, shuffled_text in zip(indices, bullet_contents):
+            new_lines[index] = shuffled_text
+
+        return "\n".join(new_lines)
+
     def debug_print_conversation_state(self) -> None:
         """
         Print debug information about conversation state.

cecli_dev-0.99.6/cecli/helpers/grep_ast/__init__.py

@@ -0,0 +1,4 @@
+# noqa: F401
+
+from .grep_ast import TreeContext  # noqa
+from .parsers import filename_to_lang  # noqa

cecli_dev-0.99.6/cecli/helpers/grep_ast/dump.py

@@ -0,0 +1,29 @@
+import json
+import traceback
+
+
+def cvt(s):
+    if isinstance(s, str):
+        return s
+    try:
+        return json.dumps(s, indent=4)
+    except TypeError:
+        return str(s)
+
+
+def dump(*vals):
+    # http://docs.python.org/library/traceback.html
+    stack = traceback.extract_stack()
+    vars = stack[-2][3]
+
+    # strip away the call to dump()
+    vars = "(".join(vars.split("(")[1:])
+    vars = ")".join(vars.split(")")[:-1])
+
+    vals = [cvt(v) for v in vals]
+    has_newline = sum(1 for v in vals if "\n" in v)
+    if has_newline:
+        print("%s:" % vars)
+        print(", ".join(vals))
+    else:
+        print("%s:" % vars, ", ".join(vals))

cecli_dev-0.99.6/cecli/helpers/grep_ast/grep_ast.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python
+
+import re
+
+from .dump import dump  # noqa: F401
+from .parsers import filename_to_lang
+from .tsl import get_parser
+
+
+class TreeContext:
+    def __init__(
+        self,
+        filename,
+        code,
+        color=False,
+        verbose=False,
+        line_number=False,
+        parent_context=True,
+        child_context=True,
+        last_line=True,
+        margin=3,
+        mark_lois=True,
+        header_max=10,
+        show_top_of_file_parent_scope=True,
+        loi_pad=1,
+    ):
+        self.filename = filename
+        self.color = color
+        self.verbose = verbose
+        self.line_number = line_number
+        self.last_line = last_line
+        self.margin = margin
+        self.mark_lois = mark_lois
+        self.header_max = header_max
+        self.loi_pad = loi_pad
+        self.show_top_of_file_parent_scope = show_top_of_file_parent_scope
+
+        self.parent_context = parent_context
+        self.child_context = child_context
+
+        lang = filename_to_lang(filename)
+        if not lang:
+            raise ValueError(f"Unknown language for {filename}")
+
+        # Get parser based on file extension
+        parser = get_parser(lang)
+        tree = parser.parse(bytes(code, "utf8"))
+
+        self.lines = code.splitlines()
+        self.num_lines = len(self.lines) + 1
+
+        # color lines, with highlighted matches
+        self.output_lines = dict()
+
+        # Which scopes is each line part of?
+        # A scope is the line number on which the scope started
+        self.scopes = [set() for _ in range(self.num_lines)]
+
+        # Which lines serve as a short "header" for the scope starting on that line
+        self.header = [list() for _ in range(self.num_lines)]
+
+        self.nodes = [list() for _ in range(self.num_lines)]
+
+        root_node = tree.root_node
+        self.walk_tree(root_node)
+
+        if self.verbose:
+            scope_width = max(len(str(set(self.scopes[i]))) for i in range(self.num_lines - 1))
+        for i in range(self.num_lines):
+            header = sorted(self.header[i])
+            if self.verbose and i < self.num_lines - 1:
+                scopes = str(sorted(set(self.scopes[i])))
+                print(f"{scopes.ljust(scope_width)}", i, self.lines[i])
+
+            if len(header) > 1:
+                size, head_start, head_end = header[0]
+                if size > self.header_max:
+                    head_end = head_start + self.header_max
+            else:
+                head_start = i
+                head_end = i + 1
+
+            self.header[i] = head_start, head_end
+
+        self.show_lines = set()
+        self.lines_of_interest = set()
+
+        return
+
+    def grep(self, pat, ignore_case):
+        found = set()
+        for i, line in enumerate(self.lines):
+            if re.search(pat, line, re.IGNORECASE if ignore_case else 0):
+                if self.color:
+                    highlighted_line = re.sub(
+                        pat,
+                        lambda match: f"\033[1;31m{match.group()}\033[0m",  # noqa
+                        line,
+                        flags=re.IGNORECASE if ignore_case else 0,
+                    )
+                    self.output_lines[i] = highlighted_line
+                found.add(i)
+        return found
+
+    def add_lines_of_interest(self, line_nums):
+        self.lines_of_interest.update(line_nums)
+
+    def add_context(self):
+        if not self.lines_of_interest:
+            return
+
+        self.done_parent_scopes = set()
+
+        self.show_lines = set(self.lines_of_interest)
+
+        if self.loi_pad:
+            for line in list(self.show_lines):
+                for new_line in range(line - self.loi_pad, line + self.loi_pad + 1):
+                    # if not self.scopes[line].intersection(self.scopes[new_line]):
+                    #    continue
+                    if new_line >= self.num_lines:
+                        continue
+                    if new_line < 0:
+                        continue
+                    self.show_lines.add(new_line)
+
+        if self.last_line:
+            # add the bottom line (plus parent context)
+            bottom_line = self.num_lines - 2
+            self.show_lines.add(bottom_line)
+            self.add_parent_scopes(bottom_line)
+
+        if self.parent_context:
+            for i in set(self.lines_of_interest):
+                self.add_parent_scopes(i)
+
+        if self.child_context:
+            for i in set(self.lines_of_interest):
+                self.add_child_context(i)
+
+        # add the top margin lines of the file
+        if self.margin:
+            self.show_lines.update(range(self.margin))
+
+        self.close_small_gaps()
+
+    def add_child_context(self, i):
+        if not self.nodes[i]:
+            return
+
+        last_line = self.get_last_line_of_scope(i)
+        size = last_line - i
+        if size < 5:
+            self.show_lines.update(range(i, last_line + 1))
+            return
+
+        children = []
+        for node in self.nodes[i]:
+            children += self.find_all_children(node)
+
+        children = sorted(
+            children,
+            key=lambda node: node.end_point[0] - node.start_point[0],
+            reverse=True,
+        )
+
+        currently_showing = len(self.show_lines)
+        max_to_show = 25
+        min_to_show = 5
+        percent_to_show = 0.10
+        max_to_show = max(min(size * percent_to_show, max_to_show), min_to_show)
+
+        for child in children:
+            if len(self.show_lines) > currently_showing + max_to_show:
+                break
+            child_start_line = child.start_point[0]
+            self.add_parent_scopes(child_start_line)
+
+    def find_all_children(self, node):
+        children = [node]
+        for child in node.children:
+            children += self.find_all_children(child)
+        return children
+
+    def get_last_line_of_scope(self, i):
+        last_line = max(node.end_point[0] for node in self.nodes[i])
+        return last_line
+
+    def close_small_gaps(self):
+        # a "closing" operation on the integers in set.
+        # if i and i+2 are in there but i+1 is not, I want to add i+1
+        # Create a new set for the "closed" lines
+        closed_show = set(self.show_lines)
+        sorted_show = sorted(self.show_lines)
+        for i in range(len(sorted_show) - 1):
+            if sorted_show[i + 1] - sorted_show[i] == 2:
+                closed_show.add(sorted_show[i] + 1)
+
+        # pick up adjacent blank lines
+        for i, line in enumerate(self.lines):
+            if i not in closed_show:
+                continue
+            if self.lines[i].strip() and i < self.num_lines - 2 and not self.lines[i + 1].strip():
+                closed_show.add(i + 1)
+
+        self.show_lines = closed_show
+
+    def format(self):
+        if not self.show_lines:
+            return ""
+
+        output = ""
+        if self.color:
+            # reset
+            output += "\033[0m\n"
+
+        dots = not (0 in self.show_lines)
+        for i, line in enumerate(self.lines):
+            if i not in self.show_lines:
+                if dots:
+                    if self.line_number:
+                        output += "...⋮...\n"
+                    else:
+                        output += "⋮\n"
+                    dots = False
+                continue
+
+            if i in self.lines_of_interest and self.mark_lois:
+                spacer = "█"
+                if self.color:
+                    spacer = f"\033[31m{spacer}\033[0m"
+            else:
+                spacer = "│"
+
+            line_output = f"{spacer}{self.output_lines.get(i, line)}"
+            if self.line_number:
+                line_output = f"{i + 1: 3}" + line_output
+            output += line_output + "\n"
+
+            dots = True
+
+        return output
+
+    def add_parent_scopes(self, i):
+        if i in self.done_parent_scopes:
+            return
+        self.done_parent_scopes.add(i)
+
+        if i >= len(self.scopes):
+            return
+
+        for line_num in self.scopes[i]:
+            head_start, head_end = self.header[line_num]
+            if head_start > 0 or self.show_top_of_file_parent_scope:
+                self.show_lines.update(range(head_start, head_end))
+
+            if self.last_line:
+                last_line = self.get_last_line_of_scope(line_num)
+                self.add_parent_scopes(last_line)
+
+    def walk_tree(self, node, depth=0):
+        start = node.start_point
+        end = node.end_point
+
+        start_line = start[0]
+        end_line = end[0]
+        size = end_line - start_line
+
+        self.nodes[start_line].append(node)
+
+        # dump(start_line, end_line, node.text)
+        if self.verbose and node.is_named:
+            """
+            for k in dir(node):
+                print(k, getattr(node, k))
+            """
+            print(
+                "   " * depth,
+                node.type,
+                f"{start_line}-{end_line}={size + 1}",
+                node.text.splitlines()[0],
+                self.lines[start_line],
+            )
+
+        if size:
+            self.header[start_line].append((size, start_line, end_line))
+
+        for i in range(start_line, end_line + 1):
+            self.scopes[i].add(start_line)
+
+        for child in node.children:
+            self.walk_tree(child, depth + 1)
+
+        return start_line, end_line