cecli-dev 1.5.0rc15__tar.gz → 1.5.1__tar.gz

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/PKG-INFO

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

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.5.0rc15'
-__version_tuple__ = version_tuple = (1, 5, 0, 'rc15')
+__version__ = version = '1.5.1'
+__version_tuple__ = version_tuple = (1, 5, 1)
 
-__commit_id__ = commit_id = 'g694c06342'
+__commit_id__ = commit_id = 'g17d4bc7df'

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/helpers/agents/service.py

@@ -617,11 +617,22 @@ class AgentService:
             parent_uuid=parent_coder.uuid,
             map_tokens=0,
             init_metadata={"agent_config": agent_config},
-            # Sub-agents start with an empty file context; rules are inherited.
-            fnames=[],
-            read_only_fnames=[],
-            read_only_stubs_fnames=[],
         )
+
+        # Sub-agents start with an empty file context by default; rules are
+        # inherited. When ``keep_files`` is set in the sub-agent's metadata,
+        # inherit the parent's editable and read-only files instead of
+        # resetting them.
+        keep_files = isinstance(metadata, dict) and bool(metadata.get("keep_files", False))
+        if not keep_files:
+            kwargs.update(
+                dict(
+                    fnames=[],
+                    read_only_fnames=[],
+                    read_only_stubs_fnames=[],
+                )
+            )
+
         if configured_root:
             kwargs["root"] = configured_root
 

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/helpers/llms/litellm_compat.py

@@ -29,6 +29,8 @@ from typing import Any, Dict, List, Optional
 from cecli.dump import dump  # noqa: F401
 from cecli.http import httpx
 
+from .runtime import log_error_response
+
 warnings.filterwarnings("ignore", category=UserWarning, module="pydantic")
 
 SITE_URL = "https://cecli.dev"
@@ -1156,7 +1158,7 @@ class _LiteLLMFacade:
         if language:
             data["language"] = language
 
-        with httpx.Client(timeout=600) as client:
+        with httpx.Client(timeout=600, event_hooks={"response": [log_error_response]}) as client:
             resp = client.post(
                 "https://api.openai.com/v1/audio/transcriptions",
                 headers=headers,

cecli_dev-1.5.1/cecli/helpers/llms/runtime.py

@@ -0,0 +1,133 @@
+"""Runtime knobs for the llms package (import-light, no heavy deps).
+
+The dispatcher and domain adapters read :data:`VERIFY_SSL` when constructing
+httpx clients so ``--no-verify-ssl`` keeps working after the litellm swap
+(litellm previously patched ``client_session``/``aclient_session`` globals).
+
+``make_client`` additionally attaches a response hook that appends the body of
+any 4xx/5xx response to :data:`ERROR_LOG_PATH` (``.cecli/logs/requests-errors.log``)
+so failed provider requests stay diagnosable after the fact.
+"""
+
+from __future__ import annotations
+
+import os
+import ssl
+import threading
+import time
+from typing import Any
+
+from cecli.http import httpx
+
+#: Global TLS verification flag; set False for ``--no-verify-ssl``.
+VERIFY_SSL = True
+
+#: Append-only destination for 4xx/5xx response bodies.
+ERROR_LOG_PATH = ".cecli/logs/requests-errors.log"
+
+#: Serializes appends from concurrent sync/async hooks (writes are tiny).
+_ERROR_LOG_LOCK = threading.Lock()
+
+#: Maximum decoded body size kept per record.
+_MAX_LOGGED_BODY = 64 * 1024
+
+
+def set_verify_ssl(verify: bool) -> None:
+    """Set whether outbound httpx clients verify TLS certificates."""
+    global VERIFY_SSL
+
+    VERIFY_SSL = bool(verify)
+
+
+def make_client(timeout: float, **kwargs: Any) -> httpx.AsyncClient:
+    """Create an httpx AsyncClient, retrying once on the OpenSSL first-init flake.
+
+    On some platforms (observed: WSL2 + OpenSSL 3.5 + Python 3.14) the very
+    first ``ssl.create_default_context(cafile=...)`` in a fresh process can
+    fail with ``ssl.SSLError`` (``[CONF: MODULE_INITIALIZATION_ERROR]`` /
+    "unknown error (0x0)") because the OpenSSL CONF module races its lazy
+    initialization. A second attempt succeeds. Retrying keeps per-request
+    httpx clients reliable whether or not truststore has been injected.
+
+    A response hook is always attached so 4xx/5xx bodies land in
+    :data:`ERROR_LOG_PATH`; caller-supplied ``event_hooks`` are preserved.
+    """
+    hooks = dict(kwargs.pop("event_hooks", None) or {})
+    hooks["response"] = [*hooks.get("response", []), _log_error_response]
+
+    try:
+        return httpx.AsyncClient(timeout=timeout, event_hooks=hooks, **kwargs)
+
+    except ssl.SSLError:
+        return httpx.AsyncClient(timeout=timeout, event_hooks=hooks, **kwargs)
+
+
+def log_error_response(response: Any) -> None:
+    """Sync httpx response hook: append 4xx/5xx bodies to :data:`ERROR_LOG_PATH`."""
+
+    if response.status_code < 400:
+        return
+
+    try:
+        response.read()
+        body = response.text
+
+    except Exception:
+        body = "<body unavailable>"
+
+    _append_error_record(response, body)
+
+
+async def _log_error_response(response: Any) -> None:
+    """Async httpx response hook: append 4xx/5xx bodies to :data:`ERROR_LOG_PATH`.
+
+    Reading the body here also makes it available to the caller's later
+    ``raise_for_status()``/error handling; streaming error responses are
+    otherwise left unread.
+    """
+
+    if response.status_code < 400:
+        return
+
+    try:
+        await response.aread()
+        body = response.text
+
+    except Exception:
+        body = "<body unavailable>"
+
+    _append_error_record(response, body)
+
+
+def _append_error_record(response: Any, body: str) -> None:
+    """Append one error record; logging failures never reach the request path."""
+
+    request = response.request
+    body = body or ""
+
+    if len(body) > _MAX_LOGGED_BODY:
+        body = f"{body[:_MAX_LOGGED_BODY]}\n<truncated>"
+
+    record = (
+        f"{time.strftime('%Y-%m-%d %H:%M:%S')} "
+        f"{getattr(request, 'method', '?')} {getattr(request, 'url', '?')} -> "
+        f"{response.status_code}\n{body}\n{'-' * 80}\n"
+    )
+
+    try:
+        os.makedirs(os.path.dirname(ERROR_LOG_PATH), exist_ok=True)
+
+        with _ERROR_LOG_LOCK, open(ERROR_LOG_PATH, "a", encoding="utf-8") as handle:
+            handle.write(record)
+
+    except Exception:
+        pass
+
+
+__all__ = [
+    "ERROR_LOG_PATH",
+    "VERIFY_SSL",
+    "log_error_response",
+    "make_client",
+    "set_verify_ssl",
+]

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/helpers/lock_detect.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import sys
 import threading
 import time
@@ -11,10 +12,14 @@ logging.basicConfig(level=logging.INFO)
 logging.getLogger("asyncio").setLevel(logging.DEBUG)
 
 
-def dump_stacks_to_file(filename="hang_dump.log", interval=5, max_prints=10):
+def dump_stacks_to_file(filename=".cecli/logs/threads.log", interval=5, max_prints=10):
     """Periodically writes stack traces to a file, resetting it after max_prints."""
     print_count = 0
 
+    log_dir = os.path.dirname(filename)
+    if log_dir:
+        os.makedirs(log_dir, exist_ok=True)
+
     while True:
         time.sleep(interval)
         try:
@@ -50,7 +55,7 @@ def dump_stacks_to_file(filename="hang_dump.log", interval=5, max_prints=10):
 # Start the monitor in a background daemon thread
 monitor_thread = threading.Thread(
     target=dump_stacks_to_file,
-    args=("program_hangs.log", 5, 10),  # Clears every 10 prints
+    args=(".cecli/logs/threads.log", 5, 10),  # Clears every 10 prints
     daemon=True,
 )
 monitor_thread.start()

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/helpers/skills.py

@@ -66,23 +66,29 @@ class SkillsManager:
             root: Optional base root directory for relative path resolution
             coder: Optional reference to the coder instance (weak reference)
         """
-        # Always include the default skills directory in the user's home
-        default_skill_dir = str(Path.home() / ".cecli" / "skills")
-        if default_skill_dir not in directory_paths:
-            directory_paths = [default_skill_dir] + list(directory_paths)
+        # Always include the default skills directories in the user's home:
+        # the cecli-specific directory plus the `.agents` standard directory.
+        default_skill_dirs = [
+            str(Path.home() / ".cecli" / "skills"),
+            str(Path.home() / ".agents" / "skills"),
+        ]
+        for default_skill_dir in reversed(default_skill_dirs):
+            if default_skill_dir not in directory_paths:
+                directory_paths = [default_skill_dir] + list(directory_paths)
 
         # Local path resolution base: use root so sub-agents with an overridden
         # local root still resolve project skills relative to the primary
         # workspace (instead of the working directory).
         local_anchor = Path(root).expanduser().resolve() if root else Path.cwd()
 
-        # Also include the local default skills directory under the coder root
-        # so project-scoped skills can live in {root}/.cecli/skills alongside the
-        # global ~/.cecli/skills default.
+        # Also include the local default skills directories under the coder root
+        # so project-scoped skills can live in {root}/.cecli/skills or
+        # {root}/.agents/skills alongside the global home defaults.
         if root:
-            local_default_skill_dir = str(local_anchor / ".cecli" / "skills")
-            if local_default_skill_dir not in directory_paths:
-                directory_paths.append(local_default_skill_dir)
+            for local_skill_subdir in (".cecli", ".agents"):
+                local_default_skill_dir = str(local_anchor / local_skill_subdir / "skills")
+                if local_default_skill_dir not in directory_paths:
+                    directory_paths.append(local_default_skill_dir)
 
         # Resolve every path relative to local_anchor and drop exact duplicates.
         resolved_paths = []
@@ -101,11 +107,14 @@ class SkillsManager:
             seen_paths.add(path)
             resolved_paths.append(path)
 
-        # Order paths: local project dirs first, then configured, home dirs last.
+        # Order paths: local project dirs before home dirs, and within the same
+        # locality cecli's own `.cecli/skills` directories before the
+        # `.agents/skills` standard directories.
         ordered = sorted(
             enumerate(resolved_paths),
             key=lambda item: (
                 self._directory_priority(item[1], local_anchor),
+                self._directory_source_rank(item[1]),
                 item[0],
             ),
         )
@@ -157,15 +166,17 @@ class SkillsManager:
 
         0 - local project directory (under the root or working directory)
         1 - any other configured directory
-        2 - a home directory (including the implicit ``~/.cecli/skills`` default)
+        2 - a home directory (including the implicit ``~/.cecli/skills`` and
+            ``~/.agents/skills`` defaults)
         """
         home = Path.home().resolve()
 
-        # Implicit default skills dir is always treated as a home dir.
-        if path == (home / ".cecli" / "skills"):
+        # Implicit default skills dirs are always treated as home dirs.
+        if path in (home / ".cecli" / "skills", home / ".agents" / "skills"):
             return 2
 
         local_anchor = root if root is not None else Path.cwd()
+
         try:
             path.relative_to(local_anchor)
             return 0
@@ -178,6 +189,22 @@ class SkillsManager:
         except ValueError:
             return 1
 
+    @staticmethod
+    def _directory_source_rank(path: Path) -> int:
+        """Rank a skill directory by the standard it belongs to.
+
+        Lower values are scanned first and therefore win by-name conflicts, but
+        this only breaks ties between directories in the same locality (see
+        ``_directory_priority``):
+
+        0 - cecli's own ``.cecli/skills`` directories and other directories
+        1 - the ``.agents/skills`` standard directories
+        """
+        if path.name == "skills" and path.parent.name == ".agents":
+            return 1
+
+        return 0
+
     def _get_coder(self):
         """Return coder via weak reference, or None if collected."""
         if self._coder_ref is not None:

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/main.py

@@ -73,6 +73,28 @@ elif sys.platform == "darwin":
 from .dump import dump  # noqa
 
 
+def attach_debug_thread_monitor(argv=None):
+    """Start the thread/stack monitor early when debug logging is requested.
+
+    The full argument parser only runs inside main_async(), so the debug flag is
+    resolved late. The monitor must be running before the event loop starts to
+    observe startup, so we detect the usual sources here instead: an explicit
+    CECLI_DEBUG_THREAD_LOG override, the CECLI_DEBUG env var, or a --debug flag
+    in argv. A debug value supplied only by a config file is not known this
+    early and is handled once args are parsed.
+    """
+    env_override = os.getenv("CECLI_DEBUG_THREAD_LOG", "").lower() in ("1", "true", "yes")
+    env_debug = os.getenv("CECLI_DEBUG", "").lower() in ("1", "true", "yes")
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    if not (env_override or env_debug or "--debug" in argv):
+        return
+
+    import cecli.helpers.lock_detect  # noqa
+
+
 def convert_yaml_to_json_string(value, config_file_value=None):
     """
     Convert YAML dict/list values to JSON strings for compatibility.
@@ -555,6 +577,8 @@ def custom_tracer(frame, event, arg):
 def main(argv=None, input=None, output=None, force_git_root=None, return_coder=False):
     from cecli.signals import ReloadProgramSignal
 
+    attach_debug_thread_monitor(argv)
+
     # Tracks the coder instance from a ReloadProgramSignal so the new
     # main_async() can pass it as from_coder to Coder.create(), preserving
     # UUID, edit_format, and other state across the reload cycle.
@@ -786,6 +810,9 @@ async def main_async(
         os.makedirs(".cecli/logs/", exist_ok=True)
         log_file = open(".cecli/logs/debug.log", "w", buffering=1)
         sys.settrace(custom_tracer)
+        # Ensure the thread/stack monitor is running even when debug was enabled
+        # from a config file rather than the CLI/env (main() attaches it early).
+        import cecli.helpers.lock_detect  # noqa
     if args.shell_completions:
         parser.prog = "cecli"
         print(shtab.complete(parser, shell=args.shell_completions))

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/models.py

@@ -1515,7 +1515,7 @@ class Model(ModelSettings):
                     should_retry = False
 
                 if not should_retry:
-                    print(f"LiteLLM API Error: {str(err)}")
+                    print(f"API Error: {str(err)}")
                     if ex_info.description:
                         print(ex_info.description)
                     if stream:
@@ -1524,7 +1524,7 @@ class Model(ModelSettings):
                         return hash_object, self.model_error_response()
 
                 print(f"Retrying in {retry_delay:.1f} seconds...")
-                print(f"LiteLLM API Error: {str(err)}")
+                print(f"API Error: {str(err)}")
                 if interrupt_event:
                     _res, interrupted = await coroutines.interruptible(
                         asyncio.sleep(retry_delay), interrupt_event

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/tui/worker.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+import sys
 import threading
 import warnings
 from typing import Optional
@@ -45,7 +46,7 @@ class CoderWorker:
 
     def _run_thread(self):
         """Thread entry point - creates event loop and runs coder."""
-        self.loop = asyncio.new_event_loop()
+        self.loop = self._create_event_loop()
         asyncio.set_event_loop(self.loop)
         self.loop.set_exception_handler(self.worker_loop_exception_handler)
 
@@ -283,3 +284,19 @@ class CoderWorker:
         # Wait for thread to finish
         if self.thread and self.thread.is_alive():
             self.thread.join(timeout=2.0)
+
+    def _create_event_loop(self):
+        """Create the event loop used by the coder worker thread.
+
+        On Windows, use a ProactorEventLoop so MCP stdio servers can spawn real
+        asynchronous subprocesses. The process-wide policy forces a
+        SelectorEventLoop (required by prompt_toolkit on the main loop), but a
+        SelectorEventLoop cannot create subprocesses, so MCP falls back to
+        blocking ``Popen.wait()`` calls on the AnyIO thread pool. Those waits are
+        uninterruptible and can hang forever, wedging MCP teardown and leaving the
+        coder stuck mid-processing.
+        """
+        if sys.platform == "win32" and hasattr(asyncio, "ProactorEventLoop"):
+            return asyncio.ProactorEventLoop()
+
+        return asyncio.new_event_loop()

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/voice.py

@@ -268,9 +268,8 @@ def _run_record_process(
             temp_path = tmp_file.name
 
         try:
-            with sd.InputStream(
-                samplerate=sample_rate, channels=1, callback=callback, device=device_id
-            ):
+            stream = _open_input_stream(callback, sample_rate, device_id)
+            with stream:
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
 
@@ -329,7 +328,6 @@ def _record_and_stream(
     """
     import threading
 
-    import sounddevice as sd
     from moonshine_voice.transcriber import LineCompleted, LineStarted, LineTextChanged
 
     transcriber = _build_transcriber(language, status_queue)
@@ -397,9 +395,8 @@ def _record_and_stream(
         feed_thread.start()
 
         try:
-            with sd.InputStream(
-                samplerate=sample_rate, channels=1, callback=callback, device=device_id
-            ):
+            stream = _open_input_stream(callback, sample_rate, device_id)
+            with stream:
                 _status(status_queue, f"\n⬤ recording: {stop_binding or 'Enter'} to stop")
                 _wait_for_stop(stop_queue)
         finally:
@@ -559,6 +556,93 @@ def _status(status_queue, message):
         print(message)
 
 
+def _open_input_stream(callback, sample_rate, device_id=None):
+    """Open and start an input stream, retrying devices that fail to start.
+
+    PortAudio can transiently time out (``paTimedOut``) when starting a stream,
+    as happens with WSL and PipeWire's ``pulse`` device. Each candidate is
+    started eagerly so a start failure is caught and the next compatible device
+    or sample rate is tried instead of aborting the recording. Returns a started
+    ``sounddevice.InputStream`` for callers to use as a context manager; raises
+    ``SoundDeviceError`` when nothing starts.
+    """
+    import sounddevice as sd
+
+    last_error = None
+
+    for dev, rate in _input_device_candidates(sample_rate, device_id):
+        stream = None
+
+        try:
+            stream = sd.InputStream(samplerate=rate, channels=1, callback=callback, device=dev)
+            stream.start()
+        except Exception as exc:
+            last_error = exc
+
+            if stream is not None:
+                try:
+                    stream.close()
+                except Exception:
+                    pass
+
+            continue
+
+        return stream
+
+    raise SoundDeviceError(_input_device_error_message(last_error))
+
+
+def _input_device_candidates(sample_rate, device_id=None):
+    """Yield ``(device, sample_rate)`` candidates for the input stream, best first."""
+    import sounddevice as sd
+
+    for rate in _sample_rates(sample_rate):
+        yield (device_id, rate)
+
+    try:
+        devices = sd.query_devices()
+    except Exception:
+        return
+
+    if not isinstance(devices, list):
+        return
+
+    for dev, entry in enumerate(devices):
+        if not isinstance(entry, dict) or entry.get("max_input_channels", 0) <= 0:
+            continue
+
+        if dev == device_id:
+            continue
+
+        for rate in _sample_rates(entry.get("default_samplerate") or sample_rate):
+            yield (dev, rate)
+
+
+def _sample_rates(sample_rate):
+    """Return the sample rates to try for a device, most-preferred first."""
+    rates = []
+
+    for rate in (sample_rate, 44100, 48000, 16000):
+        if rate and rate not in rates:
+            rates.append(rate)
+
+    return rates
+
+
+def _input_device_error_message(err):
+    """Return an actionable message when no input device can be started."""
+    reason = f" ({err})" if err else ""
+
+    return (
+        "No microphone input device could be started"
+        + reason
+        + ". Check that your mic is the default input device (Windows: Settings > "
+        "System > Sound > Input) and that Windows grants WSLg microphone access "
+        "(Settings > Privacy & security > Microphone). In WSL, confirm the mic is "
+        "bridged first, e.g. `PULSE_SERVER=unix:/mnt/wslg/PulseServer parec -d RDPSource --channels=1`."
+    )
+
+
 def _download_model_from_hf(language, status_queue=None):
     """Download the native Moonshine model for ``language`` from Hugging Face.
 

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/website/docs/config/skills.md

@@ -77,13 +77,11 @@ Skills are configured through the `agent-config` parameter in the YAML configura
 - **`skills_includelist`**: Array of skill names to include (whitelist)
 - **`skills_excludelist`**: Array of skill names to exclude (blacklist)
 
-> **Duplicate skill names**: When the same skill name is found in more than
-> one configured directory, only one copy is loaded. Directories are scanned
-> in priority order: local project directories (e.g. `./.cecli/skills`) first,
-> then other configured directories in the order they are listed, with home
-> directories (e.g. `~/skills` and the implicit `~/.cecli/skills` default)
-> last. If no `skills_paths` are configured, the only directory searched is
-> `~/.cecli/skills`.
+> **Duplicate skill names**: When the same skill name is found in more than one configured directory, only one copy is loaded. Directories are scanned in priority order: local project directories (e.g. `./.cecli/skills` and `./.agents/skills`) first, then other configured directories in the order they are listed, with home directories (e.g. `~/skills`, `~/.cecli/skills`,and `~/.agents/skills`) last. If no `skills_paths` are configured, the directories searched are `~/.cecli/skills` and `~/.agents/skills`. 
+>
+> Within the same locality, cecli's own `.cecli/skills` directories are scanned before the `.agents/skills` standard directories; local directories always take priority over global ones.
+>
+> Skills placed in the standard `.agents/skills` directories (`~/.agents/skills` globally or `{root}/.agents/skills` per project) are discovered automatically alongside cecli's own `.cecli/skills` directories.
 
 Complete configuration example in YAML configuration file (`.cecli.conf.yml` or `~/.cecli.conf.yml`):
 

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli/website/docs/config/subagents.md

@@ -45,10 +45,24 @@ and suggestions for improvement.
 | `hooks` | No | Per-agent hooks configuration (see [Hooks](hooks.html) for syntax) |
 | `agent-config` | No | Override `agent-config` property of cecli configuration with custom values for sub agent |
 | `auto_reap` | No | Controls whether this sub-agent is automatically reaped when the limit is reached. Defaults to `true` if omitted |
+| `keep_files` | No | When `true`, the sub-agent inherits the parent's editable and read-only files instead of starting with an empty file context. Defaults to `false` if omitted |
 
 #### System Prompt
 
 Any content after the closing `---` of the front matter becomes the sub-agent's system prompt. This replaces the default main system prompt for that agent. You can use this to define the sub-agent's role, behavior, and constraints.
+#### File Inheritance
+
+By default, sub-agents start with an empty file context — only rules files are inherited from the parent. Set `keep_files: true` in the front matter to also inherit the parent's editable files, read-only files, and read-only stubs:
+
+```markdown
+---
+name: reviewer
+keep_files: true
+---
+```
+
+This is useful for review or testing sub-agents that need the same working set of files as the primary agent.
+
 
 ### Configuration File
 

{cecli_dev-1.5.0rc15 → cecli_dev-1.5.1}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.5.0rc15
+Version: 1.5.1
 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-1.5.1/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.5.1",
+  "distance": 0,
+  "node": "g17d4bc7df3f3d459d2917b007dc8320189cbcf15",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-12"
+}