mini-code-cli 0.1.0.2__py3-none-any.whl → 0.1.0.3__py3-none-any.whl

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/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/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.dist-info → mini_code_cli-0.1.0.3.dist-info}/METADATA

@@ -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.dist-info → mini_code_cli-0.1.0.3.dist-info}/RECORD

@@ -1,23 +1,23 @@
 mini_code_cli/__init__.py,sha256=iNgHmKSHOuH99obGjnUMoS2JP4Gw4AOrIfu68EYaZQM,77
-mini_code_cli/agent_loop.py,sha256=mU0IW3zekmgnnT7kXcjKL0I4F0dkBMpCpSBRo6JSkL0,59433
+mini_code_cli/agent_loop.py,sha256=odSW_cHC-w0JRadt1IWvbyBprBfKEFj7aPHihY05cv4,66869
 mini_code_cli/config.py,sha256=AvzDZAKynQbuj5lcTtL-DcUwhyLa99QmNrLK6fYpdOA,814
 mini_code_cli/permissions.py,sha256=uQpQlUtQyVICpjUqdh9QQ_mgl51hZrGLHJzQR9vG124,2017
 mini_code_cli/persistence.py,sha256=BxUL4x8rha8ic_1vkWJu1cAFTuYyhK85ZdFVD9aFRYQ,14055
 mini_code_cli/plan.py,sha256=M5WZQuiN8F_K7zyWIrU_5R9L8dcN9k8iYouXzfL_KOs,6985
 mini_code_cli/prompts.py,sha256=X05Krwf9X46WinbHzHj8WYq4RTnO56KZpMiRYS2CGLw,5452
-mini_code_cli/runner.py,sha256=oYUAzbQOrkakuR2uT1OnIrruh_XJYWEDzKpM09T4Zp0,1927
+mini_code_cli/runner.py,sha256=yq7qlQgKkWbMaSahR5G33YMulI5rEGkdnW9B80InlDs,2739
 mini_code_cli/sandbox.py,sha256=t7xS_AIpE8fbo5kj9zbUFbfEaAnq6iUE7plQcn6-uAk,2128
 mini_code_cli/shell_safety_utils.py,sha256=5E126vGnG7iIuTZe_R5JrxB_zxZpMKGe_pilz_Z2r4w,5551
 mini_code_cli/skills.py,sha256=baaz0RkPQ-OgWWwH5sHsKBmJdR430yT4HK3VLX0_88Y,13704
 mini_code_cli/tools.py,sha256=bW1zYyIj6OFp5TIcg5DCwheN-4xI1LQmDOQaHIfRV7M,10998
 mini_code_cli/ui.py,sha256=064mcoxrKSaC0eWTWqeM6urPy5MD7hE5Tr-z2jjnqO4,32613
-mini_code_cli/utils.py,sha256=ffUAIisO8_h7VvlwAOLhdoNSAIdssGdtQHXm-i8bcLE,4620
+mini_code_cli/utils.py,sha256=WBiOcGICZTQjmMa_EewHmlGp5aMncjJfReJxjgB7TU0,5585
 mini_code_cli/subagents/__init__.py,sha256=3fgcwY0pNq5iW29OxLPtSA3H5IKXhl2LUhwbBjLUDuU,1884
 mini_code_cli/subagents/base.py,sha256=bhZEENoTVjebfqaEKS7uPWeU0SwQWFN3BD40EtziPbg,12660
 mini_code_cli/subagents/builtin.py,sha256=ENzuooXIylzfZZ8uYkZmdxgCrCQ4pdbfrOONkBdGSPg,7598
-mini_code_cli-0.1.0.2.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-mini_code_cli-0.1.0.2.dist-info/METADATA,sha256=WRYRunHU0Swx0qpojq_JRynzzgjN8unAYLQ6E1Ppcf0,53278
-mini_code_cli-0.1.0.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-mini_code_cli-0.1.0.2.dist-info/entry_points.txt,sha256=MwDp5UbXpI7wodSmOSYL8_nKutnBiyp96ZDDtaX7x14,60
-mini_code_cli-0.1.0.2.dist-info/top_level.txt,sha256=3Hb6PpNkJYXvzDKXuuFJRvzCdsTRh0TuRWz-ScJ6qV0,14
-mini_code_cli-0.1.0.2.dist-info/RECORD,,
+mini_code_cli-0.1.0.3.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+mini_code_cli-0.1.0.3.dist-info/METADATA,sha256=qtDZ3rLGdRVO-fIAI_OmPCogKV5zJ_2HSj5Dc-h1XoE,53895
+mini_code_cli-0.1.0.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mini_code_cli-0.1.0.3.dist-info/entry_points.txt,sha256=MwDp5UbXpI7wodSmOSYL8_nKutnBiyp96ZDDtaX7x14,60
+mini_code_cli-0.1.0.3.dist-info/top_level.txt,sha256=3Hb6PpNkJYXvzDKXuuFJRvzCdsTRh0TuRWz-ScJ6qV0,14
+mini_code_cli-0.1.0.3.dist-info/RECORD,,