mini-code-cli 0.1.0.2__tar.gz → 0.1.0.3__tar.gz

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.1.0.2
+Version: 0.1.0.3
 Summary: Mini Coding Agent. Allows you to easily experiment with a small coding agent.
 Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -721,6 +721,7 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - ask-permission: asks user permission before every tool call. For shell commands, commands in the ALLOW tier skip the prompt, DENY is blocked, and ASK always prompts.
 - system-prompt: you can override the default prompt by using a string. (Note: Agent.md is always appended after the system prompt.)
 - load-last-session: instead of starting a fresh conversation, automatically continue your most recently active session from the default cache dir. It resumes under a brand-new session id, so the original session is never overwritten. An explicit `--restore-session` (a specific path) takes precedence if both are given. The "most recent" session is resolved in two steps: at the end of every interactive session, its path is recorded in a tiny `.mini/last_session.json` pointer inside the `--allowed-dir`, and `--load-last-session` consults that pointer first; only if there is no pointer (e.g. a fresh allowed dir, or the `--skills` feature disabled) does it fall back to the timestamp heuristic (the session whose history was modified most recently). The `.mini` pointer is the same directory the `--skills` feature uses, but it is a single dedicated file, so the two never clash.
+- **Interactive session offer:** if a previous session exists in the cache dir but you did **not** explicitly ask to resume one (i.e. neither `--load-last-session` nor `--restore-session` was passed), the prompt asks what you'd like to do before the conversation starts: 1) **Resume** the previous session (splice its history in under a brand-new session id and continue it), 2) **Start a new** session (empty history), or 3) **Exit** (start nothing). Ctrl-C / EOF at the offer is treated as a graceful exit. This is distinct from `--load-last-session`, which silently resumes the most recent session without asking.
 - plan: `--plan` enables **plan mode**. The agent now keeps two tracking files in the session directory: `CURRENT_GOAL.md` (the user's latest instruction) and `CURRENT_PLAN.md` (its own step-by-step plan, which it must update as it works and mark finished once the goal is done). The system message gets an extra instruction telling the agent to do this. Plan mode also changes how history compaction works: after the history is compacted to a summary, the current `CURRENT_PLAN.md` and the user's last instruction (`CURRENT_GOAL.md`) are re-injected into the messages so the agent keeps working against the same goal. When the session ends, the active goal is marked finished in `CURRENT_PLAN.md`.
 
 ### Available tools

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/README.md

@@ -47,6 +47,7 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - ask-permission: asks user permission before every tool call. For shell commands, commands in the ALLOW tier skip the prompt, DENY is blocked, and ASK always prompts.
 - system-prompt: you can override the default prompt by using a string. (Note: Agent.md is always appended after the system prompt.)
 - load-last-session: instead of starting a fresh conversation, automatically continue your most recently active session from the default cache dir. It resumes under a brand-new session id, so the original session is never overwritten. An explicit `--restore-session` (a specific path) takes precedence if both are given. The "most recent" session is resolved in two steps: at the end of every interactive session, its path is recorded in a tiny `.mini/last_session.json` pointer inside the `--allowed-dir`, and `--load-last-session` consults that pointer first; only if there is no pointer (e.g. a fresh allowed dir, or the `--skills` feature disabled) does it fall back to the timestamp heuristic (the session whose history was modified most recently). The `.mini` pointer is the same directory the `--skills` feature uses, but it is a single dedicated file, so the two never clash.
+- **Interactive session offer:** if a previous session exists in the cache dir but you did **not** explicitly ask to resume one (i.e. neither `--load-last-session` nor `--restore-session` was passed), the prompt asks what you'd like to do before the conversation starts: 1) **Resume** the previous session (splice its history in under a brand-new session id and continue it), 2) **Start a new** session (empty history), or 3) **Exit** (start nothing). Ctrl-C / EOF at the offer is treated as a graceful exit. This is distinct from `--load-last-session`, which silently resumes the most recent session without asking.
 - plan: `--plan` enables **plan mode**. The agent now keeps two tracking files in the session directory: `CURRENT_GOAL.md` (the user's latest instruction) and `CURRENT_PLAN.md` (its own step-by-step plan, which it must update as it works and mark finished once the goal is done). The system message gets an extra instruction telling the agent to do this. Plan mode also changes how history compaction works: after the history is compacted to a summary, the current `CURRENT_PLAN.md` and the user's last instruction (`CURRENT_GOAL.md`) are re-injected into the messages so the agent keeps working against the same goal. When the session ends, the active goal is marked finished in `CURRENT_PLAN.md`.
 
 ### Available tools

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/mini_code_cli/agent_loop.py

@@ -138,6 +138,7 @@ def parse_args():
         args.enable_shell = True
         args.sudo = True
         args.auto_mode = True
+        args.skills = True
     
     if args.all_last:
         args.load_last_session = True
@@ -289,36 +290,10 @@ class AgentSession:
         self.model = model_name if model_name else args.model
         self.api_key = args.api_key if args.api_key else os.environ.get("MINI_CODE_API_KEY", "")
 
-        # Which tools the LLM may call. The shell tool is only available when
-        # --enable-shell was passed.
-        forbidden = None if args.enable_shell else tools.shell_tools
-        self.tools_dict = tools.util_get_tools_dict(forbidden_tools=forbidden)
-        self.llm_tools = tools.util_get_tools(forbidden_tools=forbidden)
-
-        # Sub-agents (opt-in via --enable-subagents). Each registered sub-agent
-        # becomes an extra tool the model can call; see subagents/. A child
-        # session built by a sub-agent never sets enable_subagents, so sub-agents
-        # cannot recursively spawn sub-agents.
-        self.enable_subagents = bool(getattr(args, "enable_subagents", False))
-        self.subagents_registry = subagents.get_registry() if self.enable_subagents else {}
-        for sa in self.subagents_registry.values():
-            self.llm_tools.append(sa.tool_schema())
-            # Marked so _run_one_tool_call knows to delegate rather than call a
-            # real function.
-            self.tools_dict[sa.name] = {"function": None, "description": sa.description, "subagent": True}
-
-        # Skills (opt-in via --skills). Each registered skill tool is exposed to
-        # the model as a normal tool, but they are all sandbox-safe: the .mini
-        # directory lives *inside* --allowed-dir and the tools never accept a
-        # path from the model -- skill / script names are validated as single
-        # path segments and resolved under the .mini root. So skills are exposed
-        # even in sessions without --enable-shell (run_skill only executes a
-        # named Python file, never a free-form shell command).
-        self.enable_skills = bool(getattr(args, "enable_skills", False))
-        if self.enable_skills:
-            self.skills_tools_dict = skills.get_skills_tools_dict(self.allowed_dir)
-            self.llm_tools.extend(skills.get_skills_tools(self.allowed_dir))
-            self.tools_dict.update(self.skills_tools_dict)
+        # Which tools the LLM may call (shell / sub-agents / skills), and which
+        # of them are registered. Split out of __init__ for readability -- see
+        # _register_tools().
+        self._register_tools(args)
 
         # Token accounting for the whole session.
         self.token_stats = {
@@ -366,33 +341,47 @@ class AgentSession:
         # cache dir and continues it -- exactly like --restore-session, but without
         # needing to know the folder name. An explicit --restore-session always wins
         # and is used verbatim; otherwise the newest session is resolved here.
+        # A "last session" candidate -- only when the user did NOT explicitly
+        # ask to resume one (no --load-last-session / --restore-session): the
+        # most recent previous session in the cache dir. Unlike a real restore,
+        # the conversation starts empty here and is only spliced in if the user
+        # confirms they want it (see _offer_resume_last_session).
         restore_session = getattr(self.args, "restore_session", None)
+        self.last_session_candidate = None
         self.loaded_last_session_dir = None
-        if getattr(self.args, "load_last_session", False) and not restore_session:
-            # Resolve the most recent session: the .mini pointer recorded under
-            # --allowed-dir is consulted first (an explicit record of the last
-            # session worked in), falling back to the timestamp heuristic over
-            # the cache dir.
-            detected = find_last_session_dir(
-                self.cache_dir,
-                allowed_dir=self.allowed_dir,
-                use_pointer=True,
-            )
-            if detected:
-                restore_session = detected
-                self.loaded_last_session_dir = detected
+        # Resolve the "most recent session" exactly once, and reuse the result
+        # for both concerns below (an explicit --restore-session always wins and
+        # is used verbatim):
+        #   * --load-last-session turns the detected session into a real restore
+        #     (continue it under this new id), OR
+        #   * when the user did NOT explicitly ask to resume (no
+        #     --load-last-session / --restore-session), it becomes a resume
+        #     *candidate* that run() offers interactively (see
+        #     _offer_resume_last_session). The conversation still starts empty
+        #     here and is spliced in only if the user confirms.
+        # Skipped entirely once a real restore is already in hand, so those paths
+        # never offer anything.
+        detected = self._detect_last_session()
+        if getattr(self.args, "load_last_session", False) and not restore_session and detected:
+            restore_session = detected
+            self.loaded_last_session_dir = detected
+        if not restore_session and detected:
+            self.last_session_candidate = detected
         restore_directory = _restore_dir(restore_session)
         restored = load_history_from_dir(restore_directory) if restore_directory else None
+        # A session built from an explicit restore / load-last-session reuses the
+        # restored history (under this brand-new id, so the original is never
+        # overwritten); an idle start keeps the freshly built initial messages.
         self.messages = restored if restored is not None else self._build_initial_messages()
-        if restored is not None:
-            self._restore_usage_if_available(restore_session)
-            self._load_summary_if_restored(restore_directory)
-        else:
-            # --load-last-session asked for a session but nothing usable was found:
-            # don't advertise a load. The recorder starts empty and the first
-            # assistant / tool-call turn seeds turn 1 -- mirroring the restore
-            # path, which also has no leading system turn, so /history turn
-            # numbers stay consistent whether or not we restored.
+        self._restore_from(restore_directory, restored)
+        # --load-last-session asked for a session but nothing usable was found:
+        # clear the flag so run() reports "no previous session to load" instead
+        # of pretending it resumed one. When the restore succeeded the flag set
+        # above (loaded_last_session_dir = detected) is kept so run() prints the
+        # "Loaded most recent session ... and continuing it" note. Best-effort:
+        # a missing/empty/corrupt history falls back to a fresh session rather
+        # than crashing.
+        if restored is None:
             self.loaded_last_session_dir = None
 
         # Snapshot the initial (or restored) messages as the first history segment
@@ -401,6 +390,56 @@ class AgentSession:
         save_history(self.messages, self.cache_dir, self.unique_id, self.history_index)
         save_summary(self.summary, self.cache_dir, self.unique_id)
 
+    def _detect_last_session(self):
+        """Resolve the most recent previous session dir, once.
+
+        Consults the .mini pointer recorded under --allowed-dir first (an
+        explicit record of the last session worked in), then falls back to the
+        timestamp heuristic over the cache dir. Returns the path, or None. The
+        constructor calls this a single time so the (relatively expensive)
+        pointer / directory scan does not run twice for the two independent
+        concerns -- --load-last-session vs. the interactive resume candidate.
+        """
+        return find_last_session_dir(
+            self.cache_dir,
+            allowed_dir=self.allowed_dir,
+            use_pointer=True,
+        )
+
+    def _register_tools(self, args):
+        """Wire up which tools the LLM may call, and register the opt-in ones.
+
+        Base tools depend on --enable-shell (the shell tool is withheld unless
+        shell is explicitly on). Then two opt-in features each add their own
+        sandbox-safe tools:
+
+          * Sub-agents (--enable-subagents): every registered sub-agent becomes
+            an extra tool. Its tools_dict entry has ``function=None`` so
+            _run_one_tool_call knows to *delegate* to a nested session rather
+            than call a real function. A child session never sets
+            enable_subagents, so sub-agents cannot recursively spawn sub-agents.
+          * Skills (--skills): the .mini directory (inside --allowed-dir) exposes
+            list/read/create/run_skill tools. They are sandbox-safe -- names are
+            validated as single path segments and resolved under .mini, so they
+            never accept an arbitrary path from the model and are usable even
+            without --enable-shell.
+        """
+        forbidden = None if args.enable_shell else tools.shell_tools
+        self.tools_dict = tools.util_get_tools_dict(forbidden_tools=forbidden)
+        self.llm_tools = tools.util_get_tools(forbidden_tools=forbidden)
+
+        self.enable_subagents = bool(getattr(args, "enable_subagents", False))
+        self.subagents_registry = subagents.get_registry() if self.enable_subagents else {}
+        for sa in self.subagents_registry.values():
+            self.llm_tools.append(sa.tool_schema())
+            self.tools_dict[sa.name] = {"function": None, "description": sa.description, "subagent": True}
+
+        self.enable_skills = bool(getattr(args, "enable_skills", False))
+        if self.enable_skills:
+            self.skills_tools_dict = skills.get_skills_tools_dict(self.allowed_dir)
+            self.llm_tools.extend(skills.get_skills_tools(self.allowed_dir))
+            self.tools_dict.update(self.skills_tools_dict)
+
     def _build_initial_messages(self):
         """Assemble the system prompt and optional Agent.md into the first turns."""
         if self.args.system_prompt:
@@ -466,6 +505,28 @@ class AgentSession:
                 self.summary.append({"turn": turn, "what": "assistant",
                                      "history_file": 0, "index": i})
 
+    def _restore_from(self, directory, messages=None):
+        """Seed usage, recorder and messages for a restore under this id.
+
+        Shared by the constructor (for an explicit ``--restore-session`` /
+        ``--load-last-session``) and the interactive resume prompt. The caller
+        resolves and loads ``directory`` itself, then hands the loaded
+        ``messages`` here so all seeding lives in one place.
+
+        ``usage.json`` is layered *on top* of the in-memory totals (so a restore
+        under a brand-new session id accumulates cleanly), the recorder is
+        flattened across the segment boundary so ``/history`` / ``/reset`` stay
+        consistent, and ``self.messages`` becomes the restored snapshot.
+        Best-effort: a missing directory / unreadable files leave the session
+        unchanged (a fresh, empty history).
+        """
+        restored = messages if messages is not None else (
+            load_history_from_dir(directory) if directory else None)
+        self._restore_usage_if_available(directory)
+        self._load_summary_if_restored(directory)
+        if restored:
+            self.messages = restored
+
     def _record_turn(self, what, messages, history_index=None):
         """Append one entry to the high-level recorder.
 
@@ -584,12 +645,84 @@ class AgentSession:
                 f"Sub-agents enabled ({len(self.subagents_registry)} available: "
                 f"{', '.join(self.subagents_registry)}).", "info")
 
+    def _offer_resume_last_session(self):
+        """Offer to continue the most recent previous session, if one exists.
+
+        Only reached when the user did *not* already ask to resume a session
+        (``--load-last-session`` / ``--restore-session``), which resolve their
+        own before this and leave ``last_session_candidate`` unset. When a
+        candidate exists the user chooses between three outcomes:
+
+          * **Resume** -- splice the previous session's history into this one
+            (still under the brand-new id) and continue it, under a new id.
+          * **New** -- leave the conversation empty and start a fresh session.
+          * **Exit** -- stop here before any pointer is written or loop enters.
+
+        The choice is recorded by setting/clearing ``self.last_session_candidate``:
+        ``resume`` keeps it pointing at the previous session's directory (the
+        caller in :meth:`run` performs the restore); ``new`` clears it (nothing
+        to restore). Returns True when the user chose to exit so the caller
+        returns before writing any pointer or entering the loop.
+        """
+        if not self.last_session_candidate:
+            return False
+        choice = self._resume_choice()
+        if choice == "resume":
+            return False  # keep the candidate: run() restores it below.
+        # "new" -> clear the candidate (nothing to restore); "exit" -> clear
+        # and tell the caller to stop before writing a pointer / entering the
+        # loop.
+        self.last_session_candidate = None
+        return choice == "exit"
+
+    def _resume_choice(self):
+        """Prompt for the resume choice and return its label.
+
+        Returns one of ``"resume"``, ``"new"`` or ``"exit"``. The prompt
+        degrades cleanly on a non-TTY / piped console: an EOF / Ctrl-C (``read_line``
+        returns None) is treated as ``"exit"`` so the loop never spins on unread input.
+        """
+        self.console.emit(
+            self.console.style(
+                "A previous session was found. What would you like to do?", dim=True,
+                fg="cyan"))
+        self.console.emit("  1) Resume the previous session (continue where you left off)")
+        self.console.emit("  2) Start a new session (empty history)")
+        self.console.emit("  3) Exit (start nothing)")
+        while True:
+            answer = self.console.read_line(
+                self.console.style("Resume previous session? Type 1, 2, or 3: ", fg="cyan"))
+            if answer is None:
+                # EOF / Ctrl-C at the offer -> graceful exit, no session written.
+                return "exit"
+            choice = answer.strip().lower()
+            if choice in ("1", "resume"):
+                return "resume"
+            if choice in ("2", "new"):
+                return "new"
+            if choice in ("3", "exit"):
+                return "exit"
+            self.console.note("Please choose 1, 2, or 3.", "warn")
+
     def run(self, initial_prompt=None):
         """Drive the agent loop until the user quits."""
         self.print_announcements()
         print_welcome(self.allowed_dir, self.server_url, self.args,
                       self.unique_id, self.cache_dir, self.model)
 
+        # A previous session exists but the user did not explicitly ask to
+        # resume it. Offer them a choice; on "exit" we return here before
+        # writing any pointer or entering the loop, and we splice the
+        # restored history into this session if they pick "resume".
+        if self._offer_resume_last_session():
+            return
+        if self.last_session_candidate is not None:
+            restored_dir = self.last_session_candidate
+            self.last_session_candidate = None
+            restored = load_history_from_dir(restored_dir)
+            self._restore_from(restored_dir, restored)
+            self.loaded_last_session_dir = restored_dir
+
         # Announce the session's unique id as an assistant-styled message so the
         # user can see / copy the id this conversation is being saved under.
         self._print_session_id()
@@ -660,7 +793,8 @@ class AgentSession:
                     self._persist()
                     if not should_continue:
                         break
-                    self.console.note("Continuing with LLM calls until no more tool calls.", "info")
+                    self.console.note(
+                        "Continuing with LLM calls until no more tool calls.", "info")
             except _Abort:
                 # Ctrl-C during a permission prompt already shut the session
                 # down; just unwind the loop quietly.
@@ -855,7 +989,11 @@ class AgentSession:
     # -- interactive input -------------------------------------------------
 
     def _read_user_line(self):
-        """Read one turn from the user. Returns the text to send, or None to quit."""
+        """Read one turn from the user. Returns the text to send, or None to quit.
+
+        An empty (blank) line is not a real instruction, so it is ignored and the
+        user is asked again rather than sending an empty turn to the model.
+        """
         self.console.short_divider()
         user_input = self.console.read_line(style_line_prompt("You:"))
         if user_input is None:  # EOF / Ctrl-C at the prompt
@@ -871,6 +1009,12 @@ class AgentSession:
             # Nothing to send to the model; ask again.
             return self._read_user_line()
 
+        # A blank line carries no instruction: say so and re-prompt instead of
+        # appending an empty user turn and spending an LLM call on it.
+        if not user_input.strip():
+            self.console.note("No input. (Type /help for commands, /quit to exit.)", "warn")
+            return self._read_user_line()
+
         return user_input
 
     def _handle_command(self, user_input):

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/mini_code_cli/runner.py

@@ -21,10 +21,10 @@ class _TimedOut(Exception):
 def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_TOOL_TIMEOUT):
     """Call ``func(**tool_params)``, aborting after ``timeout_seconds``.
 
-    On timeout, returns a friendly ``Error:`` string (so the agent sees the
-    failure as a tool result rather than crashing). Any *other* exception the
-    tool raises is allowed to propagate -- the tool authors are responsible for
-    returning ``Error`` strings, and surfacing genuine bugs here is intentional.
+    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.
     """
     def _handler(signum, frame):
         raise _TimedOut()
@@ -33,8 +33,9 @@ def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_
         previous = signal.signal(signal.SIGALRM, _handler)
     except (ValueError, OSError):
         # 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.
-        return func(**tool_params)
+        # 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)
 
     signal.alarm(int(timeout_seconds) if timeout_seconds else 0)
     try:
@@ -42,6 +43,22 @@ def call_function_with_timeout(func, tool_params, name, timeout_seconds=DEFAULT_
     except _TimedOut:
         ui.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")
+        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):
+    """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).
+    """
+    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")
+        return f"Error: tool {name} raised an error: {e}"

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/mini_code_cli/utils.py

@@ -2,6 +2,27 @@ import requests
 import json
 
 
+def _coerce_usage_int(value):
+    """Best-effort: coerce a raw usage field to a non-negative int.
+
+    Servers sometimes report ``null``/``None`` or oddly-shaped numbers for token
+    usage. This normalises those to 0 so a downstream
+    ``accumulate_usage``/``usage["tool_calls"]`` assignment can never raise.
+    """
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _usage_or_zero(value):
+    """Return ``int(value)`` when that is safe, else 0 (for summing fields)."""
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return 0
+
+
 def determine_vllm_model(server_url, api_key=None, timeout=120):
     """In case of a vLLm local server, read the first served model id from
     ``{server_url}/v1/models`` so the caller does not have to name the model.
@@ -93,9 +114,12 @@ def call_openai_server(messages, max_tokens=2048, temperature=0.0, model="defaul
 
         # Token usage, when the server reports it (many local servers do not).
         usage = response.json().get("usage", {}) or {}
-        prompt_tokens = usage.get("prompt_tokens", 0)
-        completion_tokens = usage.get("completion_tokens", 0)
-        total_tokens = usage.get("total_tokens", prompt_tokens + completion_tokens)
+        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(
+            usage.get("total_tokens",
+                      _usage_or_zero(usage.get("prompt_tokens"))
+                      + _usage_or_zero(usage.get("completion_tokens"))))
 
         return content, tool_calls, {
             "prompt_tokens": prompt_tokens,
@@ -126,3 +150,6 @@ def call_openai_server(messages, max_tokens=2048, temperature=0.0, model="defaul
     except (json.JSONDecodeError, KeyError, IndexError) as e:
         print(f"Error processing response: {e}")
         return 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}")
+        return None, None, None

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/mini_code_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.1.0.2
+Version: 0.1.0.3
 Summary: Mini Coding Agent. Allows you to easily experiment with a small coding agent.
 Author-email: Nikolai Rozanov <nikolai.rozanov@gmail.com>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -721,6 +721,7 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - ask-permission: asks user permission before every tool call. For shell commands, commands in the ALLOW tier skip the prompt, DENY is blocked, and ASK always prompts.
 - system-prompt: you can override the default prompt by using a string. (Note: Agent.md is always appended after the system prompt.)
 - load-last-session: instead of starting a fresh conversation, automatically continue your most recently active session from the default cache dir. It resumes under a brand-new session id, so the original session is never overwritten. An explicit `--restore-session` (a specific path) takes precedence if both are given. The "most recent" session is resolved in two steps: at the end of every interactive session, its path is recorded in a tiny `.mini/last_session.json` pointer inside the `--allowed-dir`, and `--load-last-session` consults that pointer first; only if there is no pointer (e.g. a fresh allowed dir, or the `--skills` feature disabled) does it fall back to the timestamp heuristic (the session whose history was modified most recently). The `.mini` pointer is the same directory the `--skills` feature uses, but it is a single dedicated file, so the two never clash.
+- **Interactive session offer:** if a previous session exists in the cache dir but you did **not** explicitly ask to resume one (i.e. neither `--load-last-session` nor `--restore-session` was passed), the prompt asks what you'd like to do before the conversation starts: 1) **Resume** the previous session (splice its history in under a brand-new session id and continue it), 2) **Start a new** session (empty history), or 3) **Exit** (start nothing). Ctrl-C / EOF at the offer is treated as a graceful exit. This is distinct from `--load-last-session`, which silently resumes the most recent session without asking.
 - plan: `--plan` enables **plan mode**. The agent now keeps two tracking files in the session directory: `CURRENT_GOAL.md` (the user's latest instruction) and `CURRENT_PLAN.md` (its own step-by-step plan, which it must update as it works and mark finished once the goal is done). The system message gets an extra instruction telling the agent to do this. Plan mode also changes how history compaction works: after the history is compacted to a summary, the current `CURRENT_PLAN.md` and the user's last instruction (`CURRENT_GOAL.md`) are re-injected into the messages so the agent keeps working against the same goal. When the session ends, the active goal is marked finished in `CURRENT_PLAN.md`.
 
 ### Available tools

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/mini_code_cli.egg-info/SOURCES.txt

@@ -28,6 +28,8 @@ tests/test_agent_loop.py
 tests/test_integration.py
 tests/test_last_session_pointer.py
 tests/test_plan.py
+tests/test_resume_offer.py
+tests/test_robustness.py
 tests/test_sandboxing.py
 tests/test_shell_safety.py
 tests/test_skills.py

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mini-code-cli"
 # version = { file = "mini_code_cli/__init__.py", attr = "__version__" }
-version = "0.1.0.2"
+version = "0.1.0.3"
 description = "Mini Coding Agent. Allows you to easily experiment with a small coding agent."
 readme = "README.md"
 requires-python = ">=3.10"

{mini_code_cli-0.1.0.2 → mini_code_cli-0.1.0.3}/tests/test_integration.py

@@ -78,8 +78,15 @@ class TestAgentLoopIntegration(unittest.TestCase):
             return f.read()
 
     def test_plan_mode_end_to_end(self):
-        args = _make_args(cache_dir=self.tmp.name, allowed_dir=".", plan=True,
-                          prompt="Solve the puzzle")
+        # allowed_dir points at the throw-away temp dir (not "."): otherwise
+        # run() would consult the *real* .mini/last_session.json pointer in the
+        # repo, offer to resume it, and consume the scripted /quit. The plan
+        # files themselves live in the cache dir (session_dir), independent of
+        # allowed_dir, and the plan-file sandbox exemption keys off plan-mode +
+        # path-in-session-dir, so the temp allowed_dir changes nothing about the
+        # assertion.
+        args = _make_args(cache_dir=self.tmp.name, allowed_dir=self.tmp.name,
+                          plan=True, prompt="Solve the puzzle")
         sess = agent_loop.AgentSession(args, console=self.console)
 
         # /quit ends the interactive loop after the preset prompt has run.

mini_code_cli-0.1.0.3/tests/test_resume_offer.py

@@ -0,0 +1,178 @@
+"""Tests for the interactive "resume last session" offer.
+
+When a previous session exists (a recorded ``.mini`` pointer, or the most
+recent session in the cache dir) but the user did *not* explicitly ask to
+resume one, the agent offers a choice before starting the loop:
+
+  1) Resume  -- splice the previous session's history into the current one.
+  2) New     -- start a fresh (empty) session.
+  3) Exit    -- stop before anything is written or the loop enters.
+
+The tests drive the mocked console through a couple of turns and verify each
+choice, plus that a session with no previous session never shows the offer.
+"""
+import os
+import sys
+import io
+import json
+import types
+import tempfile
+import unittest
+import unittest.mock as mock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import mini_code_cli.agent_loop as agent_loop
+from mini_code_cli.agent_loop import AgentSession
+from mini_code_cli import ui, persistence
+
+
+def _make_args(**kw):
+    a = types.SimpleNamespace(
+        url="http://x", model="m", allowed_dir=".", cache_dir=None, api_key=None,
+        system_prompt=None, agent_md=None, prompt=None, enable_shell=False,
+        ask_permission=False, auto_mode=False, restore_session=None, llm_timeout=30,
+        tool_timeout=30, load_last_session=False, verbose=False, max_tokens=None,
+        temperature=1.0, plan=False, enable_subagents=False, enable_skills=False,
+        sudo=False,
+    )
+    a.__dict__.update(kw)
+    return a
+
+
+class TestResumeOffer(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.allowed = self.tmp.name
+        self.cache = os.path.join(self.tmp.name, "cache")
+        os.makedirs(self.cache)
+        self.buf = io.StringIO()
+        self.console = ui.Console(stream=self.buf, color=False, unicode=False)
+
+    def _prev_session(self, content):
+        """Create a previous session with the given messages, and mark it the
+        last session via the .mini pointer."""
+        d = os.path.join(self.cache, "prev")
+        os.makedirs(d)
+        with open(os.path.join(d, "history.json"), "w") as f:
+            json.dump(content, f)
+        persistence.save_last_session_pointer(self.allowed, d)
+        return d
+
+    def _fake_empty_llm(self):
+        def fake(messages, **kw):
+            # No answer, no tool calls -> the manual-mode loop just re-prompts.
+            return "", [], {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+        return fake
+
+    def _run_until_quit(self, args, answers):
+        """Build a session and run() it, feeding `answers` to the console's
+        read_line (resume choice, then /quit), with the network calls mocked.
+
+        Extra ``/quit`` lines are appended so the mock is never exhausted: the
+        resume offer consumes the first answer, and the loop keeps asking until
+        it sees ``/quit``.
+        """
+        session = AgentSession(args, console=self.console)
+        answers = list(answers) + ["/quit"] * 5
+        with mock.patch.object(agent_loop.utils, "call_openai_server",
+                               self._fake_empty_llm()), \
+             mock.patch.object(agent_loop.utils, "determine_vllm_model", return_value=None), \
+             mock.patch.object(self.console, "read_line", side_effect=iter(answers)):
+            session.run()
+        return session
+
+    def test_no_previous_session_does_not_offer(self):
+        # No previous session at all -> the offer is a no-op and run() just
+        # enters the loop (which we end via a /quit read_line).
+        args = _make_args(cache_dir=self.cache, allowed_dir=self.allowed)
+        session = self._run_until_quit(args, ["/quit"])
+        self.assertNotIn("A previous session was found", self.buf.getvalue())
+        # No restore happened.
+        self.assertIsNone(session.loaded_last_session_dir)
+
+    def test_offer_prompt_appears_for_previous_session(self):
+        self._prev_session([{"role": "system", "content": "sys"},
+                            {"role": "user", "content": "remember 42"}])
+        args = _make_args(cache_dir=self.cache, allowed_dir=self.allowed)
+        session = self._run_until_quit(args, ["1", "2"])
+        out = self.buf.getvalue()
+        self.assertIn("A previous session was found", out)
+        self.assertIn("Resume", out)
+
+    def test_resume_choice_splices_history_and_announces(self):
+        prev = self._prev_session([{"role": "system", "content": "sys"},
+                                   {"role": "user", "content": "remember 42"}])
+        args = _make_args(cache_dir=self.cache, allowed_dir=self.allowed)
+        session = self._run_until_quit(args, ["1"])
+        # The previous conversation was spliced into the restored session.
+        joined = "\n".join(m.get("content", "") for m in session.messages)
+        self.assertIn("remember 42", joined)
+        # run() advertised that it was continuing the previous session.
+        self.assertIn("continuing", self.buf.getvalue())
+        # The candidate was consumed (no leftover restore pending).
+        self.assertIsNone(session.last_session_candidate)
+        self.assertEqual(session.loaded_last_session_dir, os.path.abspath(prev))
+
+    def test_new_choice_starts_fresh(self):
+        self._prev_session([{"role": "system", "content": "sys"},
+                            {"role": "user", "content": "remember 42"}])
+        args = _make_args(cache_dir=self.cache, allowed_dir=self.allowed)
+        session = self._run_until_quit(args, ["2"])
+        # Only the freshly-built system message remains; the old history is not
+        # spliced in.
+        contents = [m.get("content", "") for m in session.messages]
+        self.assertNotIn("remember 42", contents)
+        self.assertIsNone(session.loaded_last_session_dir)
+
+    def test_exit_choice_stops_before_loop(self):
+        self._prev_session([{"role": "system", "content": "sys"},
+                            {"role": "user", "content": "remember 42"}])
+        args = _make_args(cache_dir=self.cache, allowed_dir=self.allowed)
+        # The LLM must never be called on the exit path. Track whether it is.
+        state = {"called": False}
+
+        def boom(*a, **k):
+            state["called"] = True
+            return "", [], {}
+
+        session = AgentSession(args, console=self.console)
+        with mock.patch.object(agent_loop.utils, "call_openai_server", boom), \
+             mock.patch.object(agent_loop.utils, "determine_vllm_model", return_value=None), \
+             mock.patch.object(self.console, "read_line", side_effect=iter(["3"])):
+            session.run()  # exits cleanly via the offer
+        # The LLM was never reached; the candidate was consumed.
+        self.assertFalse(state["called"])
+        self.assertIsNone(session.last_session_candidate)
+
+    def test_bad_input_reprompts_then_new(self):
+        self._prev_session([{"role": "system", "content": "sys"},
+                            {"role": "user", "content": "remember 42"}])
+        args = _make_args(cache_dir=self.cache, allowed_dir=self.allowed)
+        session = self._run_until_quit(args, ["banana", "2"])
+        out = self.buf.getvalue()
+        self.assertIn("Please choose 1, 2, or 3", out)
+
+    def test_exit_via_eof(self):
+        # EOF / Ctrl-C at the offer (read_line returns None) is a graceful exit.
+        self._prev_session([{"role": "system", "content": "sys"},
+                            {"role": "user", "content": "remember 42"}])
+        args = _make_args(cache_dir=self.cache, allowed_dir=self.allowed)
+        state = {"called": False}
+
+        def boom(*a, **k):
+            state["called"] = True
+            return "", [], {}
+
+        session = AgentSession(args, console=self.console)
+        with mock.patch.object(agent_loop.utils, "call_openai_server", boom), \
+             mock.patch.object(agent_loop.utils, "determine_vllm_model", return_value=None), \
+             mock.patch.object(self.console, "read_line", return_value=None):
+            session.run()
+        self.assertFalse(state["called"])
+        self.assertIsNone(session.last_session_candidate)
+
+
+if __name__ == "__main__":
+    unittest.main()

mini_code_cli-0.1.0.3/tests/test_robustness.py

@@ -0,0 +1,179 @@
+"""Regression tests for the agent-loop hardening:
+
+  * runner.call_function_with_timeout shields the loop from a tool that raises
+    (returns a friendly Error string instead of propagating), and still returns
+    a distinct message on timeout.
+  * utils.call_openai_server degrades to (None, None, None) on ANY failure
+    (including malformed usage payloads) instead of raising.
+  * an empty / blank user response just re-prompts: it does not append a user
+    turn and does not call the LLM.
+  * an LLM that returns no response and no tool calls leaves the loop intact
+    (records a warning, re-prompts) rather than crashing.
+"""
+import io
+import os
+import sys
+import types
+import time
+import tempfile
+import unittest
+import unittest.mock as mock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import mini_code_cli.agent_loop as agent_loop
+from mini_code_cli import runner, utils, ui
+
+
+# ---------------------------------------------------------------------------
+# runner: a tool that raises must not crash the loop
+# ---------------------------------------------------------------------------
+
+class TestToolFailureRobustness(unittest.TestCase):
+    def test_tool_that_raises_returns_error_string(self):
+        def boom(**kw):
+            raise RuntimeError("explode")
+        with mock.patch.object(ui.console, "note") as noted:
+            result = runner.call_function_with_timeout(boom, {}, "read_file", timeout_seconds=30)
+        self.assertIsInstance(result, str)
+        self.assertIn("Error", result)
+        self.assertIn("read_file", result)
+        self.assertTrue(any("raised an error" in str(c.args[0]) for c in noted.call_args_list))
+
+    def test_timeout_still_reports_distinctly(self):
+        def slow(**kw):
+            time.sleep(3)
+            return "never"
+        result = runner.call_function_with_timeout(slow, {}, "read_file", timeout_seconds=1)
+        self.assertIsInstance(result, str)
+        self.assertIn("timed out", result)
+
+    def test_normal_call_still_returns_value(self):
+        def ok(**kw):
+            return "fine"
+        self.assertEqual(runner.call_function_with_timeout(ok, {}, "read_file"), "fine")
+
+
+# ---------------------------------------------------------------------------
+# utils: call_openai_server never raises
+# ---------------------------------------------------------------------------
+
+class TestLLMFailureRobustness(unittest.TestCase):
+    def test_malformed_usage_is_coerced_not_raised(self):
+        # A server that reports null token fields must not crash the caller's
+        # accumulation logic. The success path coerces those to ints.
+        self.assertEqual(utils._coerce_usage_int(None), 0)
+        self.assertEqual(utils._coerce_usage_int("not-a-number"), 0)
+        self.assertEqual(utils._coerce_usage_int(5), 5)
+
+    def test_connection_error_degrades_to_none(self):
+        with mock.patch("mini_code_cli.utils.requests.post",
+                        side_effect=Exception("boom")):
+            content, tool_calls, usage = utils.call_openai_server(
+                [{"role": "user", "content": "hi"}], server_url="http://x")
+        self.assertIsNone(content)
+        self.assertIsNone(tool_calls)
+        self.assertIsNone(usage)
+
+
+# ---------------------------------------------------------------------------
+# agent loop: empty response + no-response handling
+# ---------------------------------------------------------------------------
+
+def _make_args(**kw):
+    a = types.SimpleNamespace(
+        url="http://x", model="m", allowed_dir=".", cache_dir=None, api_key=None,
+        system_prompt=None, agent_md=None, prompt=None, enable_shell=False,
+        ask_permission=False, auto_mode=False, restore_session=None, llm_timeout=30,
+        tool_timeout=30, load_last_session=False, verbose=False, max_tokens=None,
+        temperature=1.0, plan=False, enable_subagents=False, enable_skills=False, sudo=False,
+    )
+    a.__dict__.update(kw)
+    return a
+
+
+class _EmptyUserTurnBase(unittest.TestCase):
+    """Run a session with a scripted console and a mocked LLM."""
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.buf = io.StringIO()
+        self.console = ui.Console(stream=self.buf, color=False, unicode=False)
+        self.llm_calls = 0
+
+    def _counting_llm(self, answer="hi", tool_calls=None):
+        def fake(messages, **kw):
+            self.llm_calls += 1
+            return answer, tool_calls or [], {
+                "prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2}
+        return fake
+
+    def _session(self, **kw):
+        # Use a fresh temp dir as --allowed-dir so there is no .mini last-session
+        # pointer (which would otherwise trigger run()'s interactive resume
+        # offer and consume the first scripted read_line).
+        with mock.patch.object(agent_loop.utils, "determine_vllm_model", return_value=None):
+            return agent_loop.AgentSession(
+                _make_args(cache_dir=self.tmp.name, allowed_dir=self.tmp.name),
+                console=self.console)
+
+
+class TestEmptyUserResponse(_EmptyUserTurnBase):
+    def test_blank_response_reprompts_without_calling_llm(self):
+        # A blank line (and one with only spaces) must be ignored and re-prompted,
+        # never sent to the model. /quit then ends the loop.
+        sess = self._session()
+        with mock.patch.object(agent_loop.utils, "call_openai_server", self._counting_llm()), \
+             mock.patch.object(self.console, "read_line",
+                               side_effect=["", "   ", "/quit"]):
+            sess.run()
+        # No user turn was ever worth an LLM call.
+        self.assertEqual(self.llm_calls, 0)
+        # And no empty user message was appended.
+        self.assertFalse(any(m.get("role") == "user" and not m.get("content")
+                             for m in sess.messages))
+
+    def test_real_input_still_sent_to_llm(self):
+        # Sanity check: a non-empty line does reach the model.
+        sess = self._session()
+        with mock.patch.object(agent_loop.utils, "call_openai_server", self._counting_llm()), \
+             mock.patch.object(self.console, "read_line", side_effect=["hello", "/quit"]):
+            sess.run()
+        self.assertEqual(self.llm_calls, 1)
+        self.assertTrue(any(m.get("role") == "user" and m.get("content") == "hello"
+                            for m in sess.messages))
+
+
+class TestNoResponseFromLLM(_EmptyUserTurnBase):
+    def test_empty_response_and_no_tool_calls_keeps_loop_alive(self):
+        # The LLM returns nothing (no text, no tool calls): the loop must record
+        # a warning and keep going (re-prompt), not crash.
+        sess = self._session()
+
+        def empty(messages, **kw):
+            self.llm_calls += 1
+            return "", [], {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+
+        with mock.patch.object(agent_loop.utils, "call_openai_server", empty), \
+             mock.patch.object(self.console, "read_line", side_effect=["go", "/quit"]):
+            sess.run()  # must not raise
+        # The session persisted and survived.
+        self.assertTrue(os.path.isdir(os.path.join(self.tmp.name, sess.unique_id)))
+
+    def test_llm_returns_none_everything_keeps_loop_alive(self):
+        # A hard failure returns (None, None, None); the loop survives and can
+        # still be driven to a clean /quit.
+        sess = self._session()
+
+        def boom(messages, **kw):
+            return None, None, None
+
+        with mock.patch.object(agent_loop.utils, "call_openai_server", boom), \
+             mock.patch.object(self.console, "read_line", side_effect=["go", "/quit"]):
+            sess.run()  # must not raise
+        self.assertTrue(os.path.isdir(os.path.join(self.tmp.name, sess.unique_id)))
+
+
+if __name__ == "__main__":
+    unittest.main()