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

{cecli_dev-0.98.2 → cecli_dev-0.99.1}/.github/workflows/ubuntu-tests.yml

@@ -56,6 +56,12 @@ jobs:
           -r requirements/requirements-playwright.in \
           ".[help,playwright]"
 
+    - name: Configure Git for tests
+      run: |
+        git config --global user.name "Test User"
+        git config --global user.email "test@example.com"
+        git config --global init.defaultBranch main
+
     - name: Run tests
       run: |
         pytest

{cecli_dev-0.98.2 → cecli_dev-0.99.1}/.github/workflows/windows-tests.yml

@@ -44,6 +44,12 @@ jobs:
         pip install uv
         uv pip install --system pytest pytest-asyncio pytest-mock -r requirements/requirements.in -r requirements/requirements-help.in -r requirements/requirements-playwright.in '.[help,playwright]'
 
+    - name: Configure Git for tests
+      run: |
+        git config --global user.name "Test User"
+        git config --global user.email "test@example.com"
+        git config --global init.defaultBranch main
+
     - name: Run tests
       run: |
         pytest

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.98.2
+Version: 0.99.1
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -108,6 +108,7 @@ LLMs are a part of our lives from here on out so join us in learning about and c
 * [Skills](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/skills.md)
 * [Session Management](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/sessions.md)
 * [Hooks](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/hooks.md)
+* [Workspaces](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/workspaces.md)
 * [Custom Commands](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-commands.md)
 * [Custom System Prompts](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-system-prompts.md)
 * [Custom Tools](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/agent-mode.md#creating-custom-tools)

{cecli_dev-0.98.2 → cecli_dev-0.99.1}/README.md

@@ -22,6 +22,7 @@ LLMs are a part of our lives from here on out so join us in learning about and c
 * [Skills](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/skills.md)
 * [Session Management](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/sessions.md)
 * [Hooks](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/hooks.md)
+* [Workspaces](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/workspaces.md)
 * [Custom Commands](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-commands.md)
 * [Custom System Prompts](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-system-prompts.md)
 * [Custom Tools](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/agent-mode.md#creating-custom-tools)

{cecli_dev-0.98.2 → cecli_dev-0.99.1}/cecli/__init__.py

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

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

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

{cecli_dev-0.98.2 → cecli_dev-0.99.1}/cecli/args.py

@@ -314,6 +314,19 @@ def get_parser(default_config_files, git_root):
         help="Specify TUI Mode configuration as a JSON string",
         default=None,
     )
+    #########
+    group = parser.add_argument_group("Workspace Settings")
+    group.add_argument(
+        "--workspaces",
+        type=str,
+        help="JSON/YAML configuration for workspace initialization",
+    )
+    group.add_argument(
+        "--workspace-name",
+        type=str,
+        help="Specify the workspace name to activate",
+    )
+
     #########
     group = parser.add_argument_group("Agent Settings")
     group.add_argument(

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

@@ -1009,35 +1009,44 @@ I will proceed based on the tool results and updated context.""")
         repetition_warning = None
 
         if repetitive_tools:
+            default_temp = (
+                float(self.get_active_model().use_temperature)
+                if isinstance(self.get_active_model().use_temperature, (int, float, str))
+                else 1
+            )
+            default_fp = 0
+
             if not self.model_kwargs:
                 self.model_kwargs = {
-                    "temperature": (
-                        1
-                        if isinstance(self.get_active_model().use_temperature, bool)
-                        else float(self.get_active_model().use_temperature)
-                    ) + 0.1,
-                    "frequency_penalty": 0.2,
+                    "temperature": default_temp + 0.1,
+                    "frequency_penalty": default_fp + 0.2,
                     "presence_penalty": 0.1,
                 }
             else:
-                temperature = nested.getter(self.model_kwargs, "temperature")
-                freq_penalty = nested.getter(self.model_kwargs, "frequency_penalty")
-                if temperature and freq_penalty:
-                    self.model_kwargs["temperature"] = min(temperature + 0.1, 2)
-                    self.model_kwargs["frequency_penalty"] = min(freq_penalty + 0.1, 1)
+                temperature = nested.getter(self.model_kwargs, "temperature", default_temp)
+                freq_penalty = nested.getter(self.model_kwargs, "frequency_penalty", default_fp)
+
+                self.model_kwargs["temperature"] = temperature + 0.1
+                self.model_kwargs["frequency_penalty"] = freq_penalty + 0.1
 
                 if random.random() < 0.2:
-                    self.model_kwargs["temperature"] = min(
-                        (
-                            1
-                            if isinstance(self.get_active_model().use_temperature, bool)
-                            else float(self.get_active_model().use_temperature)
-                        ),
-                        max(temperature - 0.15, 1),
+                    self.model_kwargs["temperature"] = max(
+                        default_temp,
+                        temperature - 0.15,
+                    )
+                    self.model_kwargs["frequency_penalty"] = max(
+                        default_fp,
+                        freq_penalty - 0.15,
                     )
-                    self.model_kwargs["frequency_penalty"] = min(0, max(freq_penalty - 0.15, 0))
 
-            self.model_kwargs["temperature"] = max(0, min(self.model_kwargs["temperature"], 1))
+            self.model_kwargs["temperature"] = max(
+                0, min(nested.getter(self.model_kwargs, "temperature", default_temp), 1)
+            )
+
+            self.model_kwargs["frequency_penalty"] = max(
+                0, min(nested.getter(self.model_kwargs, "frequency_penalty", default_fp), 1)
+            )
+
             # One twentieth of the time, just straight reset the randomness
             if random.random() < 0.05:
                 self.model_kwargs = {}

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

@@ -58,6 +58,7 @@ from cecli.reasoning_tags import (
 )
 from cecli.repo import ANY_GIT_ERROR, GitRepo
 from cecli.repomap import RepoMap
+from cecli.report import update_error_prefix
 from cecli.run_cmd import run_cmd
 from cecli.sessions import SessionManager
 from cecli.tools.utils.output import print_tool_response
@@ -531,6 +532,11 @@ class Coder:
         has_map_prompt = nested.getter(self, "gpt_prompts.repo_content_prefix")
 
         if use_repo_map and self.repo and has_map_prompt:
+            repo_root = (
+                self.repo.workspace_path
+                if (self.repo and getattr(self.repo, "workspace_path", None))
+                else self.root
+            )
             self.repo_map = RepoMap(
                 map_tokens,
                 self.map_cache_dir,
@@ -542,7 +548,7 @@ class Coder:
                 map_mul_no_files=map_mul_no_files,
                 refresh=map_refresh,
                 max_code_line_length=map_max_line_length,
-                repo_root=self.root,
+                repo_root=repo_root,
                 use_memory_cache=repomap_in_memory,
                 use_enhanced_map=getattr(self.args, "use_enhanced_map", False),
             )
@@ -1508,6 +1514,9 @@ class Coder:
             except (SwitchCoderSignal, SystemExit):
                 raise
             except Exception as e:
+                traceback_str = traceback.format_exc()
+                update_error_prefix(traceback_str)
+
                 if self.verbose or self.args.debug:
                     print(e)
 
@@ -3056,7 +3065,7 @@ class Coder:
                 self.temperature,
                 # This could include any tools, but for now it is just MCP tools
                 tools=tools,
-                override_kwargs=self.model_kwargs,
+                override_kwargs=self.model_kwargs.copy(),
             )
             self.chat_completion_call_hashes.append(hash_object.hexdigest())
 
@@ -3651,13 +3660,14 @@ class Coder:
                 # Continue to get tracked files normally
 
         if self.repo:
-            if not self.repo.cecli_ignore_file or not self.repo.cecli_ignore_file.is_file():
+            if hasattr(self.repo, "workspace_path") and self.repo.workspace_path:
+                files = self.repo.get_workspace_files()
+            elif not self.repo.cecli_ignore_file or not self.repo.cecli_ignore_file.is_file():
                 files = self.repo.get_tracked_files()
             else:
                 files = self.repo.get_non_ignored_files_from_root()
         else:
             files = self.get_inchat_relative_files()
-
         # This is quite slow in large repos
         # files = [fname for fname in files if self.is_file_safe(fname)]
 
@@ -3919,6 +3929,13 @@ class Coder:
         if not self.repo or not self.auto_commits or self.dry_run:
             return
 
+        # Workspace-aware commit logic
+        if hasattr(self.args, "workspace") and self.args.workspace:
+            # We are in a workspace context.
+            # The GitRepo instance (self.repo) should already be pointing to the correct worktree/repo
+            # within the workspace because of the os.chdir in main.py and detection in repo.py.
+            pass
+
         if not context:
             context = self.get_context_from_history(
                 ConversationService.get_manager(self).get_messages_dict(MessageTag.CUR)

{cecli_dev-0.98.2 → cecli_dev-0.99.1}/cecli/commands/__init__.py

@@ -79,6 +79,7 @@ from .utils.registry import CommandRegistry
 from .voice import VoiceCommand
 from .weak_model import WeakModelCommand
 from .web import WebCommand
+from .workspace import WorkspaceCommand
 
 # Register commands
 CommandRegistry.register(AddCommand)
@@ -143,6 +144,7 @@ CommandRegistry.register(UndoCommand)
 CommandRegistry.register(VoiceCommand)
 CommandRegistry.register(WeakModelCommand)
 CommandRegistry.register(WebCommand)
+CommandRegistry.register(WorkspaceCommand)
 
 
 __all__ = [
@@ -220,4 +222,5 @@ __all__ = [
     "VoiceCommand",
     "WeakModelCommand",
     "WebCommand",
+    "WorkspaceCommand",
 ]

cecli_dev-0.99.1/cecli/commands/workspace.py

@@ -0,0 +1,72 @@
+import subprocess
+
+from cecli.commands.utils.base_command import BaseCommand
+
+
+class WorkspaceCommand(BaseCommand):
+    NORM_NAME = "workspace"
+    DESCRIPTION = "Print information about the current workspace"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the workspace command."""
+        if not coder or not coder.repo:
+            io.tool_output("No repository or workspace active.")
+            return
+
+        workspace_path = getattr(coder.repo, "workspace_path", None)
+        if not workspace_path:
+            io.tool_output("Not currently working within a cecli workspace.")
+            return
+
+        import json
+
+        metadata_path = workspace_path / ".cecli-workspace.json"
+        config = {}
+        if metadata_path.exists():
+            try:
+                with open(metadata_path, "r") as f:
+                    config = json.load(f)
+            except Exception:
+                pass
+
+        ws_name = config.get("name", workspace_path.name)
+        is_active = config.get("active", False)
+
+        io.print(f"Current Workspace: {ws_name}{' (Active)' if is_active else ''}")
+        io.print(f"Root Directory:    {workspace_path}")
+        io.print("-" * 40)
+        io.print("Projects:")
+
+        projects = config.get("projects", [])
+        for proj in projects:
+            proj_name = proj.get("name")
+            if not proj_name:
+                continue
+
+            proj_root = workspace_path / proj_name / "main"
+            branch_info = "Unknown"
+            if proj_root.exists():
+                try:
+                    branch_info = subprocess.check_output(
+                        ["git", "-C", str(proj_root), "rev-parse", "--abbrev-ref", "HEAD"],
+                        stderr=subprocess.DEVNULL,
+                        encoding="utf-8",
+                    ).strip()
+                except Exception:
+                    branch_info = "Error retrieving branch"
+
+            repo_url = proj.get("repo", "N/A")
+            io.print(f"  - {proj_name}:")
+            io.print(f"    Branch: {branch_info}")
+            io.print(f"    Remote: {repo_url}")
+            io.print(f"    Path:   {proj_root}")
+            io.print("")
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the workspace command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /workspace  # Show details of the active monorepo workspace\n"
+        return help_text

{cecli_dev-0.98.2 → cecli_dev-0.99.1}/cecli/helpers/background_commands.py

@@ -5,11 +5,22 @@ Provides a static BackgroundCommandManager class for running shell commands
 in the background and capturing their output for injection into chat streams.
 """
 
+import codecs
+import os
+import platform
 import subprocess
 import threading
 from collections import deque
 from typing import Dict, Optional, Tuple
 
+try:
+    import pty
+    import termios
+
+    HAS_PTY = True
+except ImportError:
+    HAS_PTY = False
+
 
 class CircularBuffer:
     """
@@ -89,14 +100,48 @@ class CircularBuffer:
             return sum(len(chunk) for chunk in self.buffer)
 
 
+class InputBuffer:
+    """
+    Thread-safe buffer for queuing input to be sent to a process.
+    """
+
+    def __init__(self):
+        self.queue = deque()
+        self.lock = threading.Lock()
+
+    def append(self, text: str) -> None:
+        """Add text to the input queue."""
+        with self.lock:
+            self.queue.append(text)
+
+    def pop_all(self) -> str:
+        """Get and clear all queued input."""
+        with self.lock:
+            result = "".join(self.queue)
+            self.queue.clear()
+            return result
+
+    def has_input(self) -> bool:
+        """Check if there is queued input."""
+        with self.lock:
+            return len(self.queue) > 0
+
+
 class BackgroundProcess:
     """
     Represents a background process with output capture.
     """
 
     def __init__(
-        self, command: str, process: subprocess.Popen, buffer: CircularBuffer, persist: bool = False
+        self,
+        command: str,
+        process: subprocess.Popen,
+        buffer: CircularBuffer,
+        persist: bool = False,
+        input_buffer: Optional[InputBuffer] = None,
+        master_fd: Optional[int] = None,
     ):
+        self.master_fd = master_fd
         """
         Initialize background process wrapper.
 
@@ -116,7 +161,11 @@ class BackgroundProcess:
         self.start_time = time.time()
         self.end_time = None
         self.persist = persist
+        self.input_buffer = input_buffer or InputBuffer()
+        self.writer_thread = None
+        self._stop_event = threading.Event()
         self._start_output_reader()
+        self._start_input_writer()
 
     def _start_output_reader(self) -> None:
         """Start thread to read process output."""
@@ -128,15 +177,25 @@ class BackgroundProcess:
                 # we're in a separate thread and the buffer will capture
                 # output as soon as it's available
 
-                # Read stdout
-                for line in iter(self.process.stdout.readline, ""):
-                    if line:
-                        self.buffer.append(line)
+                if self.master_fd is not None:
+                    while not self._stop_event.is_set():
+                        try:
+                            data = os.read(self.master_fd, 4096).decode(errors="replace")
+                            if not data:
+                                break
+                            self.buffer.append(data)
+                        except (OSError, EOFError):
+                            break
+                else:
+                    # Read stdout
+                    for line in iter(self.process.stdout.readline, ""):
+                        if line:
+                            self.buffer.append(line)
 
-                # Read stderr
-                for line in iter(self.process.stderr.readline, ""):
-                    if line:
-                        self.buffer.append(line)
+                    # Read stderr
+                    for line in iter(self.process.stderr.readline, ""):
+                        if line:
+                            self.buffer.append(line)
 
             except Exception as e:
                 self.buffer.append(f"\n[Error reading process output: {str(e)}]\n")
@@ -144,6 +203,45 @@ class BackgroundProcess:
         self.reader_thread = threading.Thread(target=reader, daemon=True)
         self.reader_thread.start()
 
+    def _start_input_writer(self) -> None:
+        """Start thread to write input to process stdin."""
+
+        def writer():
+            try:
+                while not self._stop_event.is_set() and self.is_alive():
+                    if self.input_buffer.has_input():
+                        text = self.input_buffer.pop_all()
+                        if text:
+                            if self.master_fd is not None:
+                                os.write(self.master_fd, text.encode("latin-1"))
+                            else:
+                                try:
+                                    # Try to write to the binary buffer for lossless propagation
+                                    self.process.stdin.buffer.write(text.encode("latin-1"))
+                                    self.process.stdin.buffer.flush()
+                                except (AttributeError, ValueError):
+                                    # Fallback to text mode if buffer is not available
+                                    self.process.stdin.write(text)
+                                    self.process.stdin.flush()
+                    import time
+
+                    time.sleep(0.1)
+            except (BrokenPipeError, OSError):
+                pass
+            except Exception as e:
+                self.buffer.append(f"\n[Error writing to process input: {str(e)}]\n")
+            finally:
+                try:
+                    if self.master_fd is not None:
+                        os.close(self.master_fd)
+                    else:
+                        self.process.stdin.close()
+                except Exception:
+                    pass
+
+        self.writer_thread = threading.Thread(target=writer, daemon=True)
+        self.writer_thread.start()
+
     def get_output(self, clear: bool = False) -> str:
         """
         Get current output buffer.
@@ -171,6 +269,11 @@ class BackgroundProcess:
         """Check if process is running."""
         return self.process.poll() is None
 
+    def send_input(self, text: str) -> None:
+        """Queue input to be sent to the process."""
+        if self.input_buffer:
+            self.input_buffer.append(text)
+
     def stop(self, timeout: float = 5.0) -> Tuple[bool, str, Optional[int]]:
         """
         Stop the process gracefully.
@@ -184,6 +287,9 @@ class BackgroundProcess:
         import time
 
         try:
+            # Signal threads to stop
+            self._stop_event.set()
+
             # Try SIGTERM first
             self.process.terminate()
             self.process.wait(timeout=timeout)
@@ -192,7 +298,6 @@ class BackgroundProcess:
             output = self.get_output(clear=True)
             exit_code = self.process.returncode
             self.end_time = time.time()
-
             return True, output, exit_code
 
         except subprocess.TimeoutExpired:
@@ -262,6 +367,8 @@ class BackgroundCommandManager:
         existing_process: Optional[subprocess.Popen] = None,
         existing_buffer: Optional[CircularBuffer] = None,
         persist: bool = False,
+        existing_input_buffer: Optional[InputBuffer] = None,
+        use_pty: bool = False,
     ) -> str:
         """
         Start a command in background.
@@ -283,7 +390,29 @@ class BackgroundCommandManager:
             buffer = existing_buffer or CircularBuffer(max_size=max_buffer_size)
 
             # Use existing process or start new one
-            if existing_process:
+            master_fd = None
+            if use_pty and HAS_PTY and platform.system() != "Windows":
+                master_fd, slave_fd = pty.openpty()
+
+                # Disable echo on the slave PTY
+                attr = termios.tcgetattr(slave_fd)
+                attr[3] = attr[3] & ~termios.ECHO
+                termios.tcsetattr(slave_fd, termios.TCSANOW, attr)
+
+                process = subprocess.Popen(
+                    command,
+                    shell=True,
+                    stdout=slave_fd,
+                    stderr=slave_fd,
+                    stdin=slave_fd,
+                    cwd=cwd,
+                    close_fds=True,
+                    text=True,
+                    bufsize=1,
+                    universal_newlines=True,
+                )
+                os.close(slave_fd)
+            elif existing_process:
                 process = existing_process
             else:
                 process = subprocess.Popen(
@@ -291,15 +420,22 @@ class BackgroundCommandManager:
                     shell=True,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
-                    stdin=subprocess.DEVNULL,  # No stdin for background commands
+                    stdin=subprocess.PIPE,
                     cwd=cwd,
-                    text=True,  # Use text mode for easier handling
-                    bufsize=1,  # Line buffered
+                    text=True,
+                    bufsize=1,
                     universal_newlines=True,
                 )
 
             # Create background process wrapper
-            bg_process = BackgroundProcess(command, process, buffer, persist=persist)
+            bg_process = BackgroundProcess(
+                command,
+                process,
+                buffer,
+                persist=persist,
+                input_buffer=existing_input_buffer,
+                master_fd=master_fd,
+            )
 
             # Generate unique key and store
             command_key = cls._generate_command_key(command)
@@ -367,6 +503,30 @@ class BackgroundCommandManager:
                 return f"[Error] No background command found with key: {command_key}"
             return bg_process.get_new_output()
 
+    @classmethod
+    def send_command_input(cls, command_key: str, text: str) -> bool:
+        """
+        Send input to a background command.
+
+        Args:
+            command_key: Command key returned by start_background_command
+            text: Text to send to the command's stdin
+
+        Returns:
+            True if input was queued, False if command not found
+        """
+        with cls._lock:
+            bg_process = cls._background_commands.get(command_key)
+            if not bg_process:
+                return False
+            # Decode escape sequences (like \x1b) if present in the string
+            try:
+                text = codecs.decode(text, "unicode_escape")
+            except Exception:
+                pass
+            bg_process.send_input(text)
+            return True
+
     @classmethod
     def get_all_command_outputs(cls, clear: bool = False) -> Dict[str, str]:
         """