cecli-dev 0.99.1__tar.gz → 0.99.2__tar.gz

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.99.1
+Version: 0.99.2
 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.99.1 → cecli_dev-0.99.2}/cecli/__init__.py

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

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.99.1'
-__version_tuple__ = version_tuple = (0, 99, 1)
+__version__ = version = '0.99.2'
+__version_tuple__ = version_tuple = (0, 99, 2)
 
-__commit_id__ = commit_id = 'g587390916'
+__commit_id__ = commit_id = 'g7361036c0'

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/coders/agent_coder.py

@@ -95,7 +95,7 @@ class AgentCoder(Coder):
         super().__init__(*args, **kwargs)
 
     def _setup_agent(self):
-        os.makedirs(".cecli/workspace", exist_ok=True)
+        os.makedirs(".cecli/temp", exist_ok=True)
 
     def _get_agent_config(self):
         """
@@ -1020,7 +1020,7 @@ I will proceed based on the tool results and updated context.""")
                 self.model_kwargs = {
                     "temperature": default_temp + 0.1,
                     "frequency_penalty": default_fp + 0.2,
-                    "presence_penalty": 0.1,
+                    # "presence_penalty": 0.1,
                 }
             else:
                 temperature = nested.getter(self.model_kwargs, "temperature", default_temp)

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/coders/base_coder.py

@@ -229,6 +229,7 @@ class Coder:
                 file_watcher=from_coder.file_watcher,
                 mcp_manager=from_coder.mcp_manager,
                 uuid=from_coder.uuid,
+                repo=from_coder.repo,
             )
             use_kwargs.update(update)  # override to complete the switch
             use_kwargs.update(kwargs)  # override passed kwargs
@@ -328,6 +329,7 @@ class Coder:
         uuid="",
     ):
         # initialize from args.map_cache_dir
+        self.interrupt_event = asyncio.Event()
         self.uuid = generate_unique_id()
         if uuid:
             self.uuid = uuid
@@ -1735,6 +1737,7 @@ class Coder:
 
         self.io.tool_warning("\n\n^C KeyboardInterrupt")
 
+        self.interrupt_event.set()
         self.last_keyboard_interrupt = time.time()
 
     # Old summarization system removed - using context compaction logic instead
@@ -2768,6 +2771,7 @@ class Coder:
 
     def _print_tool_call_info(self, server_tool_calls):
         """Print information about an MCP tool call."""
+        self.io.ring_bell()
         # self.io.tool_output("Preparing to run MCP tools", bold=False)
 
         for server, tool_calls in server_tool_calls.items():
@@ -3039,6 +3043,7 @@ class Coder:
             return prompts.added_files.format(fnames=", ".join(added_fnames))
 
     async def send(self, messages, model=None, functions=None, tools=None):
+        self.interrupt_event.clear()
         self.got_reasoning_content = False
         self.ended_reasoning_content = False
 
@@ -3058,15 +3063,33 @@ class Coder:
         self.token_profiler.start()
 
         try:
-            hash_object, completion = await model.send_completion(
-                messages,
-                functions,
-                self.stream,
-                self.temperature,
-                # This could include any tools, but for now it is just MCP tools
-                tools=tools,
-                override_kwargs=self.model_kwargs.copy(),
+            completion_task = asyncio.create_task(
+                model.send_completion(
+                    messages,
+                    functions,
+                    self.stream,
+                    self.temperature,
+                    # This could include any tools, but for now it is just MCP tools
+                    tools=tools,
+                    override_kwargs=self.model_kwargs.copy(),
+                )
+            )
+            interrupt_task = asyncio.create_task(self.interrupt_event.wait())
+
+            done, pending = await asyncio.wait(
+                {completion_task, interrupt_task},
+                return_when=asyncio.FIRST_COMPLETED,
             )
+
+            if interrupt_task in done:
+                completion_task.cancel()
+                try:
+                    await completion_task
+                except asyncio.CancelledError:
+                    pass
+                raise KeyboardInterrupt
+
+            hash_object, completion = completion_task.result()
             self.chat_completion_call_hashes.append(hash_object.hexdigest())
 
             if not isinstance(completion, ModelResponse):

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/helpers/monorepo/project.py

@@ -11,6 +11,7 @@ class Project:
         self.config = config
         self.name = config["name"]
         self.repo_url = config["repo"]
+        self.ignore_file = config.get("ignore")
         self.base_path = workspace_path / self.name
         self.main_path = self.base_path / "main"
 

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/helpers/monorepo/workspace.py

@@ -24,6 +24,17 @@ class WorkspaceManager:
             project = Project(self.path, proj_cfg)
             project.initialize()
 
+        # Copy ignore files to workspace root
+        for proj_cfg in projects_config:
+            ignore_file = proj_cfg.get("ignore")
+            if ignore_file:
+                ignore_path = Path(ignore_file).expanduser()
+                if ignore_path.exists():
+                    import shutil
+
+                    dest_path = self.path / f"{proj_cfg['name']}.ignore"
+                    shutil.copy2(ignore_path, dest_path)
+
         # Write metadata
         import json
 

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/helpers/skills.py

@@ -35,6 +35,7 @@ class SkillContent:
     references: Dict[str, Path] = field(default_factory=dict)
     scripts: Dict[str, Path] = field(default_factory=dict)
     assets: Dict[str, Path] = field(default_factory=dict)
+    evals: Dict[str, Path] = field(default_factory=dict)
 
 
 class SkillsManager:
@@ -227,6 +228,9 @@ class SkillsManager:
         # Load assets
         assets = self._load_assets(skill_dir)
 
+        # Load evals
+        evals = self._load_evals(skill_dir)
+
         return SkillContent(
             metadata=metadata,
             frontmatter=frontmatter,
@@ -234,6 +238,7 @@ class SkillsManager:
             references=references,
             scripts=scripts,
             assets=assets,
+            evals=evals,
         )
 
     def _load_references(self, skill_dir: Path) -> Dict[str, Path]:
@@ -286,6 +291,23 @@ class SkillsManager:
 
         return assets
 
+    def _load_evals(self, skill_dir: Path) -> Dict[str, Path]:
+        """Load eval files from the evals/ directory."""
+        evals = {}
+        evals_dir = skill_dir / "evals"
+
+        if evals_dir.exists():
+            for eval_file in evals_dir.glob("**/*"):
+                if eval_file.is_file():
+                    try:
+                        # Use relative path as key, store the Path object
+                        rel_path = eval_file.relative_to(evals_dir)
+                        evals[str(rel_path)] = eval_file
+                    except Exception:
+                        continue
+
+        return evals
+
     def get_skill_summary(self, skill_name: str) -> Optional[str]:
         """
         Get a summary of a skill for display purposes.
@@ -315,9 +337,11 @@ class SkillsManager:
         ref_count = len(skill.references)
         script_count = len(skill.scripts)
         asset_count = len(skill.assets)
+        eval_count = len(skill.evals)
 
         summary += (
-            f"Resources: {ref_count} references, {script_count} scripts, {asset_count} assets\n"
+            f"Resources: {ref_count} references, {script_count} scripts, {asset_count} assets,"
+            f" {eval_count} evals\n"
         )
 
         return summary
@@ -540,6 +564,14 @@ class SkillsManager:
                         result += f"- **{asset_name}**: `{asset_path}`\n"
                     result += "\n"
 
+                # Add evals file paths
+                if skill_content.evals:
+                    result += f"#### Evals ({len(skill_content.evals)} file(s))\n\n"
+                    result += "Available eval files:\n\n"
+                    for eval_name, eval_path in skill_content.evals.items():
+                        result += f"- **{eval_name}**: `{eval_path}`\n"
+                    result += "\n"
+
                 result += "---\n\n"
 
             result += "</context>"

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/io.py

@@ -758,6 +758,11 @@ class InputOutput:
             print()
 
     def interrupt_input(self):
+        if self.coder:
+            coder = self.coder()
+            if coder and hasattr(coder, "interrupt_event"):
+                coder.interrupt_event.set()
+
         if self.prompt_session and self.prompt_session.app:
             # Store any partial input before interrupting
             self.placeholder = self.prompt_session.app.current_buffer.text
@@ -1301,6 +1306,7 @@ class InputOutput:
                 self.user_input(f"{question} - {res}", log_only=False)
             else:
                 # Ring the bell if needed
+                self.notify_user_input_required()
                 self.ring_bell()
                 self.start_spinner("Awaiting Confirmation...", False)
 
@@ -1708,22 +1714,28 @@ class InputOutput:
 
         return None  # Unknown system
 
+    def _send_notification(self):
+        if self.notifications_command:
+            try:
+                result = subprocess.run(self.notifications_command, shell=True, capture_output=True)
+                if result.returncode != 0 and result.stderr:
+                    error_msg = result.stderr.decode("utf-8", errors="replace")
+                    self.tool_warning(f"Failed to run notifications command: {error_msg}")
+            except Exception as e:
+                self.tool_warning(f"Failed to run notifications command: {e}")
+        else:
+            print("\a", end="", flush=True)  # Ring the bell
+
+    def notify_user_input_required(self):
+        """Send a notification that user input is required."""
+        if self.notifications:
+            self._send_notification()
+
     def ring_bell(self):
         """Ring the terminal bell if needed and clear the flag"""
         if self.bell_on_next_input and self.notifications:
-            if self.notifications_command:
-                try:
-                    result = subprocess.run(
-                        self.notifications_command, shell=True, capture_output=True
-                    )
-                    if result.returncode != 0 and result.stderr:
-                        error_msg = result.stderr.decode("utf-8", errors="replace")
-                        self.tool_warning(f"Failed to run notifications command: {error_msg}")
-                except Exception as e:
-                    self.tool_warning(f"Failed to run notifications command: {e}")
-            else:
-                print("\a", end="", flush=True)  # Ring the bell
-            self.bell_on_next_input = False  # Clear the flag
+            self._send_notification()
+            self.bell_on_next_input = False
 
     def toggle_multiline_mode(self):
         """Toggle between normal and multiline input modes"""

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/main.py

@@ -610,7 +610,7 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
     if hasattr(args, "hooks") and args.hooks is not None:
         args.hooks = convert_yaml_to_json_string(args.hooks)
     if hasattr(args, "workspaces") and args.workspaces is not None:
-        args.hooks = convert_yaml_to_json_string(args.workspaces)
+        args.workspaces = convert_yaml_to_json_string(args.workspaces)
 
     # Interpolate environment variables in all string arguments
     for key, value in vars(args).items():

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/prompts/agent.yml

@@ -18,13 +18,15 @@ main_system: |
   <context name="role_and_directives">
   ## Core Directives
   **Act Proactively**: Autonomously use discovery and management tools (`ViewFilesAtGlob`, `ViewFilesMatching`, `Ls`, `ContextManager`) to fulfill the request. Chain tool calls across multiple turns for continuous exploration.
-  **Be Decisive**: Trust your findings. Do not repeat identical searches or ask redundant questions once a path is established.
+  **Be Decisive**: Trust your findings. Do not repeat identical searches or ask redundant questions.
   **Be Efficient**: Batch tool calls when tools allow you to. Respect usage limits while maximizing the utility of each turn.
+  **Be Persistent**: Do not take short cuts. Work through your task until completion. No task takes too long as long as you are making progress towards the goal.
   </context>
 
   <context name="file_format">
   ### 1. FILE FORMAT
   Files are provided in "hashline" format. Each line starts with a case-sensitive content hash followed by `::`.
+  Do not attempt to write these content hashes. They are automatically generated, maintained, and subject to change.
   
   **Example File Format :**
   il9n::#!/usr/bin/env python3
@@ -43,33 +45,30 @@ main_system: |
   5. **Finished**: Use the `Finished` tool only after verifying the solution. Briefly summarize the changes for the user.
 
   ## Todo List Management
-  - Use `UpdateTodoList` every 3-10 tool calls to keep the state synchronized.
-  - Break complex tasks into granular steps so they remain tractable and context-efficient
+  - Use `UpdateTodoList` to keep the state synchronized as you complete subtasks.
+  - Break complex tasks and long edits into granular steps so they remain tractable and context-efficient
 
-  ### Editing Tools (Precision Protocol)
-  Files use leading hashline content id prefixes inside brackets, i.e. `[{{4 char hash}}]{{line content}}`. 
-  Do not attempt to write these content ids. They are automatically generated.
+  ### Editing Tool Protocol
 
   **MANDATORY Two-Phase Safety Protocol**:
-    1. **Phase 1**: Use `ShowContext` to get the hashline-prefixed content around the pattern to modify. Capture entire functions, logical blocks and closures. You may use multiple calls.
+    1. **Phase 1**: Use `ShowContext` to gather the hashline-prefixed content of the section to modify. Capture entire functions, logical blocks and closures.
     2. **Phase 2**: Execute the edit (`ReplaceText`, `InsertText`, `DeleteText`) using the verified hashlines prefixes from the `ShowContext` tool.
    
   **Atomic Scope:** Include the **entire function or logical block**. Never return partial syntax or broken closures. Do not attempt to replace just the beginning or end of a closure.
-  **Indentation**: Preserve all whitespace (spaces, tabs, and newlines).   
+  **Indentation**: Preserve all necessary whitespace (spaces, tabs, and newlines) and stylistic indentation.   
   </context>
   
-  Use the `.cecli/workspace` directory for all temporary, test, or scratch files.
+  Use the `.cecli/temp` directory for all temporary, test, or scratch files.
   Always reply to the user in {language}.
 
 system_reminder: |
   <context name="critical_reminders">
   ## Reminders
   **Strict Scope**: Stay on task. Do not alter functionality and syntax that is out of scope or pursue unrequested refactors. Do not attempt to modify large files in one shot. Work step by step.
-  **Context Hygiene**: Remove files or skills from context using `ContextManager` or `RemoveSkill` once they are no longer needed to save tokens and prevent confusion.
+  **Context Hygiene**: Remove files and loaded skills from context using `ContextManager` or `RemoveSkill` once they are no longer needed to save tokens and prevent confusion.
   **Turn Management**: Tool calls trigger the next turn. Do not include tool calls in your final summary to the user. You must use `ShowContext` to view the relevant hashline range before each edit.
-  **Sandbox**: Use `.cecli/workspace` for all verification and temporary logic.
-  **Novelty**: Do not repeat phrases in your responses to the user. You do not need to declare you understand the task. Simply proceed. Only give status when you have new information.
-  **Patience**: Do not take short cuts. Work through your task until completion. No task takes too long as long as you are making progress towards the goal.
+  **Sandbox**: Use `.cecli/temp` for all verification and temporary logic.
+  **Novelty**: Do not repeat phrases in your responses to the user. You do not need to declare you understand the task. Simply proceed. Only give status updates when you have new information. 
 
   {lazy_prompt}
   {shell_cmd_reminder}

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/prompts/base.yml

@@ -98,7 +98,7 @@ compaction_prompt: |
   - (e.g., "Discovered that the connection timeout error is triggered by the `RetryPolicy` class.")
   - (e.g., "Successfully refactored the `validate_input` function to handle null bytes.")
   - (e.g., "Reverted changes to `db.py` after determining the issue was in the environment config instead.")
-  - (e.g., "Verified that the fix works in isolation using a temporary script in `.cecli/workspace`.")
+  - (e.g., "Verified that the fix works in isolation using a temporary script in `.cecli/temp`.")
 
   ### 3. Current Technical Context
   - **Files In-Scope**: List paths currently being edited or actively referenced.

{cecli_dev-0.99.1 → cecli_dev-0.99.2}/cecli/repo.py

@@ -95,6 +95,12 @@ class GitRepo:
         self.subtree_only = subtree_only
         self.git_commit_verify = git_commit_verify
         self.ignore_file_cache = {}
+        self.is_workspace = False
+        self.workspace_path = None
+        self.workspace_config = {}
+        self.workspace_ignore_specs = {}
+        self.workspace_ignore_ts = {}
+        # Workspace detection and config loading occurs later in __init__
 
         if git_dname:
             check_fnames = [git_dname]
@@ -129,27 +135,40 @@ class GitRepo:
             raise FileNotFoundError
 
         self._init_repo_path = repo_paths.pop()
-        self.init_repo()
-
-        if cecli_ignore_file:
-            self.cecli_ignore_file = Path(cecli_ignore_file)
 
         # Detect if we're in a workspace
-        self.workspace_path = self._detect_workspace_path(self.root)
+        self.workspace_path = self._detect_workspace_path(self._init_repo_path)
         if self.workspace_path:
-            self.io.tool_output(f"Working in workspace: {self.workspace_path.name}")
+            self.is_workspace = True
+
+            try:
+                from cecli.helpers.monorepo.config import load_workspace_config
+
+                self.workspace_config = load_workspace_config(name=self.workspace_path.name)
+            except Exception:
+                self.workspace_config = {}
+
+            self.refresh_cecli_ignore()
+
+        self.init_repo()
+        if cecli_ignore_file:
+            self.cecli_ignore_file = Path(cecli_ignore_file)
 
     def init_repo(self):
         if not self.repo:
             self.repo = git.Repo(self._init_repo_path, odbt=git.GitCmdObjectDB)
             self.root = utils.safe_abs_path(self.repo.working_tree_dir)
 
+        if self.is_workspace:
+            self.root = self.workspace_path
+
         try:
             commit = self.repo.head.commit
             return commit
         except ANY_GIT_ERROR:
-            self.repo = git.Repo(self._init_repo_path, odbt=git.GitCmdObjectDB)
-            self.root = utils.safe_abs_path(self.repo.working_tree_dir)
+            if not self.is_workspace:
+                self.repo = git.Repo(self._init_repo_path, odbt=git.GitCmdObjectDB)
+                self.root = utils.safe_abs_path(self.repo.working_tree_dir)
 
     def _detect_workspace_path(self, start_path: str):
         """Check if current directory is within a workspace"""
@@ -612,7 +631,9 @@ class GitRepo:
                 ).splitlines()
 
                 for f in res:
-                    all_files.append(f"{proj_name}/main/{f}")
+                    rel_path = f"{proj_name}/main/{f}"
+                    if not self.ignored_file(rel_path):
+                        all_files.append(rel_path)
             except Exception:
                 continue
 
@@ -625,21 +646,39 @@ class GitRepo:
         if res:
             return res
 
-        path = str(Path(PurePosixPath((Path(self.root) / path).relative_to(self.root))))
+        if self.is_workspace:
+            try:
+                # In workspace mode, try to make it relative to workspace_path first
+                path = str(
+                    Path(
+                        PurePosixPath(
+                            (Path(self.workspace_path) / path).relative_to(self.workspace_path)
+                        )
+                    )
+                )
+            except ValueError:
+                # Fallback to standard relative_to(self.root)
+                path = str(Path(PurePosixPath((Path(self.root) / path).relative_to(self.root))))
+        else:
+            path = str(Path(PurePosixPath((Path(self.root) / path).relative_to(self.root))))
+
         self.normalized_path[orig_path] = path
         return path
 
     def refresh_cecli_ignore(self):
-        if not self.cecli_ignore_file:
+        if not self.cecli_ignore_file and not self.is_workspace:
             return
 
         current_time = time.time()
         if current_time - self.cecli_ignore_last_check < 1:
             return
 
+        if self.is_workspace:
+            self._refresh_workspace_ignores()
+
         self.cecli_ignore_last_check = current_time
 
-        if not self.cecli_ignore_file.is_file():
+        if not self.cecli_ignore_file or not self.cecli_ignore_file.is_file():
             return
 
         mtime = self.cecli_ignore_file.stat().st_mtime
@@ -652,6 +691,35 @@ class GitRepo:
                 lines,
             )
 
+    def _refresh_workspace_ignores(self):
+        if not hasattr(self, "workspace_config") or not self.workspace_config:
+            return
+
+        if not hasattr(self, "workspace_ignore_specs"):
+            self.workspace_ignore_specs = {}
+            self.workspace_ignore_ts = {}
+
+        projects = self.workspace_config.get("projects", [])
+        for proj in projects:
+            proj_name = proj.get("name")
+            ignore_file = proj.get("ignore")
+            if not proj_name or not ignore_file:
+                continue
+
+            ignore_path = self.workspace_path / f"{proj_name}.ignore"
+            if not ignore_path.is_file():
+                continue
+
+            mtime = ignore_path.stat().st_mtime
+            if mtime != self.workspace_ignore_ts.get(proj_name):
+                self.workspace_ignore_ts[proj_name] = mtime
+                self.ignore_file_cache = {}
+                lines = ignore_path.read_text().splitlines()
+                self.workspace_ignore_specs[proj_name] = pathspec.PathSpec.from_lines(
+                    pathspec.patterns.GitWildMatchPattern,
+                    lines,
+                )
+
     def _get_gitignore_spec(self, dir_path):
         """Get or create a GitIgnoreSpec for a directory, caching for performance."""
         dir_path = Path(dir_path).resolve()
@@ -755,6 +823,31 @@ class GitRepo:
             if cwd_path not in fname_path.parents and fname_path != cwd_path:
                 return True
 
+        if self.is_workspace:
+            # Check project-specific ignores
+            try:
+                fname_rel = self.normalize_path(fname)
+                parts = Path(fname_rel).parts
+                if parts:
+                    proj_name = parts[0]
+                    if (
+                        hasattr(self, "workspace_ignore_specs")
+                        and proj_name in self.workspace_ignore_specs
+                    ):
+                        # Check against project-specific spec
+                        # The spec expects paths relative to the project root (usually proj/main/)
+                        if len(parts) > 2 and parts[1] == "main":
+                            proj_rel_path = str(Path(*parts[2:]))
+                        else:
+                            proj_rel_path = str(Path(*parts[1:]))
+
+                        if self.workspace_ignore_specs[proj_name].match_file(proj_rel_path):
+                            return True
+                # If not matched by project-specific ignore, continue to global ignore
+                # but don't return False yet as there might be a global .cecli.ignore
+            except (ValueError, IndexError):
+                pass
+
         if not self.cecli_ignore_file or not self.cecli_ignore_file.is_file():
             return False