cecli-dev 1.8.0__tar.gz → 1.8.1rc1__tar.gz

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.8.0
+Version: 1.8.1rc1
 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.8.0 → cecli_dev-1.8.1rc1}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.8.0'
-__version_tuple__ = version_tuple = (1, 8, 0)
+__version__ = version = '1.8.1rc1'
+__version_tuple__ = version_tuple = (1, 8, 1, 'rc1')
 
-__commit_id__ = commit_id = 'gbf30ff4c0'
+__commit_id__ = commit_id = 'g15af71fcd'

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli/coders/base_coder.py

@@ -3996,7 +3996,7 @@ class Coder(metaclass=UsageMeta):
         if (
             not len(self.partial_response_content)
             and not len(self.partial_response_tool_calls)
-            and not len(self.partial_response_reasoning_content)
+            and not _is_meaningful_reasoning(self.partial_response_reasoning_content)
         ):
             self.empty_response = True
             return
@@ -4126,7 +4126,8 @@ class Coder(metaclass=UsageMeta):
 
                             text += reasoning_content
                             self.got_reasoning_content = True
-                            received_content = True
+                            if _is_meaningful_reasoning(reasoning_content):
+                                received_content = True
 
                         self.token_profiler.on_token()
                         self.io.update_spinner_suffix(reasoning_content)
@@ -4202,7 +4203,14 @@ class Coder(metaclass=UsageMeta):
             self.io.tool_warning("Execution stopped by on message hook")
             return
 
-        if not received_content and len(self.partial_response_tool_calls) == 0:
+        # Treat the response as empty when nothing was received, or when the
+        # only thing received was reasoning made entirely of non-alphanumeric
+        # characters (e.g. moonshotai/kimi-k3 returning "!!!!").
+        if (
+            not received_content
+            and len(self.partial_response_tool_calls) == 0
+            and not _is_meaningful_reasoning(self.partial_response_reasoning_content)
+        ):
             self.empty_response = True
             return
 
@@ -5391,3 +5399,15 @@ def _first_usage_tokens(usage: object, paths: list[str], default: int = 0) -> in
         if value is not None:
             return value
     return default
+
+
+def _is_meaningful_reasoning(text):
+    """Return True if reasoning text contains at least one alphanumeric character.
+
+    Some providers (e.g. moonshotai/kimi-k3) occasionally return completions
+    with empty ``content`` and a ``reasoning_content`` made entirely of
+    punctuation (e.g. ``"!!!!"``). Those responses are effectively empty, so
+    the empty-response detector only lets reasoning count as response
+    content when it holds at least one alphanumeric character.
+    """
+    return bool(text) and any(ch.isalnum() for ch in text)

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli/helpers/llms/domains/bedrock.py

@@ -194,7 +194,7 @@ def bedrock_endpoint(resolved: Dict[str, Any]) -> str:
         )
 
     route = resolved["route"]
-    return f"https://bedrock-runtime.{region}.amazonaws.com/model/{route}/converse"
+    return f"{resolved['api_base']}/model/{route}/converse"
 
 
 def _signed_headers(

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli/helpers/workflows/config.py

@@ -10,8 +10,9 @@ Resolution order, highest precedence first:
    ``None``, ``''``, ``'{}'``, ``'[]'`` and ``'null'`` count as *absent* so that
    lower-precedence sources still load.
 2. ``<git_root or cwd>/.cecli.workflows.yml`` / ``.cecli.workflows.yaml``.
-3. ``merged_config["workflows"]`` — the deep-merged ``.cecli.conf.yml`` value.
-4. ``~/.cecli/workflows/*.yml`` / ``*.yaml`` — globbed in stable sorted order.
+3. ``<git_root or cwd>/.cecli/workflows/*.yml`` / ``*.yaml`` — globbed in stable sorted order.
+4. ``merged_config["workflows"]`` — the deep-merged ``.cecli.conf.yml`` value.
+5. ``~/.cecli/workflows/*.yml`` / ``*.yaml`` — globbed in stable sorted order.
 
 Each source may hold a single workflow mapping or a ``workflows: [...]`` list.
 On a duplicate ``name`` the higher-precedence definition wins and the loser is
@@ -93,6 +94,7 @@ def resolve_workflow_configs(
         ordered += _entries_from_arg(str(config_arg))
 
     ordered += _entries_from_local(git_root)
+    ordered += _entries_from_local_dir(git_root)
 
     if isinstance(merged_config, dict):
         ordered += _entries(merged_config.get("workflows"), None, _CONFIG_LABEL)
@@ -289,9 +291,21 @@ def _entries_from_local(git_root: Optional[Any]) -> List[_Discovered]:
     return []
 
 
+def _entries_from_local_dir(git_root: Optional[Any]) -> List[_Discovered]:
+    """Resolve a repo-local ``.cecli/workflows/*.yml|*.yaml`` directory."""
+    base = Path(git_root).expanduser() if git_root else Path.cwd()
+
+    return _entries_from_dir(base / WORKFLOW_DIR)
+
+
 def _entries_from_home() -> List[_Discovered]:
     """Resolve ``~/.cecli/workflows/*.yml|*.yaml`` in stable sorted order."""
-    root = Path.home() / WORKFLOW_DIR
+
+    return _entries_from_dir(Path.home() / WORKFLOW_DIR)
+
+
+def _entries_from_dir(root: Path) -> List[_Discovered]:
+    """Resolve ``*.yml`` / ``*.yaml`` files under *root* in stable sorted order."""
     if not root.is_dir():
         return []
 

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli/website/docs/config/retries.md

@@ -11,6 +11,7 @@ Cecli can be configured to retry failed API calls. This is useful for handling i
 - `retry-timeout`: The timeout in seconds for each retry.
 - `retry-backoff-factor`: The backoff factor to use between retries.
 - `retry-on-unavailable`: Whether to retry on 503 Service Unavailable errors.
+- `retry-on-empty`: Whether to retry when the model returns an empty response. A response is considered empty when it has no content, no tool calls, and no *meaningful* reasoning. Reasoning that contains no alphanumeric characters (for example a `reasoning_content` of `"!!!!"`) does not count as a response, so it is retried like any other empty response.
 - `retry-on-unauthorized`: Whether to retry on 401 Unauthorized (and 403 Forbidden) errors. Default: false.
 
 Example usage in `.cecli.conf.yml`:

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli/website/docs/config/scheduler.md

@@ -1,7 +1,7 @@
 ---
 parent: Configuration
 nav_order: 48
-description: The scheduler turns workflow schedule: entries into runs, coordinating any number of cecli instances through a shared SQLite database.
+description: The scheduler turns workflow schedule entries into runs, coordinating any number of cecli instances through a shared SQLite database.
 ---
 # Scheduler
 

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli/website/docs/config/workflows.md

@@ -17,12 +17,13 @@ Preferred: one YAML file per workflow in `~/.cecli/workflows/`:
     morning-triage.yml
 ```
 
-Also supported: inline under a `workflows:` key in `.cecli.conf.yml`, or a repo-local `.cecli.workflows.yml`. Each source may hold a single workflow mapping, a `workflows: [...]` list, or a plain list of mappings. Resolution precedence (highest first):
+Also supported: a repo-local `.cecli/workflows/` directory (one YAML file per workflow), inline under a `workflows:` key in `.cecli.conf.yml`, or a repo-local `.cecli.workflows.yml`. Each source may hold a single workflow mapping, a `workflows: [...]` list, or a plain list of mappings. Resolution precedence (highest first):
 
 1. **CLI argument** — an inline JSON/YAML string or a file path passed to `--workflows`.
 2. **Local file** — `.cecli.workflows.yml` / `.cecli.workflows.yaml` in the git root (or working directory).
-3. **Merged config** — the `workflows:` key in `.cecli.conf.yml`.
-4. **Global files** — `~/.cecli/workflows/*.yml` / `*.yaml`, loaded in sorted order.
+3. **Local directory** — `.cecli/workflows/*.yml` / `*.yaml` in the git root (or working directory), loaded in sorted order.
+4. **Merged config** — the `workflows:` key in `.cecli.conf.yml`.
+5. **Global files** — `~/.cecli/workflows/*.yml` / `*.yaml`, loaded in sorted order.
 
 On a duplicate `name`, the higher-precedence definition wins and the loser is skipped with a warning. A source that fails to parse is skipped with a warning as well — a malformed workflows file never crashes startup.
 

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.8.0
+Version: 1.8.1rc1
 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.8.0 → cecli_dev-1.8.1rc1}/cecli_dev.egg-info/SOURCES.txt

@@ -686,6 +686,7 @@ tests/basic/test_custom_commands.py
 tests/basic/test_deprecated.py
 tests/basic/test_editblock.py
 tests/basic/test_editor.py
+tests/basic/test_empty_response.py
 tests/basic/test_exceptions.py
 tests/basic/test_file_system_service.py
 tests/basic/test_find_or_blocks.py

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/cecli_dev.egg-info/scm_file_list.json

@@ -926,6 +926,7 @@
     "tests/basic/test_deprecated.py",
     "tests/basic/test_editblock.py",
     "tests/basic/test_editor.py",
+    "tests/basic/test_empty_response.py",
     "tests/basic/test_exceptions.py",
     "tests/basic/test_file_system_service.py",
     "tests/basic/test_find_or_blocks.py",

cecli_dev-1.8.1rc1/cecli_dev.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.8.1rc1",
+  "distance": 0,
+  "node": "g15af71fcdb6adc69eaa552bd209a8bc1838445ba",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-13"
+}

cecli_dev-1.8.1rc1/tests/basic/test_empty_response.py

@@ -0,0 +1,223 @@
+"""Tests for empty-response detection with non-meaningful reasoning content.
+
+Regression coverage for the ``retry-on-empty`` fix: a completion with empty
+``content``, no tool calls, and a ``reasoning_content`` made entirely of
+non-alphanumeric characters (e.g. moonshotai/kimi-k3 returning ``"!!!!"``) must
+be classified as an empty response so the existing retry loop engages.
+"""
+
+from types import SimpleNamespace
+
+import pytest
+
+from cecli.coders.base_coder import Coder, _is_meaningful_reasoning
+from cecli.helpers.threading import ThreadSafeEvent
+from cecli.llm import litellm
+
+
+# --------------------------------------------------------------------------- #
+# Test doubles
+# --------------------------------------------------------------------------- #
+class _AlwaysSetEvent:
+    def is_set(self):
+        return True
+
+
+class _FakeIO:
+    def __init__(self):
+        self.confirmation_in_progress_event = _AlwaysSetEvent()
+        self.assistant_outputs = []
+
+    def tool_error(self, *a, **k):
+        pass
+
+    def tool_warning(self, *a, **k):
+        pass
+
+    def update_spinner_suffix(self, *a, **k):
+        pass
+
+    def reset_streaming_response(self):
+        pass
+
+    def stream_output(self, *a, **k):
+        pass
+
+    def ai_output(self, *a, **k):
+        pass
+
+    def tool_output(self, *a, **k):
+        pass
+
+    def assistant_output(self, *a, **k):
+        self.assistant_outputs.append(a)
+
+
+class _FakeTokenProfiler:
+    def start(self):
+        pass
+
+    def on_token(self):
+        pass
+
+    def on_error(self):
+        pass
+
+    def add_to_usage_report(self, *a, **k):
+        return a[0] if a else ""
+
+
+def _make_coder(stream=False):
+    coder = Coder.__new__(Coder)
+    coder.stream = stream
+    coder.verbose = False
+    coder.args = SimpleNamespace(debug=False, show_thinking=False)
+    coder.io = _FakeIO()
+    coder.interrupt_event = ThreadSafeEvent()
+    coder.pretty = False
+    coder.reasoning_tag_name = "THINKING"
+    coder.got_reasoning_content = False
+    coder.ended_reasoning_content = False
+    coder.empty_response = False
+    coder.tool_reflection = False
+    coder.partial_response_content = ""
+    coder.partial_response_reasoning_content = ""
+    coder.partial_response_chunks = []
+    coder.partial_response_tool_calls = []
+    coder.partial_response_function_call = dict()
+    coder.partial_response_consolidated = None
+    coder.multi_response_content = ""
+    coder.chat_completion_response_hashes = []
+    coder._streaming_buffer_length = 0
+    coder.token_profiler = _FakeTokenProfiler()
+    coder._output_loop_detected = False
+    coder._output_loop_message = ""
+    coder._has_empty_reflected = False
+    coder.edit_format = "code"
+    return coder
+
+
+def _tc(index, call_id, name, arguments):
+    return litellm.ChatCompletionMessageToolCall(
+        id=call_id,
+        function=litellm.Function(arguments=arguments or "", name=name),
+        type="function",
+        index=index,
+    )
+
+
+def _non_streaming_completion(content="", reasoning=None, tool_calls=None):
+    message = {"role": "assistant", "content": content}
+    if reasoning is not None:
+        message["reasoning_content"] = reasoning
+    if tool_calls is not None:
+        message["tool_calls"] = tool_calls
+    return litellm.ModelResponse(
+        id="test-completion",
+        created=0,
+        model="gpt-test",
+        object="chat.completion",
+        choices=[{"finish_reason": "stop", "index": 0, "message": message}],
+        usage={"completion_tokens": 1, "prompt_tokens": 1, "total_tokens": 2},
+    )
+
+
+def _reasoning_chunk(text):
+    delta = litellm.Delta(role="assistant", content=None, reasoning_content=text)
+    choice = litellm.StreamChoice(finish_reason=None, index=0, delta=delta)
+    return litellm.StreamChunk(
+        id="cmpl-test", created=1000, model="gpt-test", choices=[choice], usage=None
+    )
+
+
+async def _agen(chunks):
+    for chunk in chunks:
+        yield chunk
+
+
+# --------------------------------------------------------------------------- #
+# _is_meaningful_reasoning unit tests
+# --------------------------------------------------------------------------- #
+def test_is_meaningful_reasoning_empty_and_none():
+    assert _is_meaningful_reasoning("") is False
+    assert _is_meaningful_reasoning(None) is False
+
+
+def test_is_meaningful_reasoning_punctuation_only():
+    assert _is_meaningful_reasoning("!!!!") is False
+    assert _is_meaningful_reasoning("...?!,;:") is False
+
+
+def test_is_meaningful_reasoning_whitespace_only():
+    assert _is_meaningful_reasoning("   \n\t  ") is False
+
+
+def test_is_meaningful_reasoning_normal_text():
+    assert _is_meaningful_reasoning("Let me think about this") is True
+
+
+def test_is_meaningful_reasoning_mixed_punctuation_and_alnum():
+    assert _is_meaningful_reasoning("42?") is True
+    assert _is_meaningful_reasoning("!!!a!!!") is True
+
+
+# --------------------------------------------------------------------------- #
+# Non-streaming path (show_send_output)
+# --------------------------------------------------------------------------- #
+@pytest.mark.asyncio
+async def test_junk_reasoning_is_empty_non_streaming():
+    coder = _make_coder(stream=False)
+    await coder.show_send_output(_non_streaming_completion(content="", reasoning="!" * 40))
+    assert coder.empty_response is True
+
+
+@pytest.mark.asyncio
+async def test_meaningful_reasoning_is_not_empty_non_streaming():
+    coder = _make_coder(stream=False)
+    await coder.show_send_output(
+        _non_streaming_completion(content="", reasoning="Let me think about this")
+    )
+    assert coder.empty_response is False
+
+
+@pytest.mark.asyncio
+async def test_tool_calls_are_not_empty_non_streaming():
+    coder = _make_coder(stream=False)
+    await coder.show_send_output(
+        _non_streaming_completion(
+            content="",
+            reasoning="",
+            tool_calls=[_tc(0, "call_1", "Local--ls", "{}")],
+        )
+    )
+    assert coder.empty_response is False
+
+
+@pytest.mark.asyncio
+async def test_mixed_reasoning_is_not_empty_non_streaming():
+    coder = _make_coder(stream=False)
+    await coder.show_send_output(_non_streaming_completion(content="", reasoning="42?"))
+    assert coder.empty_response is False
+
+
+# --------------------------------------------------------------------------- #
+# Streaming path (show_send_output_stream)
+# --------------------------------------------------------------------------- #
+@pytest.mark.asyncio
+async def test_junk_reasoning_is_empty_streaming():
+    coder = _make_coder(stream=True)
+    coder.args.show_thinking = True
+    async for _ in coder.show_send_output_stream(_agen([_reasoning_chunk("!" * 40)])):
+        pass
+    assert coder.empty_response is True
+
+
+@pytest.mark.asyncio
+async def test_meaningful_reasoning_is_not_empty_streaming():
+    coder = _make_coder(stream=True)
+    coder.args.show_thinking = True
+    async for _ in coder.show_send_output_stream(
+        _agen([_reasoning_chunk("Let me think about this")])
+    ):
+        pass
+    assert coder.empty_response is False

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/tests/helpers/test_llms_hyperscalers.py

@@ -153,6 +153,19 @@ def test_bedrock_endpoint_requires_region():
         raise AssertionError("expected ValueError without a region")
 
 
+def test_bedrock_endpoint_built_from_resolved_api_base(monkeypatch):
+    # The Converse URL is assembled from resolved["api_base"] verbatim rather
+    # than a hardcoded public host, so a custom endpoint (VPC endpoint, proxy,
+    # LocalStack, ...) resolved onto api_base is honored.
+    monkeypatch.setenv("AWS_REGION_NAME", "us-east-1")
+    resolved = {
+        "route": "anthropic.claude-sonnet",
+        "api_base": "https://bedrock.internal.example.com",
+    }
+    url = bedrock_endpoint(resolved)
+    assert url == ("https://bedrock.internal.example.com/model/anthropic.claude-sonnet/converse")
+
+
 # ---------------------------------------------------------------------------
 # Chat-family wiring: signer hook + extra_query
 # ---------------------------------------------------------------------------

{cecli_dev-1.8.0 → cecli_dev-1.8.1rc1}/tests/helpers/workflows/test_config.py

@@ -44,6 +44,14 @@ def _mapping_text(name: str, prompt: str) -> str:
     return f"name: {name}\ntasks:\n  - prompt: {prompt}\n"
 
 
+def _local_dir_workflow(repo: Path, filename: str, text: str) -> Path:
+    wdir = repo / ".cecli" / "workflows"
+    wdir.mkdir(parents=True, exist_ok=True)
+    path = wdir / filename
+    path.write_text(text, encoding="utf-8")
+    return path
+
+
 # ── Case 1: single-mapping file, defaults ───────────────────────────────────
 
 
@@ -455,6 +463,55 @@ def test_bad_local_file_does_not_block_home_files(isolated, caplog):
 # ── Case 8: definition_hash stability ───────────────────────────────────────
 
 
+def test_local_dir_files_are_loaded(isolated):
+    _local_dir_workflow(isolated["repo"], "pipelines.yml", _mapping_text("local-dir", "check"))
+
+    configs = load_workflows(git_root=isolated["repo"])
+
+    assert [wf.name for wf in configs] == ["local-dir"]
+    assert configs[0].source_path == str(
+        isolated["repo"] / ".cecli" / "workflows" / "pipelines.yml"
+    )
+
+
+def test_local_dir_globs_stably_sorted(isolated):
+    _local_dir_workflow(isolated["repo"], "b_second.yml", _mapping_text("b", "second"))
+    _local_dir_workflow(isolated["repo"], "a_first.yml", _mapping_text("a", "first"))
+
+    configs = load_workflows(git_root=isolated["repo"])
+
+    assert [wf.name for wf in configs] == ["a", "b"]
+
+
+def test_local_dir_defaults_to_cwd(isolated):
+    _local_dir_workflow(isolated["repo"], "here.yml", _mapping_text("here", "cwd"))
+
+    configs = load_workflows()
+
+    assert [wf.name for wf in configs] == ["here"]
+
+
+def test_local_file_wins_over_local_dir(isolated):
+    _local_dir_workflow(isolated["repo"], "dir.yml", _mapping_text("dup", "dir"))
+    (isolated["repo"] / WORKFLOW_FILENAMES[0]).write_text(
+        _mapping_text("dup", "local-file"), encoding="utf-8"
+    )
+
+    configs = load_workflows(git_root=isolated["repo"])
+
+    assert [wf.tasks[0].prompt for wf in configs] == ["local-file"]
+
+
+def test_local_dir_wins_over_merged_config_and_home(isolated):
+    _local_dir_workflow(isolated["repo"], "dir.yml", _mapping_text("dup", "dir"))
+    _home_workflow(isolated["wdir"], "a_home.yml", _mapping_text("dup", "home"))
+    merged = {"workflows": [{"name": "dup", "tasks": [{"prompt": "merged"}]}]}
+
+    configs = load_workflows(merged_config=merged, git_root=isolated["repo"])
+
+    assert [wf.tasks[0].prompt for wf in configs] == ["dir"]
+
+
 def test_definition_hash_stable_across_key_order():
     one = models.WorkflowConfig.from_dict(
         {"name": "h", "tasks": [{"prompt": "a", "name": "t1"}], "enabled": True}

cecli_dev-1.8.0/cecli_dev.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.8.0",
-  "distance": 0,
-  "node": "gbf30ff4c02df12ec6c05ac71d84566220f68f804",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-12"
-}