mini-code-cli 0.1.1.2__py3-none-any.whl → 0.1.1.3__py3-none-any.whl

mini_code_cli/__init__.py

@@ -11,22 +11,41 @@ to ``"unknown"`` so importing the package can never fail over a version lookup.
 __all__ = ["__version__"]
 
 
+def _version_from_file(path):
+    """Return the ``[project] version`` in ``path``.
+
+    ``tomllib`` only exists from Python 3.11, and the scan below is not a
+    nicety for 3.10: without it this function used to skip the file entirely on
+    that interpreter and report the *installed* metadata instead, so a checkout
+    with a stale editable install showed the wrong version in the banner (found
+    on the 3.10 CI leg). Both paths read the same key, and the section tracking
+    matters: a ``version`` key in some other table must not win.
+    """
+    try:
+        import tomllib  # Python >= 3.11
+    except ImportError:  # pragma: no cover - exercised on the 3.10 CI leg
+        tomllib = None
+    if tomllib is not None:
+        with open(path, "rb") as f:
+            return str(tomllib.load(f)["project"]["version"])
+    section = None
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            stripped = line.strip()
+            if stripped.startswith("["):
+                section = stripped
+            elif section == "[project]" and stripped.startswith("version"):
+                return stripped.split("=", 1)[1].strip().strip('"')
+    raise KeyError(f"no version in the [project] table of {path}")
+
+
 def _read_version():
     """Best-effort package version: pyproject.toml, then installed metadata."""
     try:
         from pathlib import Path
 
         pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
-        try:
-            import tomllib  # Python >= 3.11
-        except ImportError:  # pragma: no cover - older interpreters
-            tomllib = None
-        if tomllib is not None:
-            try:
-                with open(pyproject, "rb") as f:
-                    return str(tomllib.load(f)["project"]["version"])
-            except Exception:
-                pass
+        return _version_from_file(pyproject)
     except Exception:
         pass
     try:

mini_code_cli/__main__.py

@@ -0,0 +1,12 @@
+"""Allow ``python -m mini_code_cli`` to start the agent.
+
+The console script ``mini-code`` (see ``[project.scripts]``) is the normal entry
+point; this module exists so the package also runs straight from a checkout or
+an installed wheel without the script on ``PATH`` -- which is what a reader
+tries first after ``pip install -e .``.
+"""
+
+from .agent_loop import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mini_code_cli/agent_loop.py

@@ -31,7 +31,7 @@ from . import prompts
 from . import shell_safety_utils
 from . import tools
 from . import utils
-from .utils import oneline
+from .utils import oneline, plural
 from . import ui
 from . import subagents
 from . import skills
@@ -118,7 +118,12 @@ def _safe_int(value, default=0):
 # ---------------------------------------------------------------------------
 
 def parse_args():
-    parser = argparse.ArgumentParser(description="Agent loop for interacting with a language model")
+    # ``prog`` is pinned so ``--help`` reads the same whether the agent was
+    # started through the ``mini-code`` script, ``python -m mini_code_cli`` or
+    # a test harness (without it, the usage line said ``__main__.py``).
+    parser = argparse.ArgumentParser(
+        prog="mini-code",
+        description="Agent loop for interacting with a language model")
     # MODEL / LLM related
     parser.add_argument("--url", type=str, default=f"{DEFAULT_MODEL_URL}", help=f"API host, default={DEFAULT_MODEL_URL}")
     parser.add_argument("--max-tokens", type=int, help="Maximum tokens for a single LLM response (the reply budget), default=None. Also used as the output headroom reserved when deriving the compaction limit from the model's context window.")
@@ -298,11 +303,6 @@ def _in_flight_tail(messages):
     return []
 
 
-def _plural(count, noun, suffix="s"):
-    """``"1 message"`` / ``"4 messages"`` -- for messages the user reads."""
-    return f"{count} {noun}" + ("" if count == 1 else suffix)
-
-
 def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats,
                   history_index=0, token_limit=None, reserved_output_tokens=0,
                   current_tokens=None, plan_hook=None, console=None):
@@ -358,12 +358,12 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
     # stake; a compaction note that stays silent about that is exactly what makes
     # the rollover look like it might have eaten the message.
     tail = _in_flight_tail(messages)
-    kept_note = (f" The current turn ({_plural(len(tail), 'message')}) is kept "
+    kept_note = (f" The current turn ({plural(len(tail), 'message')}) is kept "
                  f"verbatim." if tail else "")
 
     try:
         console.note(
-            f"Compacting the conversation: {_plural(len(messages), 'message')} "
+            f"Compacting the conversation: {plural(len(messages), 'message')} "
             f"-> a summary ({reason}).{kept_note}", "warn")
         summary_prompt = prompts.compaction_prompt(messages)
 
@@ -404,7 +404,7 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
             # may still be too large.
             console.note(
                 f"Could not compact history: the summariser returned an empty "
-                f"summary twice. Keeping all {_plural(len(messages), 'message')} "
+                f"summary twice. Keeping all {plural(len(messages), 'message')} "
                 f"and history_{history_index}.json as they are -- nothing was "
                 f"lost, but the next request may still be too large "
                 f"({reason}).", "warn")
@@ -449,7 +449,7 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
         # and *where it went* (which segment file was closed and which was
         # started).
         console.note(f"Summary preview: {utils.oneline(summary, 120)}", "warn")
-        kept = (f"summary + {_plural(len(tail), 'kept message')}" if tail
+        kept = (f"summary + {plural(len(tail), 'kept message')}" if tail
                 else "summary only")
         # Phrased as "old segment -> new segment" rather than "N messages -> M
         # messages": the replacement can be *longer* than what it replaced (a
@@ -457,9 +457,9 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
         # counts that sometimes grows reads like a bug.
         console.note(
             f"Compacted history_{history_index}.json "
-            f"({_plural(len(messages), 'message')}) into a summary; "
+            f"({plural(len(messages), 'message')}) into a summary; "
             f"history_{history_index + 1}.json now starts with "
-            f"{_plural(len(compacted), 'message')} ({kept}).", "warn")
+            f"{plural(len(compacted), 'message')} ({kept}).", "warn")
         # A new segment (history_index + 1) is started on compaction: the
         # compacted messages are its snapshot, and every later turn appends
         # to it. The caller records a single high-level 'summary' turn for
@@ -468,7 +468,7 @@ def maybe_compact(messages, server_url, model, api_key, llm_timeout, token_stats
     except Exception as e:
         console.note(
             f"Failed to compact history: {e}. Keeping all "
-            f"{_plural(len(messages), 'message')} unchanged.", "error")
+            f"{plural(len(messages), 'message')} unchanged.", "error")
 
     return messages, False, history_index
 
@@ -1960,7 +1960,9 @@ class AgentSession:
         #    just the turns. In verbose mode everything is printed permanently.
         transient = not self.console.verbose
         func = self.tools_dict[name]["function"]
-        result = call_function_with_timeout(func, tool_params, name, timeout_seconds=self.args.tool_timeout)
+        result = call_function_with_timeout(func, tool_params, name,
+                                            timeout_seconds=self.args.tool_timeout,
+                                            console=self.console)
 
         self.console.tool_call_display(name, tool_params, result, transient=transient)
         self._append_tool_result(call_id, str(result))
@@ -2105,8 +2107,8 @@ class AgentSession:
             ("session id", self.unique_id),
             ("saved under", f"{self.cache_dir}/{self.unique_id}/"),
             ("history", f"{where} (segment {self.history_index}), "
-                        f"{_plural(len(self.messages), 'message')}"),
-            ("conversation", _plural(turns, "recorded turn")),
+                        f"{plural(len(self.messages), 'message')}"),
+            ("conversation", plural(turns, "recorded turn")),
             ("tokens", f"{count('prompt_tokens'):,} in / "
                        f"{count('completion_tokens'):,} out "
                        f"({count('total_tokens'):,} total)"),
@@ -2176,7 +2178,7 @@ class AgentSession:
             save_history(self.messages, self.cache_dir, self.unique_id, self.history_index)
             self._record_turn(
                 f"summary: history_{new_index - 1}.json "
-                f"({_plural(len(closing_messages), 'message')}) compacted into a "
+                f"({plural(len(closing_messages), 'message')}) compacted into a "
                 f"summary; history_{self.history_index}.json started",
                 self.messages)
 

mini_code_cli/runner.py

@@ -18,13 +18,19 @@ class _TimedOut(Exception):
     pass
 
 
-def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_TOOL_TIMEOUT):
+def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_TOOL_TIMEOUT,
+                               console=None):
     """Call ``func(**tool_params)``, aborting after ``timeout_seconds``.
 
     On timeout -- or if the tool raises *any* other exception -- a friendly
     ``Error:`` string is returned so the failure reaches the model as a tool
     result (letting it recover or retry) instead of propagating and crashing the
     whole agent loop. A timeout is reported distinctly from a generic failure.
+
+    ``console`` is the session's console. It defaults to the shared one so a
+    bare call still works, but the agent loop passes its own: a sub-agent's
+    console redirects its output, and reporting to the module-level console
+    would print a background child's tool errors onto the user's terminal.
     """
     def _handler(signum, frame):
         raise _TimedOut()
@@ -35,30 +41,32 @@ def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_
         # signal only works in the main thread; if we cannot arm it, just run
         # the tool without the wall-clock guard rather than failing outright --
         # but still shield the loop from a tool that raises.
-        return _call_tool_safely(func, tool_params, name)
+        return _call_tool_safely(func, tool_params, name, console)
 
+    console = console if console is not None else ui.console
     signal.alarm(int(timeout_seconds) if timeout_seconds else 0)
     try:
         return func(**tool_params)
     except _TimedOut:
-        ui.console.note(f"Function {name} timed out after {timeout_seconds} seconds.", "error")
+        console.note(f"Function {name} timed out after {timeout_seconds} seconds.", "error")
         return f"Error: Function {name} timed out after {timeout_seconds} seconds."
     except Exception as e:  # noqa: BLE001 -- a failing tool must not crash the loop
-        ui.console.note(f"Tool {name} raised an error: {e}", "error")
+        console.note(f"Tool {name} raised an error: {e}", "error")
         return f"Error: tool {name} raised an error: {e}"
     finally:
         signal.alarm(0)
         signal.signal(signal.SIGALRM, previous)
 
 
-def _call_tool_safely(func, tool_params, name):
+def _call_tool_safely(func, tool_params, name, console=None):
     """Run a tool with no wall-clock guard (SIGALRM unavailable) but still
     shield the loop from a tool that raises.
 
     Used as the fallback when we could not arm SIGALRM (e.g. a non-main thread).
     """
+    console = console if console is not None else ui.console
     try:
         return func(**tool_params)
     except Exception as e:  # noqa: BLE001 -- never let a tool exception propagate
-        ui.console.note(f"Tool {name} raised an error: {e}", "error")
+        console.note(f"Tool {name} raised an error: {e}", "error")
         return f"Error: tool {name} raised an error: {e}"

mini_code_cli/skills.py

@@ -294,7 +294,10 @@ def run_skill(allowed_dir, skill_name, script_name, args=None):
     argv = shlex.split(args) if args else []
     cmd = [sys.executable, script_path] + argv
     try:
-        result = subprocess.run(cmd, capture_output=True, text=True,
+        # Run *inside* the skill's own directory: a script that writes or reads
+        # a relative path then stays in the skill folder instead of landing in
+        # whatever directory the agent process happens to have inherited.
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd=base,
                                 timeout=DEFAULT_TOOL_TIMEOUT, check=False)
     except Exception as e:
         return f"Error: {e}"

mini_code_cli/ui.py

@@ -29,7 +29,7 @@ import shutil
 import sys
 import threading
 
-from .utils import oneline
+from .utils import oneline, plural
 
 # --- ANSI SGR codes ---------------------------------------------------------
 _RESET = "\033[0m"
@@ -348,12 +348,6 @@ class Console:
                 styled_lines.append(text)
         self.print_box(styled_lines, title=title, fg=fg)
 
-    def truncate(self, text, limit):
-        text = str(text)
-        if len(text) > limit:
-            return text[:limit] + "... (truncated)"
-        return text
-
     @staticmethod
     def _oneline(text, limit=None):
         """Collapse ``text`` to one line (delegates to :func:`utils.oneline`)."""
@@ -570,7 +564,7 @@ class Console:
         """Render one attempted tool call: its name, parameters and result."""
         self.emit(self.style(f"{self.glyph('gear')} {name}", fg="magenta", bold=True))
         for key, value in (params or {}).items():
-            snippet = self.truncate(self._oneline(str(value), 100), 100)
+            snippet = self._oneline(str(value), 100)
             key_str = self.style(f"    {key}:", fg="gray", dim=True) if self.color_enabled \
                 else f"    {key}:"
             self.emit(f"{key_str} {snippet}")
@@ -586,7 +580,7 @@ class Console:
                 first = text.splitlines()[0] if text.strip() else "(no output)"
                 arrow = self.style(self.glyph("arrow"), fg=color) if self.color_enabled \
                     else self.glyph("arrow")
-                self.emit(f"    {arrow} {self.truncate(first, 300)}")
+                self.emit(f"    {arrow} {self._oneline(first, 300)}")
 
     def tool_call_display(self, name, params=None, result=None, transient=True):
         """Render one attempted tool call.
@@ -624,7 +618,7 @@ class Console:
                     f"total={usage.get('total_tokens', 0)}")
         if llm_calls is not None:
             calls = int(llm_calls)
-            text += f" | {calls} LLM call{'' if calls == 1 else 's'}"
+            text += f" | {plural(calls, 'LLM call')}"
         label = self.style("tokens", fg="cyan", dim=True) if self.color_enabled else "tokens"
         return f"{label}: {text}"
 
@@ -683,7 +677,7 @@ class Console:
         self.emit(self.style(header, bold=True, fg="cyan"))
         for turn, what, where in rows:
             turn_cell = self.style(turn.rjust(turn_w), fg="magenta", bold=True) if self.color_enabled else turn.rjust(turn_w)
-            what_cell = self.style(self.truncate(what, what_w), dim=True) if self.color_enabled else what.ljust(what_w)
+            what_cell = self.style(self._oneline(what, what_w), dim=True) if self.color_enabled else what.ljust(what_w)
             where_cell = self.style(where, fg="gray", dim=True) if self.color_enabled else where
             self.emit(f"{turn_cell}  {what_cell}  {where_cell}")
         self.emit(self.style("(commands: /history <n> to inspect, /reset <n> to rewind)", dim=True, fg="cyan"))

mini_code_cli/utils.py

@@ -1,6 +1,5 @@
 import requests
 import json
-import sys
 
 
 def oneline(text, limit=None):
@@ -23,6 +22,17 @@ def oneline(text, limit=None):
     return one
 
 
+def plural(count, noun, suffix="s"):
+    """``"1 message"`` / ``"4 messages"`` -- for text a human reads.
+
+    Lives here, next to :func:`oneline`, because both the agent loop (compaction
+    notes, the good-bye box) and the console (usage lines) build user-facing
+    counts; three inline ``'' if n == 1 else 's'`` expressions had already
+    drifted before this was factored out.
+    """
+    return f"{count} {noun}" + ("" if count == 1 else suffix)
+
+
 def _coerce_usage_int(value):
     """Best-effort: coerce a raw usage field to a non-negative int.
 
@@ -131,11 +141,14 @@ def call_openai_server(messages, max_tokens=2048, temperature=0.0, model="defaul
     if api_key:
         headers["Authorization"] = f"Bearer {api_key}"
 
+    # Note: the request timeout is a *transport* concern and is passed to
+    # ``requests.post(timeout=...)`` below, not put in the JSON body -- it is
+    # not a field of the chat-completions API, and strict gateways reject
+    # unexpected keys.
     payload = {
         "model": model,
         "messages": messages,
         "temperature": temperature,
-        "timeout": timeout,
     }
 
     if max_tokens is not None:
@@ -159,7 +172,10 @@ def call_openai_server(messages, max_tokens=2048, temperature=0.0, model="defaul
         )
         response.raise_for_status()
 
-        result = response.json().get("choices", [{}])[0].get("message", {})
+        # Parse the body once: a second ``response.json()`` call re-decodes it
+        # and can raise on a server that sends a slightly different body.
+        body = response.json()
+        result = body.get("choices", [{}])[0].get("message", {})
         content = result.get("content", "")
         tool_calls = result.get("tool_calls", [])
         # Thinking-mode servers return the chain of thought next to ``content``.
@@ -172,7 +188,7 @@ def call_openai_server(messages, max_tokens=2048, temperature=0.0, model="defaul
         reasoning_content = result.get("reasoning_content")
 
         # Token usage, when the server reports it (many local servers do not).
-        usage = response.json().get("usage", {}) or {}
+        usage = body.get("usage", {}) or {}
         prompt_tokens = _coerce_usage_int(usage.get("prompt_tokens", 0))
         completion_tokens = _coerce_usage_int(usage.get("completion_tokens", 0))
         total_tokens = _coerce_usage_int(
@@ -187,28 +203,51 @@ def call_openai_server(messages, max_tokens=2048, temperature=0.0, model="defaul
         }, reasoning_content
 
     except requests.exceptions.RequestException as e:
-        print(f"HTTP Error: {e}", file=sys.stderr)
-        # Only probe the response further if we actually got one back. A
-        # request-level failure (timeout, connection refused, DNS) leaves
-        # ``response`` as None, and there is nothing to inspect then.
-        if response is not None:
-            try:
-                # Print the status code / raw body to see the detailed error.
-                print(f"Status Code: {response.status_code}", file=sys.stderr)
-                print(f"Response Body: {response.text}", file=sys.stderr)
-                # If the response is JSON, parse and pretty-print it.
-                try:
-                    error_details = response.json()
-                    print("Parsed Error Details:", file=sys.stderr)
-                    print(json.dumps(error_details, indent=2), file=sys.stderr)
-                except json.JSONDecodeError:
-                    print("Response body is not valid JSON.", file=sys.stderr)
-            except Exception as e:
-                print(f"Problem with (error) response: {e}", file=sys.stderr)
+        _report_request_failure(e, response)
         return None, None, None, None
     except (json.JSONDecodeError, KeyError, IndexError) as e:
-        print(f"Error processing response: {e}", file=sys.stderr)
+        _report(f"Error processing the model's response: {e}")
         return None, None, None, None
     except Exception as e:  # noqa: BLE001 -- a network/parse hiccup must not crash the loop
-        print(f"Unexpected error calling OpenAI server: {e}", file=sys.stderr)
+        _report(f"Unexpected error calling the model server: {e}")
         return None, None, None, None
+
+
+def _report(message, level="error"):
+    """Report a request failure through the console, never straight to stderr.
+
+    ``ui`` imports :func:`oneline` from this module, so the console is imported
+    lazily here to keep the import graph acyclic. A single note -- rather than a
+    multi-line ``print`` -- keeps the transient region intact: this can fire
+    while the "… thinking" spinner owns the bottom line, and writing multi-line
+    text underneath it left the screen mangled.
+    """
+    from . import ui  # local: ui imports oneline from here
+    ui.console.note(oneline(message, 300), level)
+
+
+def _report_request_failure(error, response):
+    """Explain an HTTP failure, folding the server's own words into one line.
+
+    Only the response is inspected more closely when there *is* one: a
+    request-level failure (timeout, refused connection, DNS) leaves ``response``
+    as None, and there is nothing to inspect then. The body is the useful part
+    (servers put the real reason there), so it is kept -- collapsed and
+    truncated -- instead of dumping the whole payload into the terminal.
+    """
+    if response is None:
+        _report(f"HTTP error talking to the model server: {error}")
+        return
+    status = getattr(response, "status_code", "?")
+    detail = ""
+    try:
+        body = response.text or ""
+        try:
+            body = json.dumps(response.json())
+        except json.JSONDecodeError:
+            pass  # not JSON: the raw body is the best we have
+        if body.strip():
+            detail = f": {oneline(body, 200)}"
+    except Exception as e:  # a broken response must not break the report
+        detail = f" (and the error body was unreadable: {e})"
+    _report(f"HTTP {status} from the model server: {error}{detail}")