cecli-dev 0.100.6rc5__tar.gz → 0.100.6rc7__tar.gz

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.6rc5
+Version: 0.100.6rc7
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/__init__.py

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

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.6rc5'
-__version_tuple__ = version_tuple = (0, 100, 6, 'rc5')
+__version__ = version = '0.100.6rc7'
+__version_tuple__ = version_tuple = (0, 100, 6, 'rc7')
 
-__commit_id__ = commit_id = 'g468a7f73e'
+__commit_id__ = commit_id = 'g7f1d0176c'

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/coders/agent_coder.py

@@ -239,20 +239,6 @@ class AgentCoder(Coder):
         if self.loaded_custom_tools:
             self.io.tool_output(f"Loaded custom tools: {', '.join(self.loaded_custom_tools)}")
 
-        skills = self.skills_manager.find_skills()
-        if skills:
-            skills_list = []
-            for skill in skills:
-                skills_list.append(skill.name)
-            joined_skills = ", ".join(skills_list)
-            self.io.tool_output(f"Available Skills: {joined_skills}")
-
-        registry = AgentService.get_registry()
-        if registry:
-            names = sorted(registry.keys())
-            joined_names = ", ".join(names)
-            self.io.tool_output(f"Available Subagents: {joined_names}")
-
     def get_local_tool_schemas(self):
         """Returns the JSON schemas for all local tools using the tool registry."""
         schemas = []

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/coders/base_coder.py

@@ -778,91 +778,118 @@ class Coder(metaclass=UsageMeta):
         """Get CUR messages from ConversationManager."""
         return ConversationService.get_manager(self).get_messages_dict(MessageTag.CUR)
 
+    @staticmethod
+    def _strip_provider(model_name: str) -> str:
+        """Remove provider prefix from model name (e.g., 'openai/gpt-4' -> 'gpt-4')."""
+        if "/" in model_name:
+            return model_name.split("/", 1)[1]
+        return model_name
+
     def get_announcements(self):
-        lines = []
-        lines.append(f"cecli v{__version__}")
+        sections = {}
 
-        # Model
+        # --- MODELS ---
         main_model = self.main_model
-        weak_model = main_model.weak_model
+
+        models_items = [f"{self._strip_provider(main_model.name)} (main)"]
         agent_model = main_model.agent_model
+        weak_model = main_model.weak_model
 
-        if weak_model is not main_model:
-            prefix = "Main model"
-        else:
-            prefix = "Model"
+        if agent_model and agent_model.name != main_model.name:
+            models_items.append(f"{self._strip_provider(agent_model.name)} (agent)")
+
+        if weak_model and weak_model.name != main_model.name:
+            models_items.append(f"{self._strip_provider(weak_model.name)} (weak)")
+        if self.edit_format == "architect":
+            models_items.append(f"{self._strip_provider(main_model.editor_model.name)} (editor)")
+
+        sections["Models"] = {"items": models_items}
 
-        output = f"{prefix}: {main_model.name} with {self.edit_format} edit format"
+        # --- SETTINGS ---
+        settings_items = []
 
-        # Check for thinking token budget
+        # Edit format
+        settings_items.append(f"{self.edit_format} (edit format)")
+
+        # Thinking tokens
         thinking_tokens = main_model.get_thinking_tokens()
         if thinking_tokens:
-            output += f", {thinking_tokens} think tokens"
+            settings_items.append(f"{thinking_tokens} think tokens")
 
-        # Check for reasoning effort
+        # Reasoning effort
         reasoning_effort = main_model.get_reasoning_effort()
         if reasoning_effort:
-            output += f", reasoning {reasoning_effort}"
+            settings_items.append(f"reasoning {reasoning_effort}")
 
+        # Prompt cache
         if self.add_cache_headers or main_model.caches_by_default:
-            output += ", prompt cache"
-        if main_model.info.get("supports_assistant_prefill"):
-            output += ", infinite output"
-        if self.copy_paste_mode:
-            output += ", copy/paste mode"
+            settings_items.append("prompt cache")
 
-        lines.append(output)
+        # Infinite output
+        if main_model.info.get("supports_assistant_prefill"):
+            settings_items.append("infinite output")
 
-        if self.edit_format == "architect":
-            output = (
-                f"Editor model: {main_model.editor_model.name} with"
-                f" {main_model.editor_edit_format} edit format"
-            )
-            lines.append(output)
+        # Copy/paste mode
+        if self.copy_paste_mode:
+            settings_items.append("copy/paste mode")
 
-        if weak_model is not main_model:
-            output = f"Weak model: {weak_model.name}"
-            lines.append(output)
+        if settings_items:
+            sections["Settings"] = {"items": settings_items}
 
-        if agent_model is not main_model:
-            output = f"Agent model: {agent_model.name}"
-            lines.append(output)
+        # --- ENVIRONMENT ---
+        env_items = []
+        repo_map_tokens = None  # Track for later warning check
 
-        # Repo
         if self.repo:
             rel_repo_dir = self.repo.get_rel_repo_dir()
             num_files = len(self.repo.get_tracked_files())
-
-            lines.append(f"Git repo: {rel_repo_dir} with {num_files:,} files")
+            env_items.append(f"{rel_repo_dir} ({num_files:,} files)")
             if num_files > 1000:
-                lines.append(
+                env_items.append(
                     "Warning: For large repos, consider using --subtree-only and .cecli_ignore"
                 )
-                lines.append(f"See: {urls.large_repos}")
+                env_items.append(f"See: {urls.large_repos}")
         else:
-            lines.append("Git repo: none")
+            env_items.append("no git repo")
 
-        # Repo-map
         if self.repo_map:
             map_tokens = self.repo_map.max_map_tokens
             if map_tokens > 0:
                 refresh = self.repo_map.refresh
-                lines.append(f"Repo-map: using {map_tokens} tokens, {refresh} refresh")
-                max_map_tokens = self.get_active_model().get_repo_map_tokens() * 2
-                if map_tokens > max_map_tokens:
-                    lines.append(
-                        f"Warning: map-tokens > {max_map_tokens} is not recommended. Too much"
-                        " irrelevant code can confuse LLMs."
-                    )
+                env_items.append(f"map ({map_tokens} tokens, {refresh} refresh)")
+                repo_map_tokens = map_tokens
             else:
-                lines.append("Repo-map: disabled because map_tokens == 0")
+                env_items.append("repo-map disabled")
         else:
-            lines.append("Repo-map: disabled")
+            env_items.append("repo-map disabled")
+
+        sections["Environment"] = {"items": env_items}
+        # --- CAPABILITIES ---
+        capabilities = {}
+
+        # Sub-agents
+        try:
+            from cecli.helpers.agents.service import AgentService
+
+            registry = AgentService.get_registry()
+            if registry:
+                capabilities["Subagents"] = sorted(registry.keys())
+        except Exception:
+            pass
+
+        # Skills
+        if hasattr(self, "skills_manager") and self.skills_manager:
+            try:
+                skills = self.skills_manager.find_skills()
+                if skills:
+                    capabilities["Skills"] = [s.name for s in skills]
+            except Exception:
+                pass
 
+        # MCP Servers
         if self.mcp_tools:
             mcp_servers = []
             for server_name, server_tools in self.mcp_tools:
-                # Filter servers per instance configuration
                 if (
                     self.registered_servers["included"]
                     and server_name not in self.registered_servers["included"]
@@ -871,17 +898,49 @@ class Coder(metaclass=UsageMeta):
                 if server_name in self.registered_servers["excluded"]:
                     continue
                 mcp_servers.append(server_name)
-
             if mcp_servers:
-                lines.append(f"MCP servers configured: {', '.join(mcp_servers)}")
+                capabilities["Servers"] = mcp_servers
+
+        if capabilities:
+            # sections["Extensions"] = {"subsections": capabilities}
+            sections["Environment"]["subsections"] = capabilities
+
+        # --- RENDER ---
+        lines = []
+
+        # Version line (CLI only; TUI has its own banner)
+        if not self.args.tui:
+            lines.append(f"cecli v{__version__}")
+
+        for name, section in sections.items():
+            if "items" in section:
+                lines.append(f"{name:15s}" + " • ".join(section["items"]))
+            if "subsections" in section:
+                last_key = next(reversed(section["subsections"]))
+                # lines.append(name)
+                for sub_name, sub_items in section["subsections"].items():
+                    connector = "└─" if sub_name == last_key else "├─"
+                    lines.append(f" {connector} {sub_name:10} {' • '.join(sub_items)}")
+
+        # Repo-map max_tokens warning
+        if repo_map_tokens is not None:
+            max_map_tokens = self.get_active_model().get_repo_map_tokens() * 2
+            if repo_map_tokens > max_map_tokens:
+                lines.append(
+                    f"Warning: map-tokens > {max_map_tokens} is not recommended. Too much"
+                    " irrelevant code can confuse LLMs."
+                )
 
+        # Read-only stubs
         for fname in self.abs_read_only_stubs_fnames:
             rel_fname = self.get_rel_fname(fname)
             lines.append(f"Added {rel_fname} to the chat (read-only stub).")
 
+        # Restored conversation
         if ConversationService.get_manager(self).get_messages_dict(MessageTag.DONE):
             lines.append("Restored previous conversation history.")
 
+        # Multiline mode
         if self.io.multiline_mode and not self.args.tui:
             lines.append("Multiline mode: Enabled. Enter inserts newline, Alt-Enter submits text")
 

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/helpers/conversation/files.py

@@ -281,8 +281,8 @@ class ConversationFiles:
             diff_message = {
                 "role": "user",
                 "content": (
-                    f"{rel_fname} has been updated. Review this git diff of the changes to"
-                    f" ensure the modifications are intended:\n\n{diff}"
+                    f"{rel_fname} has been updated. Review this diff of the changes to"
+                    f" ensure all modifications are appropriate:\n\n{diff}"
                 ),
             }
 
@@ -290,7 +290,7 @@ class ConversationFiles:
                 "role": "assistant",
                 "content": (
                     f"Thank you for sharing this diff of the updates to {rel_fname}."
-                    " I will review their contents next turn."
+                    " I will review their contents."
                 ),
             }
 

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/helpers/hashline.py

@@ -236,6 +236,84 @@ def extract_hashline_range(
     return original_range_content
 
 
+def resolve_content_to_hashline_ids(
+    original_content: str,
+    start_value: str,
+    end_value: str = None,
+) -> tuple:
+    """
+    Resolve potential line content values to proper hashline content IDs.
+
+    If start_value or end_value does not look like a content ID (hash),
+    search for the content in the original file. If found exactly once,
+    return the hash ID for that line instead.
+
+    This handles the case where LLMs return entire line content or fragments
+    instead of content IDs in edit parameters.
+
+    Args:
+        original_content: Original file content (without hash prefixes)
+        start_value: The start_line value from the edit
+        end_value: The end_line value from the edit (optional)
+
+    Returns:
+        tuple: (resolved_start, resolved_end) with hash IDs or original values
+               unchanged if resolution is not possible
+    """
+    if not original_content:
+        return start_value, end_value
+
+    def _looks_like_content_id(value: str) -> bool:
+        """Check if value looks like a content ID rather than line content."""
+        if value in ("@000", "000@"):
+            return True
+        # Try to normalize - if it succeeds, it's a valid content ID
+        try:
+            normalize_hashline(value)
+            return True
+        except (ContentHashError, ValueError):
+            return False
+
+    def _resolve_value(value: str) -> str:
+        if value is None:
+            return value
+        if _looks_like_content_id(value):
+            return value
+
+        # Value doesn't look like a content ID - try to find it as line content
+        lines = original_content.splitlines()
+        value_stripped = value.rstrip("\r\n")
+
+        # First try exact match (full line content)
+        matching_indices = [
+            i for i, line in enumerate(lines) if line.rstrip("\r\n") == value_stripped
+        ]
+
+        if len(matching_indices) == 1:
+            idx = matching_indices[0]
+            hp = HashPos(original_content)
+            hash_id = hp.generate_public_id(lines[idx], idx)
+            return hash_id + "::"
+
+        # If no exact match, try substring match (value might be a fragment)
+        # Only resolve if exactly one line contains the value
+        containing_indices = [i for i, line in enumerate(lines) if value_stripped in line]
+
+        if len(containing_indices) == 1:
+            idx = containing_indices[0]
+            hp = HashPos(original_content)
+            hash_id = hp.generate_public_id(lines[idx], idx)
+            return hash_id + "::"
+
+        # Can't resolve uniquely - return original value
+        return value
+
+    resolved_start = _resolve_value(start_value)
+    resolved_end = _resolve_value(end_value) if end_value is not None else end_value
+
+    return resolved_start, resolved_end
+
+
 def find_best_line(content, target_line_num, content_to_lines, used_lines, hashlines):
     """
     Find the best matching line for given content near target_line_num.

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/tools/edit_text.py

@@ -2,6 +2,7 @@ from cecli.helpers.hashline import (
     ContentHashError,
     apply_hashline_operations,
     get_hashline_diff,
+    resolve_content_to_hashline_ids,
     strip_hashline,
 )
 from cecli.tools.utils.base_tool import BaseTool
@@ -40,8 +41,9 @@ class Tool(BaseTool):
                 "Can handle an array of up to 10 edits across multiple files. "
                 "Each edit must include its own file_path and operation type. "
                 "Use content ID ranges with the start_line and end_line parameters with format "
-                "`{4 char hash}` (without the braces). For empty files, use `@000` as the "
-                "content ID references."
+                "`content_id::` (the content id with the :: demarcator). For empty files, use `@000` as the "
+                "content ID references. "
+                "Edits within a file must not be adjacent or overlapping."
             ),
             "parameters": {
                 "type": "object",
@@ -64,25 +66,24 @@ class Tool(BaseTool):
                                         " after start_line). Defaults to 'replace'."
                                     ),
                                 },
-                                "text": {
+                                "start_line": {
                                     "type": "string",
                                     "description": (
-                                        "Text content for replace/insert operations. "
-                                        "Not required for delete operations."
+                                        "Content ID for start line. Only include the id and demarcator."
                                     ),
                                 },
-                                "start_line": {
+                                "end_line": {
                                     "type": "string",
                                     "description": (
-                                        "content ID for start line: `{4 char hash}` (without "
-                                        "the braces)"
+                                        "Content ID for end line. Only include the id and demarcator."
                                     ),
                                 },
-                                "end_line": {
+                                "text": {
                                     "type": "string",
                                     "description": (
-                                        "content ID for end line: `{4 char hash}` (without the"
-                                        " braces)"
+                                        "Text content for replace operations. "
+                                        "Empty string for delete operations. "
+                                        "Do not include content IDs inside replacement text"
                                     ),
                                 },
                             },
@@ -91,7 +92,6 @@ class Tool(BaseTool):
                         "description": "Array of edits to apply.",
                     },
                     "change_id": {"type": "string"},
-                    "dry_run": {"type": "boolean", "default": False},
                 },
                 "required": ["edits"],
             },
@@ -186,6 +186,13 @@ class Tool(BaseTool):
                             edit_start_line = edit.get("start_line")
                             edit_end_line = edit.get("end_line")
 
+                            # Try to resolve line content values to content IDs
+                            # This handles cases where LLMs pass actual line content
+                            # instead of content ID markers
+                            edit_start_line, edit_end_line = resolve_content_to_hashline_ids(
+                                original_content, edit_start_line, edit_end_line
+                            )
+
                             # Validate required fields based on operation type
                             if operation in ("replace", "insert"):
                                 if edit_text is None:

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/tools/explore_code.py

@@ -120,7 +120,10 @@ class Tool(BaseTool):
 
                 try:
                     if action == "search":
-                        results = c.search(symbol, limit=limit)
+                        # Sanitize symbol: Cymbal's CLI interprets hyphens as SQL operators.
+                        # Replace hyphens with underscores (common in code) and strip special chars.
+                        safe_symbol = symbol.replace("-", "_") if symbol else symbol
+                        results = c.search(safe_symbol, limit=limit)
                         all_results.append(cls._format_search_results(results, symbol))
                     elif action == "investigate":
                         symbol_name = symbol
@@ -131,8 +134,11 @@ class Tool(BaseTool):
                                 file_hint = parts[0]
                                 symbol_name = parts[1]
 
+                        # Sanitize for Cymbal search
+                        safe_name = symbol_name.replace("-", "_") if symbol_name else symbol_name
+
                         try:
-                            investigation = c.investigate(symbol_name, file_hint)
+                            investigation = c.investigate(safe_name, file_hint)
                             all_results.append(
                                 cls._format_investigation_results(investigation, symbol)
                             )
@@ -151,7 +157,8 @@ class Tool(BaseTool):
                             else:
                                 raise e
                     elif action == "find_references":
-                        references = c.find_references(symbol, limit=limit)
+                        safe_symbol = symbol.replace("-", "_") if symbol else symbol
+                        references = c.find_references(safe_symbol, limit=limit)
                         all_results.append(cls._format_reference_results(references, symbol))
                     else:
                         all_failed_queries.append(

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/tools/read_range.py

@@ -36,12 +36,13 @@ class Tool(BaseTool):
                 " respectively. Line numbers may also be used for range lookups."
                 " It is best to use function names, variable declarations and other meaningful identifiers"
                 " as range_start and range_end values."
-                " Do not use both of the special markers together on non-empty file."
                 " Do not use the same pattern for the range_start and range_end."
                 " Do not use empty strings for the range_start and range_end."
-                " Prefer using this tool over cli tools for reading files."
-                " Calling this tool sequentially on increasingly finer grained searches "
-                " will help with understanding important structural features."
+                " Use this tool instead of cli tools for reading file contents."
+                " Line number and special marker ranges greater than 200 lines will return"
+                " preview content for further, more scoped investigation."
+                " Call this tool sequentially on increasingly finer grained searches "
+                " to help with understanding important structural features in large files."
             ),
             "parameters": {
                 "type": "object",
@@ -436,7 +437,7 @@ class Tool(BaseTool):
                 # For structured searches (line numbers, special markers) or mixed searches
                 # (one special marker, one text pattern), cap large ranges with preview
                 # Text pattern searches are not subject to capping
-                if (both_structured or mixed_special_search) and (e_idx - s_idx > 200):
+                if both_structured or (mixed_special_search and (e_idx - s_idx > 200)):
                     preview = cls._get_range_preview(
                         abs_path, coder.io, start_idx=s_idx, end_idx=e_idx, line_numbers=True
                     )

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/tools/utils/helpers.py

@@ -338,6 +338,9 @@ def format_tool_result(
             result_for_llm += f" Change ID: {change_id}."
         if diff_snippet:
             result_for_llm += f" Diff snippet:\n{diff_snippet}"
+        else:
+            result_for_llm += " A diff will be provided in a future message."
+
         return result_for_llm
 
 

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli/tui/app.py

@@ -15,6 +15,7 @@ from textual import events
 from textual.app import App, ComposeResult
 from textual.theme import Theme
 
+from cecli import __version__
 from cecli.editor import pipe_editor
 from cecli.helpers.agents.service import AgentService
 from cecli.helpers.coroutines import is_active
@@ -360,7 +361,7 @@ class TUI(App):
 [bold {BANNER_COLORS[2]}]  ▒▒║     ▒▒▒▒▒╗  ▒▒║     ▒▒║     ▒▒║[/bold {BANNER_COLORS[2]}]
 [bold {BANNER_COLORS[3]}]  ▒▒║     ▒▒╔══╝  ▒▒║     ▒▒║     ▒▒║[/bold {BANNER_COLORS[3]}]
 [bold {BANNER_COLORS[4]}]  ╚▒▒▒▒▒▒╗▒▒▒▒▒▒▒╗╚▒▒▒▒▒▒╗▒▒▒▒▒▒▒╗▒▒║[/bold {BANNER_COLORS[4]}]
-[bold {BANNER_COLORS[5]}]   ╚═════╝╚══════╝ ╚═════╝╚══════╝╚═╝[/bold {BANNER_COLORS[5]}]
+[bold {BANNER_COLORS[5]}]   ╚═════╝╚══════╝ ╚═════╝╚══════╝╚═╝ v{__version__}[/bold {BANNER_COLORS[5]}]
 
 """
 

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.6rc5
+Version: 0.100.6rc7
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-0.100.6rc5 → cecli_dev-0.100.6rc7}/tests/tools/test_read_range_execute.py

@@ -162,7 +162,7 @@ class TestReadRangeExecute:
         try:
             show = [{"file_path": self.test_file, "range_start": "5", "range_end": "10"}]
             result = self.Tool.execute(self.coder, show)
-            assert "Snapshot" in result
+            assert "File range too large" in result
             assert "line5" in result
             assert "line10" in result
         finally:
@@ -456,7 +456,7 @@ class TestReadRangeExecute:
         cs_patch = patch("cecli.helpers.conversation.ConversationService", mock_cs)
         cs_patch.start()
 
-        mock_coder.io.read_text.side_effect = [content1, content2]
+        mock_coder.io.read_text.side_effect = [content1, content1, content2, content2]
 
         try:
             from cecli.tools.read_range import Tool