cecli-dev 0.100.6rc4__tar.gz → 0.100.6rc6__tar.gz

{cecli_dev-0.100.6rc4 → cecli_dev-0.100.6rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.100.6rc4
+Version: 0.100.6rc6
 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.6rc4 → cecli_dev-0.100.6rc6}/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.6rc4 → cecli_dev-0.100.6rc6}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.100.6rc4'
-__version_tuple__ = version_tuple = (0, 100, 6, 'rc4')
+__version__ = version = '0.100.6rc6'
+__version_tuple__ = version_tuple = (0, 100, 6, 'rc6')
 
-__commit_id__ = commit_id = 'g1ad8d13a1'
+__commit_id__ = commit_id = 'gb2b12bdf9'

{cecli_dev-0.100.6rc4 → cecli_dev-0.100.6rc6}/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.6rc4 → cecli_dev-0.100.6rc6}/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.6rc4 → cecli_dev-0.100.6rc6}/cecli/helpers/conversation/integration.py

@@ -842,7 +842,7 @@ class ConversationChunks:
 
             user_msg = {
                 "role": "user",
-                "content": f"Hash-Prefixed Context For:\n{rel_fname}\n\n{context_content}",
+                "content": f"ID-Prefixed Context For:\n{rel_fname}\n\n{context_content}",
             }
 
             assistant_msg = {

{cecli_dev-0.100.6rc4 → cecli_dev-0.100.6rc6}/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.6rc4 → cecli_dev-0.100.6rc6}/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,7 +41,7 @@ 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::` (the content id with the :: demarcator). For empty files, use `@000` as the "
                 "content ID references."
             ),
             "parameters": {
@@ -64,25 +65,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"
                                     ),
                                 },
                             },
@@ -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.6rc4 → cecli_dev-0.100.6rc6}/cecli/tools/read_range.py

@@ -27,24 +27,21 @@ class Tool(BaseTool):
         "function": {
             "name": "ReadRange",
             "description": (
-                "Get content ID prefixes of content between start and end markers in files."
+                "Get content ID prefixed content between start and end markers in files."
                 " This is useful for files you are attempting to edit and for understanding their structure."
                 " Accepts an array of `read` objects, each with file_path, range_start, range_end."
-                " These values should be lines of content in the file. They can contain up to 3"
-                " lines of content but newlines should generally be avoided. Avoid using generic keywords and"
+                " They can contain up to 3 lines of content. Avoid using singular generic keywords and"
                 " symbols. Special markers @000 and 000@ represent the file boundaries and can be"
                 " used for range_start and range_end for the first and last lines of the file"
                 " 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 content IDs cannot be used as the range_start and range_end values."
-                " These lookups will fail."
                 " 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 to cli tools for reading files."
-                " Calling this tool sequentially on increasingly finer grained searchers "
-                " will help with getting outlines of important structural features"
+                " 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."
             ),
             "parameters": {
                 "type": "object",
@@ -416,6 +413,22 @@ class Tool(BaseTool):
                             )
                             continue
 
+                    if best_pair is None:
+                        error_outputs.append(
+                            cls.format_error(
+                                coder,
+                                (
+                                    f"End pattern '{range_end}' not found after start pattern in"
+                                    f" {file_path}."
+                                ),
+                                file_path,
+                                range_start,
+                                range_end,
+                                read_index,
+                            )
+                        )
+                        continue
+
                     s_idx, e_idx = best_pair
                     s_idx, e_idx = cls._extend_range_with_stub(
                         coder, abs_path, s_idx, e_idx, num_lines
@@ -531,10 +544,10 @@ class Tool(BaseTool):
                     and e_idx >= 0
                     and e_idx < len(hashed_lines)
                 ):
-                    hashed_slice = hashed_lines[s_idx : e_idx + 1]
+                    # hashed_slice = hashed_lines[s_idx : e_idx + 1]
                     if is_already_up_to_date:
                         model_response = cls.format_model_response(
-                            coder, rel_path, s_idx, e_idx, hashed_slice, current=True
+                            coder, rel_path, s_idx, e_idx, hashed_lines, current=True
                         )
 
                         if model_response not in already_up_to_set:
@@ -542,7 +555,7 @@ class Tool(BaseTool):
                             already_up_to_details.append(model_response)
                     else:
                         model_response = cls.format_model_response(
-                            coder, rel_path, s_idx, e_idx, hashed_slice
+                            coder, rel_path, s_idx, e_idx, hashed_lines
                         )
 
                         if model_response not in new_context_set:
@@ -625,7 +638,7 @@ class Tool(BaseTool):
             return handle_tool_error(coder, tool_name, e)
 
     @classmethod
-    def format_model_response(cls, coder, rel_path, s_idx, e_idx, hashed_slice, current=False):
+    def format_model_response(cls, coder, rel_path, s_idx, e_idx, hashed_lines, current=False):
         """Format a file's context range as hash-prefixed lines for the model."""
         # Read file content for stub lookups
         try:
@@ -633,17 +646,15 @@ class Tool(BaseTool):
 
             abs_path, _ = resolve_paths(coder, rel_path)
             last_turn = cls._last_read_turn[abs_path] or 0
-            content = coder.io.read_text(abs_path)
-            file_lines = content.splitlines() if content else None
         except Exception:
-            file_lines = None
+            pass
 
         lines = []
 
         # Try to return structural stub information instead of raw hashed lines
         try:
-            if file_lines is not None and current and coder.turn_count - last_turn >= 2:
-                num_lines = len(file_lines)
+            if hashed_lines and current and coder.turn_count - last_turn >= 2:
+                num_lines = len(hashed_lines)
 
                 start_stub_s, start_stub_e = cls._extend_range_with_stub(
                     coder, abs_path, s_idx, s_idx, num_lines
@@ -665,9 +676,6 @@ class Tool(BaseTool):
                     end_found = False
 
                 if start_found or end_found:
-                    hashed_content = hashline(content)
-                    hashed_lines = hashed_content.splitlines()
-
                     if start_found:
                         lines.append(
                             f"File {rel_path} Snapshot (Lines {start_stub_s + 1} - {start_stub_e + 1}):"
@@ -692,13 +700,13 @@ class Tool(BaseTool):
             pass
 
         lines = [f"File {rel_path} Snapshot (Lines {s_idx + 1} - {e_idx + 1}):"]
-        total = len(hashed_slice)
+        total = e_idx - s_idx
         if total <= 15:
-            lines.extend(hashed_slice)
+            lines.extend(hashed_lines[s_idx : e_idx + 1])
         else:
-            lines.extend(hashed_slice[:5])
+            lines.extend(hashed_lines[s_idx : s_idx + 5])
             lines.append("...⋮...")
-            lines.extend(hashed_slice[-5:])
+            lines.extend(hashed_lines[e_idx - 4 : e_idx + 1])
         lines.append("")
         return "\n".join(lines)
 

{cecli_dev-0.100.6rc4 → cecli_dev-0.100.6rc6}/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.6rc4 → cecli_dev-0.100.6rc6}/cecli_dev.egg-info/PKG-INFO

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