cli2 5.2.1rc1__tar.gz → 5.2.3__tar.gz

{cli2-5.2.1rc1/cli2.egg-info → cli2-5.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.2.1rc1
+Version: 5.2.3
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -63,6 +63,7 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
-- **AI assisted programing CLI & framework with code2**
+- **AI CLI with prompt2**
+- **AI coding with code2** (TBA)
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.2.1rc1 → cli2-5.2.3}/README.rst

@@ -25,6 +25,7 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
-- **AI assisted programing CLI & framework with code2**
+- **AI CLI with prompt2**
+- **AI coding with code2** (TBA)
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.2.1rc1 → cli2-5.2.3}/cli2/__init__.py

@@ -11,7 +11,7 @@ from .cli import (
     Cli2Error,
     Cli2ValueError,
 )
-from .asyncio import async_resolve, async_run, Queue
+from .asyncio import async_resolve, Queue
 from .colors import colors as c
 from .theme import theme, t
 
@@ -28,6 +28,8 @@ else:
 from .log import configure, log, parse
 from .mask import Mask
 from .notlevenshtein import closest, closest_path
+from .proc import Proc
+from .find import Find
 from .table import Table
 
 

{cli2-5.2.1rc1 → cli2-5.2.3}/cli2/asyncio.py

@@ -39,23 +39,6 @@ async def async_resolve(result, output=False):
     return result
 
 
-def async_run(coroutine):
-    """Run an async coroutine in the current event loop or create a new one.
-
-    If an event loop is already running, creates a task in that loop.
-    If no event loop is running, creates a new one and runs the coroutine.
-
-    :param coroutine: The coroutine to run (return value of an async function)
-    :return: The result of the coroutine execution
-    """
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError:
-        return asyncio.run(coroutine)
-    else:
-        return loop.create_task(coroutine)
-
-
 class Queue(asyncio.Queue):
     """
     An async queue with worker pool for concurrent task processing.

cli2-5.2.3/cli2/find.py

@@ -0,0 +1,189 @@
+"""
+Effecient git-aware file finder with filtering capabilities.
+
+Uses Linux commands: find, comm and git-ignore for an efficient path walker.
+
+Example usage:
+
+.. code-block:: python
+
+    # Simple usage with default root
+    finder = cli2.Find()
+    files = finder.files()
+    dirs = finder.dirs()
+
+    # Usage with filters and callback
+    def callback(filepath):
+        print(f"Found: {filepath}")
+
+    finder = cli2.Find(
+        root="/path/to/repo",
+        glob_include=['*.py'],
+        glob_exclude=['*test*'],
+        file_callback=callback
+    )
+    files = finder.files()
+    dirs = finder.dirs()
+"""
+import cli2
+from fnmatch import fnmatch
+from pathlib import Path
+import os
+
+
+class Find:
+    """
+    A class to walk through files and directories not ignored by git with
+    optional filtering.
+
+    .. py:attribute:: root
+
+        Root directory for file operations
+
+    .. py:attribute:: glob_include
+
+        Optional list of glob patterns to include
+
+    .. py:attribute:: glob_exclude
+
+        Optional list of glob patterns to exclude
+
+    .. py:attribute:: file_callback
+
+        Optional callback function called for each file or directory
+    """
+
+    def __init__(
+        self,
+        root=None,
+        glob_include=None,
+        glob_exclude=None,
+        file_callback=None,
+    ):
+        """
+        Initialize Find with optional root directory, filters, and callback.
+
+        :param root: Root directory (defaults to current working directory if
+                     not specified)
+        :type root: str or pathlib.Path or None
+        :param glob_include: List of glob patterns to include
+        :type glob_include: list or None
+        :param glob_exclude: List of glob patterns to exclude
+        :type glob_exclude: list or None
+        :param file_callback: Function to call for each file or directory
+        :type file_callback: callable or None
+        """
+        self.root = Path(root if root is not None else os.getcwd()).resolve()
+        self.glob_include = glob_include if glob_include is not None else []
+        self.glob_exclude = glob_exclude if glob_exclude is not None else []
+        self.file_callback = file_callback
+
+    def _matches_filters(self, filepath):
+        """
+        Check if a file or directory matches the include/exclude filters.
+
+        :param filepath: Path to check against filters
+        :type filepath: pathlib.Path
+        :return: True if path should be included, False otherwise
+        :rtype: bool
+        """
+        filepath_str = str(filepath.relative_to(self.root))
+
+        if self.glob_include:
+            if not any(
+                fnmatch(filepath_str, pattern) for pattern in self.glob_include
+            ):
+                return False
+
+        if self.glob_exclude:
+            if any(
+                fnmatch(filepath_str, pattern) for pattern in self.glob_exclude
+            ):
+                return False
+
+        return True
+
+    def files(self, directory=None):
+        """
+        List files not ignored by git, applying filters and callback.
+
+        :param directory: Directory to start search from (defaults to root if
+                          not specified)
+        :type directory: str or pathlib.Path or None
+        :return: List of Path objects for files not ignored by git that match
+                 filters
+        :rtype: list
+        :raises RuntimeError: If the git command fails
+        """
+        base_path = Path(directory).resolve() if directory else self.root
+
+        cmd = ' '.join([
+            f'comm -23 <(find {base_path} -type f | sort)',
+            f'<(find {base_path} -type f | git check-ignore --stdin | sort)'
+        ])
+        proc = cli2.Proc("bash", "-c", cmd).wait()
+
+        if proc.rc != 0:
+            raise RuntimeError(
+                f"Command failed with return code {proc.rc}: {proc.stderr}"
+            )
+
+        files = []
+        for line in proc.stdout.splitlines():
+            if not line.strip():
+                continue
+
+            filepath = (base_path / line.strip()).resolve()
+
+            if (
+                not self.glob_include and not self.glob_exclude
+            ) or self._matches_filters(filepath):
+                files.append(filepath)
+                if self.file_callback:
+                    self.file_callback(filepath)
+
+        return files
+
+    def dirs(self, directory=None):
+        """
+        List directories not ignored by git, applying filters and callback.
+
+        :param directory: Directory to start search from (defaults to root if
+                          not specified)
+        :type directory: str or pathlib.Path or None
+        :return: List of Path objects for directories not ignored by git that
+                 match filters
+        :rtype: list
+        :raises RuntimeError: If the git command fails
+        """
+        base_path = Path(directory).resolve() if directory else self.root
+
+        cmd = ' '.join([
+            f'comm -23 <(find {base_path} -type d | sort)',
+            f'<(find {base_path} -type d | git check-ignore --stdin | sort)'
+        ])
+        proc = cli2.Proc("bash", "-c", cmd).wait()
+
+        if proc.rc != 0:
+            raise RuntimeError(
+                f"Command failed with return code {proc.rc}: {proc.stderr}"
+            )
+
+        dirs = []
+        for line in proc.stdout.splitlines():
+            if not line.strip():
+                continue
+
+            dirpath = (base_path / line.strip()).resolve()
+
+            if dirpath == base_path:
+                continue
+
+            if (
+                not self.glob_include and not self.glob_exclude
+            ) or self._matches_filters(dirpath):
+                dirs.append(dirpath)
+                if self.file_callback:
+                    self.file_callback(dirpath)
+
+        return dirs

{cli2-5.2.1rc1 → cli2-5.2.3}/cli2/interactive.py

@@ -3,6 +3,7 @@ import os
 import shlex
 import subprocess
 import tempfile
+from pathlib import Path
 
 from .log import log
 
@@ -49,32 +50,47 @@ def editor(content=None):
 
     Like git rebase -i does!
 
-    :param content: Initial content if any
+    - If a file path is given, edit in place.
+    - Otherwise, write to a temporary file.
+    - Anyway: return the written contents.
+
+    :param content: Initial content if any, or a file path
     :return: The edited content after $EDITOR exit
     """
-    tmp = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".txt")
-    with tmp as f:
-        f.write(content)
-        f.flush()
-        filepath = f.name
-
     editor = os.getenv('EDITOR', 'vim')
 
+    if Path(content).exists():
+        # open directly on target path
+        filepath = content
+        tmp = None
+    else:
+        tmp = tempfile.NamedTemporaryFile(
+            mode='w+',
+            delete=False,
+            suffix=".txt",
+        )
+        with tmp as f:
+            f.write(content)
+            f.flush()
+            filepath = f.name
+
+    command = f"{editor} {shlex.quote(str(filepath))}"
+
     try:
-        command = f"{editor} {shlex.quote(filepath)}"
         subprocess.run(shlex.split(command), check=True)
-
-        with open(filepath, 'r') as f:
-            content = f.read()
-        return content
     except subprocess.CalledProcessError as e:
         log.error(f"Error running Vim: {e}")
         return None
     except FileNotFoundError:
         log.warn(f"Temporary file gone?? {filepath}")
         return None
+    else:
+        with open(filepath, 'r') as f:
+            content = f.read()
+        return content
     finally:
-        try:
-            os.remove(filepath)
-        except OSError as e:
-            log.warn(f"Error deleting temporary file {filepath}: {e}")
+        if tmp:
+            try:
+                os.remove(filepath)
+            except OSError as e:
+                log.warn(f"Error deleting temporary file {filepath}: {e}")

cli2-5.2.3/cli2/proc.py

@@ -0,0 +1,302 @@
+"""
+Asyncio subprocess wrapper featuring:
+
+- Capture + live logging of stdout/stderr
+- ANSI escape code cleaning for captured output: print colored output for
+  humans, have clean output in a variable for processing, log, cache... and
+  sending to LLMs!
+- Separate start/wait methods for process control
+
+Example usage:
+
+.. code-block:: python
+
+    # pass shell command in a string for convenience
+    proc = cli2.Proc('foo bar')
+
+    # or as list, better when building commands
+    proc = cli2.Proc('foo', 'bar')
+
+    # run in sync mode (ie. for jinja2)
+    proc.wait()
+
+    # OR run in async loop
+    await proc.waita()
+
+    # You can chain
+    proc = cli2.Proc('hi').wait()
+    proc = await cli2.Proc('hi').waita()
+
+.. note:: There are also start functions, sync and async, in case you want to
+          start the proc and wait later.
+"""
+import asyncio
+import os
+import shlex
+import re
+import subprocess
+
+from .log import log
+
+ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+
+
+class Proc:
+    """
+    Asynchronous subprocess manager with advanced IO handling.
+
+    .. py:attribute:: args
+
+        Full command arguments list used to launch the process
+
+    .. py:attribute:: rc
+
+        Return Code: process exit code (available after process completes)
+
+    .. py:attribute:: out
+
+        Combined cleaned output with ANSI escape codes removed.
+
+    .. py:attribute:: out_ansi
+
+        Combined stdout/stderr output with ANSI codes preserved.
+
+    .. py:attribute:: stdout
+
+        Cleaned stdout output with ANSI escape codes removed.
+
+    .. py:attribute:: stderr
+
+        Cleaned stdout output with ANSI escape codes removed.
+
+    .. py:attribute:: stdout_ansi
+
+        Stdout output with ANSI escape codes preserved.
+
+    .. py:attribute:: stderr_ansi
+
+        Stderr output with ANSI escape codes preserved.
+    """
+    def __init__(self, cmd, *args, quiet=False, inherit=True, timeout=None,
+                 **env):
+        """
+        :param cmd: Command string (will shlex split) or initial argument
+        :param args: Additional command arguments
+        :param quiet: Suppress live output printing (default: False)
+        :param inherit: Inherit parent environment variables (default: True)
+        :param timeout: Maximum execution time in seconds (default: None)
+        :param env: Additional environment variables to set
+        :type env: Environment variables.
+        """
+        if args:
+            self.args = [cmd] + list(args)
+        else:
+            self.args = shlex.split(cmd)
+
+        self.quiet = quiet
+
+        self.env = dict()
+        if inherit:
+            self.env = os.environ.copy()
+        self.env.update(env)
+
+        self.out_raw = bytearray()
+        self.err_raw = bytearray()
+        self.raw = bytearray()
+
+        self.started = False
+        self.waited = False
+        self.timeout = timeout
+        self.rc = None
+        self.proc = None
+
+    def clone(self):
+        """
+        Create a new unstarted Proc instance with identical configuration.
+
+        :return: New Proc instance ready for execution
+        """
+        return type(self)(
+            *self.args, quiet=self.quiet, inherit=True, timeout=self.timeout,
+            **self.env
+        )
+
+    @property
+    def cmd(self):
+        """
+        Get/set the command as a shell-joinable string.
+
+        :getter: Returns shell-escaped command string
+        :setter: Parses and updates internal args list
+        :type: str
+        """
+        return shlex.join(self.args)
+
+    @cmd.setter
+    def cmd(self, value):
+        self.args = shlex.split(value)
+
+    async def starta(self):
+        """
+        Launch the subprocess asynchronously.
+
+        :return: Self reference for method chaining
+        :raises RuntimeError: If process is already started
+        """
+        if self.started:
+            raise RuntimeError("Process already started")
+
+        if not self.quiet:
+            log.debug('cmd', cmd=self.cmd)
+
+        self.proc = await asyncio.create_subprocess_exec(
+            *[str(arg) for arg in self.args],
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env={str(k): str(v) for k, v in self.env.items()},
+        )
+        self.started = True
+
+        self.stdout_task = asyncio.create_task(
+            self._handle_output(self.proc.stdout, 1)
+        )
+        self.stderr_task = asyncio.create_task(
+            self._handle_output(self.proc.stderr, 2)
+        )
+        return self
+
+    async def waita(self):
+        """
+        Wait for process completion with timeout handling.
+
+        Terminates process if timeout occurs. Gathers all output streams.
+
+        :return: Self reference for method chaining
+        """
+        if not self.started:
+            await self.starta()
+
+        try:
+            if self.timeout:
+                await asyncio.wait_for(self.proc.wait(), timeout=self.timeout)
+            else:
+                await self.proc.wait()
+        except asyncio.TimeoutError:
+            print(f"Process timed out after {self.timeout}s")
+            self.proc.terminate()
+            await self.proc.wait()
+
+        await asyncio.gather(self.stdout_task, self.stderr_task)
+        self.rc = self.proc.returncode
+        self.waited = True
+        return self
+
+    async def _handle_output(self, stream, fd):
+        """
+        Internal method for stream handling.
+
+        :param stream: Output stream to monitor
+        :type stream: asyncio.StreamReader
+        :param fd: Stream identifier (1=stdout, 2=stderr)
+        :type fd: int
+        """
+        while True:
+            line = await stream.readline()
+            if not line:  # EOF
+                break
+
+            decoded_line = line.decode().rstrip()
+            if fd == 1:  # stdout
+                self.out_raw.extend(line)
+            elif fd == 2:  # stderr
+                self.err_raw.extend(line)
+            self.raw.extend(line)
+
+            if not self.quiet:
+                print(decoded_line)
+
+    def start(self):
+        """
+        Start the subprocess synchronously without waiting for output.
+        """
+        if self.started:
+            raise RuntimeError("Process already started")
+
+        if not self.quiet:
+            log.debug('cmd', cmd=self.cmd)
+
+        self.proc = subprocess.Popen(
+            self.args,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=self.env,
+            universal_newlines=True
+        )
+        self.started = True
+        # Do NOT start output handling here; defer to wait
+        return self
+
+    def wait(self):
+        """
+        Wait for process completion synchronously with timeout handling.
+        Collects output streams after waiting.
+        """
+        if not self.started:
+            self.start()
+
+        try:
+            if self.timeout:
+                self.rc = self.proc.wait(timeout=self.timeout)
+            else:
+                self.rc = self.proc.wait()
+        except subprocess.TimeoutExpired:
+            print(f"Process timed out after {self.timeout}s")
+            self.proc.terminate()
+            try:
+                # Grace period for termination
+                self.rc = self.proc.wait(timeout=1)
+            except subprocess.TimeoutExpired:
+                self.proc.kill()
+                self.rc = self.proc.wait()  # Final wait after kill
+
+        # Collect output after process has finished or been terminated
+        stdout, stderr = self.proc.communicate()
+        if stdout:
+            self.out_raw.extend(stdout.encode())
+            self.raw.extend(stdout.encode())
+            if not self.quiet:
+                print(stdout.rstrip())
+        if stderr:
+            self.err_raw.extend(stderr.encode())
+            self.raw.extend(stderr.encode())
+            if not self.quiet:
+                print(stderr.rstrip())
+
+        self.waited = True
+        return self
+
+    @property
+    def stdout_ansi(self):
+        return self.out_raw.decode().rstrip()
+
+    @property
+    def stderr_ansi(self):
+        return self.err_raw.decode().rstrip()
+
+    @property
+    def out_ansi(self):
+        return self.raw.decode().rstrip()
+
+    @property
+    def stdout(self):
+        return ansi_escape.sub('', self.stdout_ansi)
+
+    @property
+    def stderr(self):
+        return ansi_escape.sub('', self.stderr_ansi)
+
+    @property
+    def out(self):
+        return ansi_escape.sub('', self.out_ansi)

{cli2-5.2.1rc1 → cli2-5.2.3/cli2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.2.1rc1
+Version: 5.2.3
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -63,6 +63,7 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
-- **AI assisted programing CLI & framework with code2**
+- **AI CLI with prompt2**
+- **AI coding with code2** (TBA)
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.2.1rc1 → cli2-5.2.3}/cli2.egg-info/SOURCES.txt

@@ -10,12 +10,14 @@ cli2/colors.py
 cli2/configuration.py
 cli2/decorators.py
 cli2/display.py
+cli2/find.py
 cli2/interactive.py
 cli2/lock.py
 cli2/log.py
 cli2/mask.py
 cli2/node.py
 cli2/notlevenshtein.py
+cli2/proc.py
 cli2/sphinx.py
 cli2/table.py
 cli2/test.py
@@ -45,6 +47,7 @@ tests/test_configuration.py
 tests/test_decorators.py
 tests/test_display.py
 tests/test_entry_point.py
+tests/test_find.py
 tests/test_group.py
 tests/test_inject.py
 tests/test_interactive.py
@@ -53,6 +56,7 @@ tests/test_log.py
 tests/test_mask.py
 tests/test_node.py
 tests/test_notlevenshtein.py
+tests/test_proc.py
 tests/test_prompt2.py
 tests/test_restful.py
 tests/test_table.py

{cli2-5.2.1rc1 → cli2-5.2.3}/setup.py

@@ -44,7 +44,7 @@ from setuptools import setup
 
 setup(
     name='cli2',
-    version='5.2.1rc1',
+    version='5.2.3',
     setup_requires='setupmeta',
     packages=['cli2'],
     install_requires=[

{cli2-5.2.1rc1 → cli2-5.2.3}/tests/test_asyncio.py

@@ -4,21 +4,6 @@ import pytest
 from unittest import mock
 
 
-def test_async_run_noloop():
-    async def task():
-        await asyncio.sleep(.01)
-
-    cli2.async_run(task())
-
-
-@pytest.mark.asyncio
-async def test_async_run_loop():
-    async def task():
-        await asyncio.sleep(.01)
-
-    cli2.async_run(task())
-
-
 @pytest.mark.asyncio
 async def test_queue_basic():
     async def task(i):

cli2-5.2.3/tests/test_find.py

@@ -0,0 +1,131 @@
+import pytest
+from pathlib import Path
+import os
+from cli2 import Find
+
+@pytest.fixture
+def temp_git_repo(tmp_path):
+    """Create a temporary git repository with test files."""
+    # Initialize git repo
+    os.system(f"git init {tmp_path}")
+
+    # Create some test files and directories
+    (tmp_path / "src").mkdir()
+    (tmp_path / "src" / "main.py").write_text("main content")
+    (tmp_path / "src" / "utils.py").write_text("utils content")
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "test_main.py").write_text("test content")
+    (tmp_path / ".gitignore").write_text("*.pyc\n__pycache__")
+
+    # Add files to git
+    os.system(f"cd {tmp_path} && git add . && git commit -m 'Initial commit'")
+
+    return tmp_path
+
+def test_basic_initialization():
+    """Test basic Find initialization."""
+    finder = Find()
+    assert isinstance(finder.root, Path)
+    assert finder.root.is_dir()
+    assert finder.glob_include == []
+    assert finder.glob_exclude == []
+    assert finder.file_callback is None
+
+def test_custom_root_initialization(temp_git_repo):
+    """Test initialization with custom root."""
+    finder = Find(root=temp_git_repo)
+    assert finder.root == temp_git_repo.resolve()
+
+def test_files_listing(temp_git_repo):
+    """Test basic file listing."""
+    finder = Find(root=temp_git_repo)
+    files = finder.files()
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" in file_names
+    assert ".gitignore" in file_names
+
+def test_dirs_listing(temp_git_repo):
+    """Test basic directory listing."""
+    finder = Find(root=temp_git_repo)
+    dirs = finder.dirs()
+
+    dir_names = {d.name for d in dirs}
+    assert "src" in dir_names
+    assert "tests" in dir_names
+
+def test_glob_include_filter(temp_git_repo):
+    """Test glob include filtering."""
+    finder = Find(root=temp_git_repo, glob_include=["*.py"])
+    files = finder.files()
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" in file_names
+    assert ".gitignore" not in file_names
+
+def test_glob_exclude_filter(temp_git_repo):
+    """Test glob exclude filtering."""
+    finder = Find(root=temp_git_repo, glob_exclude=["*test*"])
+    files = finder.files()
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" not in file_names
+
+def test_file_callback(temp_git_repo):
+    """Test file callback functionality."""
+    called_paths = []
+    def callback(filepath):
+        called_paths.append(filepath)
+
+    finder = Find(root=temp_git_repo, file_callback=callback)
+    files = finder.files()
+
+    assert len(called_paths) == len(files)
+    assert set(called_paths) == set(files)
+
+def test_custom_directory_search(temp_git_repo):
+    """Test searching from a specific directory."""
+    finder = Find(root=temp_git_repo)
+    files = finder.files(directory=temp_git_repo / "src")
+
+    file_names = {f.name for f in files}
+    assert "main.py" in file_names
+    assert "utils.py" in file_names
+    assert "test_main.py" not in file_names
+
+def test_error_handling(temp_git_repo, monkeypatch):
+    """Test error handling when git command fails."""
+    # Mock cli2.Proc to simulate git command failure
+    class MockProc:
+        def __init__(self, *args, **kwargs):
+            pass
+        def wait(self):
+            return self
+        rc = 1
+        stderr = "Git error"
+        stdout = ""
+
+    monkeypatch.setattr("cli2.Proc", MockProc)
+
+    finder = Find(root=temp_git_repo)
+    with pytest.raises(RuntimeError, match="Command failed with return code 1: Git error"):
+        finder.files()
+
+def test_matches_filters(temp_git_repo):
+    """Test the _matches_filters method."""
+    finder = Find(
+        root=temp_git_repo,
+        glob_include=["*.py"],
+        glob_exclude=["*test*"]
+    )
+
+    assert finder._matches_filters(temp_git_repo / "src" / "main.py")
+    assert finder._matches_filters(temp_git_repo / "src" / "utils.py")
+    assert not finder._matches_filters(temp_git_repo / "tests" / "test_main.py")
+    assert not finder._matches_filters(temp_git_repo / ".gitignore")

cli2-5.2.3/tests/test_proc.py

@@ -0,0 +1,150 @@
+import cli2
+import os
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_command_string():
+    proc = cli2.Proc("echo hello")
+    assert proc.args == ["echo", "hello"]
+    assert proc.quiet is False
+    assert proc.timeout is None
+    assert proc.env == os.environ
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_command_and_args():
+    proc = cli2.Proc("echo", "hello", "world")
+    assert proc.args == ["echo", "hello", "world"]
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_quiet():
+    proc = cli2.Proc("echo hello", quiet=True)
+    assert proc.quiet is True
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_timeout():
+    proc = cli2.Proc("echo hello", timeout=10)
+    assert proc.timeout == 10
+
+
+@pytest.mark.asyncio
+async def test_proc_init_with_env():
+    proc = cli2.Proc("echo hello", MY_VAR="test")
+    assert proc.env["MY_VAR"] == "test"
+
+
+@pytest.mark.asyncio
+async def test_proc_clone():
+    proc = cli2.Proc("echo hello", quiet=True, timeout=10, MY_VAR="test")
+    cloned_proc = proc.clone()
+    assert cloned_proc.args == proc.args
+    assert cloned_proc.quiet == proc.quiet
+    assert cloned_proc.timeout == proc.timeout
+    assert cloned_proc.env == proc.env
+
+
+@pytest.mark.asyncio
+async def test_proc_cmd_property():
+    proc = cli2.Proc("echo hello")
+    assert proc.cmd == "echo hello"
+    proc.cmd = "echo world"
+    assert proc.args == ["echo", "world"]
+
+
+@pytest.mark.asyncio
+async def test_proc_start_and_waita():
+    proc = cli2.Proc("echo hello")
+    await proc.starta()
+    await proc.waita()
+    assert proc.started is True
+    assert proc.waited is True
+    assert proc.rc == 0
+    assert proc.out == "hello"
+
+
+@pytest.mark.asyncio
+async def test_proc_start_and_wait_with_timeout():
+    proc = cli2.Proc("sleep 2", timeout=1)
+    await proc.starta()
+    await proc.waita()
+    assert proc.rc != 0  # Should be terminated due to timeout
+
+
+@pytest.mark.asyncio
+async def test_proc_output_properties():
+    proc = cli2.Proc("echo hello")
+    await proc.starta()
+    await proc.waita()
+    assert proc.stdout == "hello"
+    assert proc.stderr == ""
+    assert proc.out == "hello"
+    assert proc.stdout_ansi == "hello"
+    assert proc.stderr_ansi == ""
+    assert proc.out_ansi == "hello"
+
+
+@pytest.mark.asyncio
+async def test_proc_with_stderr():
+    proc = cli2.Proc("bash", "-c", "echo error >&2 ")
+    await proc.starta()
+    await proc.waita()
+    assert proc.stdout == ""
+    assert proc.stderr == "error"
+    assert proc.out == "error"
+    assert proc.stdout_ansi == ""
+    assert proc.stderr_ansi == "error"
+    assert proc.out_ansi == "error"
+
+
+@pytest.mark.asyncio
+async def test_proc_with_ansi_codes():
+    proc = cli2.Proc("echo -e '\033[31mred\033[0m'")
+    await proc.starta()
+    await proc.waita()
+    assert proc.stdout == "red"
+    assert proc.stdout_ansi == "\x1b[31mred\x1b[0m"
+
+
+@pytest.mark.asyncio
+async def test_proc_quiet_mode():
+    proc = cli2.Proc("echo hello", quiet=True)
+    await proc.starta()
+    await proc.waita()
+    assert proc.out == "hello"
+
+
+def test_proc_start_and_wait():
+    proc = cli2.Proc("echo hello").wait()
+    assert proc.started is True
+    assert proc.waited is True
+    assert proc.rc == 0
+    assert proc.out == "hello"
+
+
+def test_proc_start_and_wait_with_timeout():
+    proc = cli2.Proc("sleep 2", timeout=1).wait()
+    assert proc.rc != 0  # Should be terminated due to timeout
+
+
+def test_proc_start_and_wait_with_stderr():
+    proc = cli2.Proc("bash", "-c", "echo error >&2").wait()
+    assert proc.stdout == ""
+    assert proc.stderr == "error"
+    assert proc.out == "error"
+    assert proc.stdout_ansi == ""
+    assert proc.stderr_ansi == "error"
+    assert proc.out_ansi == "error"
+
+
+def test_proc_start_and_wait_with_ansi_codes():
+    proc = cli2.Proc("echo -e '\033[31mred\033[0m'").wait()
+    assert proc.stdout == "red"
+    assert proc.stdout_ansi == "\x1b[31mred\x1b[0m"
+
+
+def test_proc_start_and_wait_quiet_mode():
+    proc = cli2.Proc("echo hello", quiet=True).wait()
+    assert proc.out == "hello"

{cli2-5.2.1rc1 → cli2-5.2.3}/tests/test_prompt2.py

@@ -7,21 +7,52 @@ from unittest import mock
 from prompt2 import cli, Model, Prompt
 
 
+def test_model():
+    os.environ['MODEL'] = 'litellm foo bar=1 foo=.2'
+    model = Model()
+    assert type(model.backend).__name__ == 'LiteLLMBackend'
+    assert model.backend.model_name == 'foo'
+    assert model.backend.model_kwargs['bar'] == 1
+    assert model.backend.model_kwargs['foo'] == .2
+    del os.environ['MODEL']
+
+    os.environ['MODEL_FOO'] = 'test a=b'
+    model = Model('foo')
+    assert type(model.backend).__name__ == 'LiteLLMBackend'
+    assert model.backend.model_name == 'test'
+    assert model.backend.model_kwargs['a'] == 'b'
+
+
+def test_prompt(user, local):
+    with user.open('w') as f:
+        f.write('hello')
+
+    args = ['user', str(user), user]
+    for arg in args:
+        prompt = Prompt(arg)
+        assert prompt.path == user, arg
+        assert prompt.content == 'hello', arg
+        assert prompt.name == 'user'
+
+
 def test_paths():
-    assert cli.cli('paths') == [
-        str(Prompt.LOCAL_PATH),
-        str(Prompt.USER_PATH),
-    ]
+    paths = cli.cli('paths')
+    assert paths[0] == str(Prompt.local_path)
+    assert paths[1] == str(Prompt.user_path)
 
 
 @pytest.fixture
-def user():
-    return Path(os.getenv('PROMPT2_USER_PATH')) / 'user.txt'
+def user(prompt2_env):
+    path = Path(prompt2_env.get('PROMPT2_USER_PATH'))
+    path.mkdir(parents=True, exist_ok=True)
+    return path / 'user.txt'
 
 
 @pytest.fixture
-def local():
-    return Path(os.getenv('PROMPT2_LOCAL_PATH')) / 'local.txt'
+def local(prompt2_env):
+    path = Path(prompt2_env.get('PROMPT2_LOCAL_PATH'))
+    path.mkdir(parents=True, exist_ok=True)
+    return path / 'local.txt'
 
 
 @pytest.fixture
@@ -39,10 +70,8 @@ def kwargs(prompt2_env, user, local):
 
 @pytest.mark.asyncio
 async def test_python(prompt2_env):
-    model = Model.get()
-
-    prompt = Prompt()
-    prompt.parts.append('make a hello world in python')
+    model = Model()
+    prompt = Prompt(content='make a hello world in python')
     result = await model(prompt)
     assert 'To run this:' in result
     result = await model(prompt, 'wholefile')
@@ -67,6 +96,32 @@ def test_parsers(kwargs):
     )
 
 
+def test_ask(kwargs):
+    autotest(
+        'tests/prompt2/test_ask.txt',
+        'prompt2 ask Write hello world in python',
+        **kwargs,
+    )
+
+
+def test_command():
+    from prompt2.cli import PromptCommand
+    def test(model=None, parser=None):
+        return model, parser
+    model, parser = PromptCommand(test)()
+    assert type(model.backend).__name__ == 'LiteLLMBackend'
+    assert model.backend.model_name == Model.default
+    assert not parser
+
+    os.environ['MODEL_LOL'] = 'foo temperature=test'
+    model, parser = PromptCommand(test)('lol')
+    assert model.backend.model_name == 'foo'
+    assert model.backend.model_kwargs == dict(temperature='test')
+
+    model, parser = PromptCommand(test)('parser=wholefile')
+    assert type(parser).__name__.lower() == 'wholefile'
+
+
 def test_crud(user, kwargs):
     autotest(
         'tests/prompt2/test_edit_user.txt',
@@ -142,3 +197,14 @@ def test_crud(user, kwargs):
         'prompt2 send user wholefile',
         **kwargs,
     )
+    autotest(
+        'tests/prompt2/test_send_code_failparser.txt',
+        'prompt2 send user foeuau',
+        **kwargs,
+    )
+    os.environ['MODEL_FOO'] = 'test a=b'
+    autotest(
+        'tests/prompt2/test_send_code_failmodel.txt',
+        'prompt2 send user model=oaeoeau',
+        **kwargs,
+    )