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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.1.0.0
+Version: 0.1.0.2
 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
@@ -720,7 +720,7 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - allowed-dir: this specifies which dirs the agent can read and write from, that does not stop the shell comands! (though dangerous shell commands are still blocked by the classifier above).
 - 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 (the one whose history was last modified) 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.
+- 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.
 - 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
@@ -871,4 +871,19 @@ vllm serve ornith-ai/Ornith-1.5-397B-FP8 \
     --trust-remote-code
 ```
 
+## Citation
+
+If you use `mini-code-cli` in your research or writing, please cite it using the BibTeX entry below:
+
+```bibtex
+@misc{mini-code-cli,
+  author       = {Rozanov, Nikolai},
+  title        = {mini-code-cli: A minimal, dependency-light coding agent},
+  year         = {2026},
+  version      = {0.1.0.0},
+  howpublished = {\url{https://github.com/ai-nikolai/mini-code-cli}},
+  note         = {A no-bloat, dependency-free agent CLI for experimenting.}
+}
+```
+
 ## (C) Nikolai Rozanov, 2026 - Present

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

@@ -46,7 +46,7 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - allowed-dir: this specifies which dirs the agent can read and write from, that does not stop the shell comands! (though dangerous shell commands are still blocked by the classifier above).
 - 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 (the one whose history was last modified) 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.
+- 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.
 - 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
@@ -197,4 +197,19 @@ vllm serve ornith-ai/Ornith-1.5-397B-FP8 \
     --trust-remote-code
 ```
 
+## Citation
+
+If you use `mini-code-cli` in your research or writing, please cite it using the BibTeX entry below:
+
+```bibtex
+@misc{mini-code-cli,
+  author       = {Rozanov, Nikolai},
+  title        = {mini-code-cli: A minimal, dependency-light coding agent},
+  year         = {2026},
+  version      = {0.1.0.0},
+  howpublished = {\url{https://github.com/ai-nikolai/mini-code-cli}},
+  note         = {A no-bloat, dependency-free agent CLI for experimenting.}
+}
+```
+
 ## (C) Nikolai Rozanov, 2026 - Present

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

@@ -52,6 +52,7 @@ from .persistence import (
     load_summary_from_dir,
     load_usage_from_dir,
     find_last_session_dir,
+    save_last_session_pointer,
     accumulate_usage,
     generate_unique_id,
     _restore_dir,
@@ -368,7 +369,15 @@ class AgentSession:
         restore_session = getattr(self.args, "restore_session", None)
         self.loaded_last_session_dir = None
         if getattr(self.args, "load_last_session", False) and not restore_session:
-            detected = find_last_session_dir(self.cache_dir)
+            # 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
@@ -581,6 +590,17 @@ class AgentSession:
         print_welcome(self.allowed_dir, self.server_url, self.args,
                       self.unique_id, self.cache_dir, self.model)
 
+        # 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()
+
+        # Record this session as the "latest" so a future --load-last-session can
+        # resume it without scanning the cache dir. This lives in the top-level
+        # loop's own directory (cache_dir/unique_id), and only the interactive
+        # run() writes it -- a sub-agent child drives via _drive_auto and would
+        # otherwise overwrite the pointer with its own buried path.
+        self._save_last_session_pointer()
+
         # Report the outcome of --load-last-session up front, so the user sees
         # whether we resumed an earlier conversation (under a brand-new id) or
         # started fresh because no previous session was found.
@@ -612,6 +632,7 @@ class AgentSession:
                 # 1) Get the user's turn: the one-shot preset, or a fresh line.
                 if pending is not None:
                     self.console.rule(title="Preset prompt", char="=", fg="cyan")
+                    self.console.short_divider()
                     self.console.turn("You", pending, accent="cyan")
                     user_input = pending
                     pending = None
@@ -649,6 +670,26 @@ class AgentSession:
                 # Ctrl-C mid-loop just saves and re-prompts rather than crashing.
                 self._persist()
 
+    def _print_session_id(self):
+        """Print the session's unique id as a minimal "Assistant" turn.
+
+        Instead of a banner/header the id is rendered as an assistant-styled
+        (green) turn carrying *only* the id in brackets, so the user can see /
+        copy the id this conversation is being saved under without the noise of
+        the extra "saved under" line.
+        """
+        self.console.turn("Assistant", f"[{self.unique_id}]", accent="green")
+
+    def _save_last_session_pointer(self):
+        """Record this session's directory in --allowed-dir/.mini.
+
+        Writes the .mini pointer that a later --load-last-session consults first
+        (see save_last_session_pointer). Best-effort: never raises, so a pointer
+        hiccup can never break the interactive session.
+        """
+        save_last_session_pointer(self.allowed_dir,
+                                  os.path.join(self.cache_dir, self.unique_id))
+
     # -- autonomous drive (used by sub-agents) ------------------------------
 
     def _drive_auto(self, initial_task, max_steps=None):
@@ -815,6 +856,7 @@ class AgentSession:
 
     def _read_user_line(self):
         """Read one turn from the user. Returns the text to send, or None to quit."""
+        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
             self.console.note("Thank you. Goodbye! Saving history...", "info")
@@ -864,7 +906,7 @@ class AgentSession:
                        self.unique_id, self.cache_dir, self.model)
             return True
         if cmd in self.CLEAR_COMMANDS:
-            self.console.clear_screen()
+            self._clear_and_show_last()
             return True
         self.console.note(f"Unknown command {stripped!r}. Try /help.", "warn")
         return True
@@ -892,12 +934,42 @@ class AgentSession:
                 return
         self._reset_history(target["turn"], target)
 
+    def _clear_and_show_last(self):
+        """Handle /clear: wipe the screen and re-print the last turn.
+
+        The conversation itself is unchanged; we just redraw the most recent
+        exchange so the user re-orients after clearing the view. If there is no
+        assistant reply yet, the last user turn is shown instead.
+        """
+        self.console.clear_screen()
+        last_role = last_text = None
+        for m in reversed(self.messages):
+            role = m.get("role")
+            content = m.get("content")
+            if role == "assistant" and not m.get("tool_calls") and content:
+                last_role, last_text = "Assistant", content
+                break
+            if role == "user" and content:
+                last_role, last_text = "You", content
+                break
+        if last_role is not None:
+            self.console.divider()
+            accent = "green" if last_role == "Assistant" else "cyan"
+            self.console.turn(last_role, last_text, accent=accent)
+
     # -- tool execution ----------------------------------------------------
 
     def _run_tool_calls(self, tool_calls):
         _make_tool_call_note(self.console, len(tool_calls))
-        for call in tool_calls:
-            self._run_one_tool_call(call)
+        # Show a "… calling tool" spinner (in-place, non-scrolling) while the
+        # tool(s) execute, mirroring the thinking spinner that covers the LLM
+        # call. Always stopped (finally) so it can never leak into the next turn.
+        self.console.start_tool_call()
+        try:
+            for call in tool_calls:
+                self._run_one_tool_call(call)
+        finally:
+            self.console.stop_tool_call()
 
     def _run_one_tool_call(self, call):
         call_id = call.get("id", "")

{mini_code_cli-0.1.0.0 → mini_code_cli-0.1.0.2}/mini_code_cli/persistence.py

@@ -24,6 +24,7 @@ raising.
 import json
 import os
 import re
+import time
 
 from . import ui
 from .config import DEFAULT_CACHE_LOCATION
@@ -76,8 +77,112 @@ def generate_unique_id():
     return f"{timestamp}-{uuid.uuid4().hex[:8]}"
 
 
-def find_last_session_dir(cache_dir):
-    """Return the path to the most recently *active* session dir under ``cache_dir``.
+# ---------------------------------------------------------------------------
+# latest-session pointer (.mini)
+# ---------------------------------------------------------------------------
+
+# The .mini directory (inside the user's --allowed-dir) holds a tiny pointer to
+# the most recent session. --load-last-session consults this pointer *first*
+# (an explicit opt-in the user's environment recorded) before falling back to
+# the timestamp heuristic in find_last_session_dir().
+#
+# NOTE: .mini is also the skills feature's directory. The pointer is a single
+# dedicated file inside it (LAST_SESSION_FILENAME), so the two never collide and
+# the skills code (which only reads <skill-name>/ + SKILLS.md) is unaffected.
+SKILLS_DIRNAME = ".mini"
+LAST_SESSION_FILENAME = "last_session.json"
+
+
+def _last_session_dir_store(allowed_dir):
+    """Return the .mini directory for ``allowed_dir`` (creating it if needed).
+
+    Best-effort: never raises. Returns None if the directory cannot be ensured,
+    in which case the pointer is simply not consulted/updated.
+    """
+    if not allowed_dir:
+        return None
+    store = os.path.join(os.path.abspath(allowed_dir), SKILLS_DIRNAME)
+    try:
+        os.makedirs(store, exist_ok=True)
+        return store
+    except OSError as e:
+        ui.console.note(f"Could not use {store} for the latest-session pointer: {e}", "warn")
+        return None
+
+
+def save_last_session_pointer(allowed_dir, session_dir):
+    """Record ``session_dir`` as the latest session in ``allowed_dir/.mini``.
+
+    Writes a tiny JSON file (the absolute path plus a timestamp) so a later
+    --load-last-session run can resume the most recent session without scanning
+    the cache dir. Best-effort: never raises, returns the written path or None.
+    """
+    if not session_dir:
+        return None
+    store = _last_session_dir_store(allowed_dir)
+    if store is None:
+        return None
+    payload = {
+        "session_dir": os.path.abspath(session_dir),
+        "recorded_at": time.time(),
+    }
+    path = os.path.join(store, LAST_SESSION_FILENAME)
+    try:
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(payload, f, indent=2)
+        return path
+    except OSError as e:
+        ui.console.note(f"Could not record latest-session pointer: {e}", "warn")
+        return None
+
+
+def load_last_session_pointer(allowed_dir):
+    """Read the latest-session pointer recorded under ``allowed_dir/.mini``.
+
+    Returns the recorded session directory (a path into the cache folder), or
+    None if no pointer exists or it cannot be read. Best-effort: a missing or
+    malformed pointer simply yields None so the caller falls back to the
+    timestamp heuristic.
+    """
+    if not allowed_dir:
+        return None
+    store = os.path.join(os.path.abspath(allowed_dir), SKILLS_DIRNAME)
+    path = os.path.join(store, LAST_SESSION_FILENAME)
+    if not os.path.isfile(path):
+        return None
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            payload = json.load(f)
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    session_dir = payload.get("session_dir")
+    if not session_dir or not os.path.isdir(session_dir):
+        return None
+    return session_dir
+
+
+def find_last_session_dir(cache_dir=None, allowed_dir=None, use_pointer=True):
+    """Return the path to the most recently *active* session dir.
+
+    When ``use_pointer`` and an ``allowed_dir`` are given, the .mini pointer
+    recorded by a previous run (see save_last_session_pointer) is consulted
+    *first* -- it is an explicit record of the session the user last worked in.
+    Only if that yields nothing do we fall back to the timestamp heuristic over
+    ``cache_dir`` (find_last_session_dir_by_mtime). Session folders with no
+    files are ignored. Never raises: a missing/unreadable cache dir simply
+    yields None.
+    """
+    if use_pointer and allowed_dir:
+        pointed = load_last_session_pointer(allowed_dir)
+        if pointed:
+            return pointed
+    return find_last_session_dir_by_mtime(cache_dir)
+
+
+def find_last_session_dir_by_mtime(cache_dir):
+    """Timestamp heuristic for the most recently *active* session dir.
 
     "Most recent" is decided by the newest modification time of any file inside
     each session folder (a session rewrites its ``history_{n}.json`` every step),

{mini_code_cli-0.1.0.0 → mini_code_cli-0.1.0.2}/mini_code_cli/ui.py

@@ -99,6 +99,12 @@ class Console:
         # "… thinking" spinner state (see start_thinking / stop_thinking).
         self._thinking_thread = None
         self._thinking_stop = None
+        # "… calling tool" spinner state (see start_tool_call / stop_tool_call).
+        # Mirrors the thinking spinner: a daemon thread that rewrites a single
+        # live line in place (via the transient region) so the tool-execution
+        # phase looks alive without scrolling the transcript.
+        self._tool_call_thread = None
+        self._tool_call_stop = None
         # Live "transient" region (non-verbose mode) renders the tool-call area
         # and the usage line without scrolling the screen. We keep a single
         # invariant: whenever ``_transient_lines`` is > 0 a block of that many
@@ -365,6 +371,16 @@ class Console:
         """
         self.emit(self.style("-" * self.width, fg="gray", dim=True))
 
+    def short_divider(self, char="-", width=8, fg="gray"):
+        """Render a short horizontal delimiter line (not the full width).
+
+        Used to set off the user's own "You:" turn from the preceding assistant
+        reply with a light, unobtrusive rule rather than a full-width divider.
+        Defaults to a plain ASCII dash so it renders consistently regardless of
+        the console's unicode setting.
+        """
+        self.emit(self.style(char * width, fg=fg, dim=True))
+
     def clear_screen(self):
         """Clear the terminal and move the cursor to the top-left.
 
@@ -432,6 +448,55 @@ class Console:
         if thread is not None and thread.is_alive():
             thread.join(timeout=1.0)
 
+    def start_tool_call(self, message="Calling tool"):
+        """Start a background "… calling tool" spinner (non-scrolling).
+
+        Shown while the agent executes a tool call, mirroring
+        :meth:`start_thinking` which covers the LLM request. Runs a short
+        animation in a daemon thread that rewrites a single live line in place
+        via the transient region, so the wait looks alive without scrolling the
+        transcript. On a real colour/utf-8 TTY it animates in place; on piped /
+        ASCII output it simply prints one static line and starts no thread.
+        Stop it with :meth:`stop_tool_call` before drawing the next turn.
+        """
+        self.stop_tool_call()  # be defensive: never leak more than one spinner
+        if not self._can_clear_cursor():
+            self.emit(self.style(f"\u2026 {message}", fg="magenta", dim=True))
+            return
+        self._tool_call_stop = threading.Event()
+        self._tool_call_thread = threading.Thread(
+            target=self._spin_tool_call, args=(message,), daemon=True)
+        self._tool_call_thread.start()
+
+    def _spin_tool_call(self, message):
+        """Animation loop for the tool-call spinner (mirror of :meth:`_spin`)."""
+        stop = self._tool_call_stop
+        i = 0
+        while not stop.is_set():
+            dots = "\u2026 " * min((i % 3) + 1, 3)
+            i += 1
+            self.emit_transient(self.style(f"{dots}{message}", fg="magenta", dim=True))
+            stop.wait(0.3)
+        # Replace the spinner line with a blank so the following real output
+        # lands cleanly; the blank stays tracked as the transient block and is
+        # cleared by the next :meth:`emit` (e.g. the next assistant turn).
+        self.emit_transient(None)
+
+    def stop_tool_call(self):
+        """Stop the "… calling tool" spinner started by :meth:`start_tool_call`.
+
+        Signals the animation thread to finish its current frame and exit, then
+        joins it, so no writes race with the main thread's subsequent output.
+        Safe to call when no spinner is running (a no-op)."""
+        stop = self._tool_call_stop
+        thread = self._tool_call_thread
+        self._tool_call_stop = None
+        self._tool_call_thread = None
+        if stop is not None:
+            stop.set()
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=1.0)
+
     def tool_group(self, name, params=None, result=None, status="ran"):
         """Render one attempted tool call: its name, parameters and result."""
         self.emit(self.style(f"{self.glyph('gear')} {name}", fg="magenta", bold=True))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.1.0.0
+Version: 0.1.0.2
 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
@@ -720,7 +720,7 @@ mini-code --enable-shell --auto-mode --agent-md "./skill.md" --allowed-dir "./"
 - allowed-dir: this specifies which dirs the agent can read and write from, that does not stop the shell comands! (though dangerous shell commands are still blocked by the classifier above).
 - 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 (the one whose history was last modified) 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.
+- 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.
 - 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
@@ -871,4 +871,19 @@ vllm serve ornith-ai/Ornith-1.5-397B-FP8 \
     --trust-remote-code
 ```
 
+## Citation
+
+If you use `mini-code-cli` in your research or writing, please cite it using the BibTeX entry below:
+
+```bibtex
+@misc{mini-code-cli,
+  author       = {Rozanov, Nikolai},
+  title        = {mini-code-cli: A minimal, dependency-light coding agent},
+  year         = {2026},
+  version      = {0.1.0.0},
+  howpublished = {\url{https://github.com/ai-nikolai/mini-code-cli}},
+  note         = {A no-bloat, dependency-free agent CLI for experimenting.}
+}
+```
+
 ## (C) Nikolai Rozanov, 2026 - Present

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

@@ -26,6 +26,7 @@ mini_code_cli/subagents/base.py
 mini_code_cli/subagents/builtin.py
 tests/test_agent_loop.py
 tests/test_integration.py
+tests/test_last_session_pointer.py
 tests/test_plan.py
 tests/test_sandboxing.py
 tests/test_shell_safety.py

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

@@ -1,7 +1,7 @@
 [project]
 name = "mini-code-cli"
 # version = { file = "mini_code_cli/__init__.py", attr = "__version__" }
-version = "0.1.0.0"
+version = "0.1.0.2"
 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/tests/test_last_session_pointer.py

@@ -0,0 +1,218 @@
+"""Tests for the `.mini` latest-session pointer used by --load-last-session.
+
+A tiny pointer is recorded in `--allowed-dir/.mini/last_session.json` at the
+end of every interactive session. `--load-last-session` consults that pointer
+*first* (an explicit record of the session the user last worked in) and only
+falls back to the timestamp heuristic over the cache dir when there is none.
+"""
+import io
+import os
+import sys
+import types
+import tempfile
+import json
+import shutil
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from mini_code_cli import agent_loop, ui, persistence, skills
+
+
+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 TestPointerBasics(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.allowed = self.tmp.name
+
+    def _session_dir(self, name="sess"):
+        d = os.path.join(self.tmp.name, "cache", name)
+        os.makedirs(d, exist_ok=True)
+        open(os.path.join(d, "history.json"), "w").write("[]")
+        return d
+
+    def test_save_then_load_roundtrip(self):
+        sdir = self._session_dir("one")
+        path = persistence.save_last_session_pointer(self.allowed, sdir)
+        self.assertIsNotNone(path)
+        self.assertTrue(os.path.isfile(path))
+        payload = json.load(open(path))
+        self.assertEqual(payload["session_dir"], os.path.abspath(sdir))
+        self.assertIn("recorded_at", payload)
+        self.assertEqual(persistence.load_last_session_pointer(self.allowed),
+                         os.path.abspath(sdir))
+
+    def test_load_missing_returns_none(self):
+        self.assertIsNone(persistence.load_last_session_pointer(self.allowed))
+
+    def test_load_malformed_returns_none(self):
+        persistence.save_last_session_pointer(self.allowed, self._session_dir("x"))
+        p = os.path.join(self.allowed, ".mini", persistence.LAST_SESSION_FILENAME)
+        open(p, "w").write("not json {[")
+        self.assertIsNone(persistence.load_last_session_pointer(self.allowed))
+
+    def test_load_pointing_to_missing_dir_returns_none(self):
+        path = persistence.save_last_session_pointer(self.allowed, self._session_dir("x"))
+        shutil.rmtree(os.path.join(self.tmp.name, "cache", "x"))
+        self.assertIsNone(persistence.load_last_session_pointer(self.allowed))
+
+    def test_save_none_is_a_noop(self):
+        self.assertIsNone(persistence.save_last_session_pointer(self.allowed, None))
+        self.assertIsNone(
+            persistence.load_last_session_pointer(self.allowed))
+
+
+class TestFindLastSessionResolution(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")
+
+    def _session_dir(self, name):
+        d = os.path.join(self.cache, name)
+        os.makedirs(d, exist_ok=True)
+        f = os.path.join(d, "history.json")
+        open(f, "w").write("[]")
+        return d, f
+
+    def test_pointer_wins_over_newer_mtime(self):
+        s1, _ = self._session_dir("older")
+        s2, f2 = self._session_dir("newer")
+        os.utime(f2, (1e12, 1e12))  # far in the future -> newest by mtime
+        # Record a pointer to s1 (the older one).
+        persistence.save_last_session_pointer(self.allowed, s1)
+        got = persistence.find_last_session_dir(self.cache, allowed_dir=self.allowed,
+                                                use_pointer=True)
+        self.assertEqual(got, os.path.abspath(s1))
+
+    def test_falls_back_to_mtime_when_no_pointer(self):
+        s1, _ = self._session_dir("older")
+        s2, f2 = self._session_dir("newer")
+        os.utime(f2, (1e12, 1e12))
+        got = persistence.find_last_session_dir(self.cache, allowed_dir=self.allowed,
+                                                use_pointer=True)
+        self.assertEqual(got, os.path.abspath(s2))
+
+    def test_use_pointer_false_ignores_pointer(self):
+        s1, _ = self._session_dir("older")
+        s2, f2 = self._session_dir("newer")
+        os.utime(f2, (1e12, 1e12))
+        persistence.save_last_session_pointer(self.allowed, s1)
+        got = persistence.find_last_session_dir(self.cache, allowed_dir=self.allowed,
+                                                use_pointer=False)
+        self.assertEqual(got, os.path.abspath(s2))
+
+    def test_none_when_everything_empty(self):
+        os.makedirs(self.cache, exist_ok=True)
+        got = persistence.find_last_session_dir(self.cache, allowed_dir=self.allowed,
+                                                use_pointer=True)
+        self.assertIsNone(got)
+
+
+class TestPointerAndSkillsCoexist(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.allowed = self.tmp.name
+
+    def test_pointer_file_does_not_appear_as_a_skill(self):
+        # Use skills so .mini + SKILLS.md exist.
+        skills.list_skills(self.allowed)
+        # A session records its pointer in the same .mini.
+        cache = os.path.join(self.tmp.name, "cache")
+        sdir = os.path.join(cache, "abc")
+        os.makedirs(sdir); open(os.path.join(sdir, "history.json"), "w").write("[]")
+        persistence.save_last_session_pointer(self.allowed, sdir)
+        # Skills still work, and the pointer file never shows up as a skill.
+        listing = skills.list_skills(allowed_dir=self.allowed)
+        self.assertNotIn(persistence.LAST_SESSION_FILENAME, listing)
+        self.assertIn("Skills", open(skills.summary_path(self.allowed)).read())
+
+    def test_create_skill_after_pointer_written(self):
+        cache = os.path.join(self.tmp.name, "cache")
+        sdir = os.path.join(cache, "abc")
+        os.makedirs(sdir); open(os.path.join(sdir, "history.json"), "w").write("[]")
+        persistence.save_last_session_pointer(self.allowed, sdir)
+        out = skills.create_skill(self.allowed, "greet", "greets")
+        self.assertIn("Created", out)
+        self.assertIn("greet", skills.list_skills(self.allowed))
+
+
+class TestPrintSessionIdAndDivider(unittest.TestCase):
+    """The interactive run() should show the id as an Assistant turn in brackets,
+    and draw a short divider before the user's turn."""
+
+    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)
+
+    def _fake_llm(self, session):
+        def fake(messages, **kw):
+            return "hi there", [], {"prompt_tokens": 1, "completion_tokens": 1,
+                                    "total_tokens": 2}
+        return fake
+
+    def test_session_id_renderedin_assistant_turn_and_pointer_written(self):
+        allowed = self.tmp.name
+        args = _make_args(cache_dir=os.path.join(self.tmp.name, "cache"),
+                          allowed_dir=allowed, prompt="hello")
+        sess = agent_loop.AgentSession(args, console=self.console)
+        uid = sess.unique_id
+
+        with patch.object(agent_loop.utils, "determine_vllm_model", return_value=None), \
+             patch.object(agent_loop.utils, "call_openai_server", self._fake_llm(sess)), \
+             patch.object(self.console, "read_line", side_effect=iter(["/quit"])):
+            sess.run(initial_prompt="hello")
+
+        out = self.buf.getvalue()
+        # (1) id rendered as an Assistant turn carrying only the id in brackets.
+        self.assertIn(f"[{uid}]", out)
+        # It sits on the same line as the 'Assistant' role marker.
+        self.assertRegex(out, r"(?m)^> Assistant\n   \[%s\]$" % uid)
+        # No noisy "saved under" line in the session-id turn.
+        self.assertNotIn("saved under", out)
+
+        # (3) a pointer was written under allowed_dir/.mini.
+        ptr = os.path.join(allowed, ".mini", persistence.LAST_SESSION_FILENAME)
+        self.assertTrue(os.path.isfile(ptr))
+        payload = json.load(open(ptr))
+        self.assertEqual(payload["session_dir"],
+                         os.path.abspath(os.path.join(self.tmp.name, "cache", uid)))
+
+    def test_short_divider_before_preset_you_turn(self):
+        args = _make_args(cache_dir=os.path.join(self.tmp.name, "cache"),
+                          allowed_dir=self.tmp.name, prompt="hello")
+        sess = agent_loop.AgentSession(args, console=self.console)
+        with patch.object(agent_loop.utils, "determine_vllm_model", return_value=None), \
+             patch.object(agent_loop.utils, "call_openai_server", self._fake_llm(sess)), \
+             patch.object(self.console, "read_line", side_effect=iter(["/quit"])):
+            sess.run(initial_prompt="hello")
+        out = self.buf.getvalue()
+        # The preset "You" turn is preceded by a short divider line.
+        lines = out.splitlines()
+        idx = next(i for i, l in enumerate(lines) if l.strip() == "> You")
+        divider = lines[idx - 1].strip()
+        self.assertTrue(set(divider) <= {"-", " "})
+        self.assertIn("-", divider)
+        self.assertLess(len(divider.strip("-")), 12)
+
+
+if __name__ == "__main__":
+    unittest.main()

{mini_code_cli-0.1.0.0 → mini_code_cli-0.1.0.2}/tests/test_ui.py

@@ -115,6 +115,24 @@ class TestConsoleRendering(unittest.TestCase):
         self.assertIn("Assistant", text)
         self.assertIn("   line2", text)
 
+    def test_short_divider_renders_without_ansi(self):
+        c = ui.Console(stream=self.buf, color=False)
+        c.short_divider()
+        out = self.buf.getvalue().rstrip("\n")
+        # A short run of dashes, not the full-width divider.
+        self.assertTrue(set(out) <= {"-", " "})
+        self.assertLess(len(out.strip("-")), 12)
+        self.assertIn("-", out)
+
+    def test_short_divider_shorter_than_full_divider(self):
+        c = ui.Console(stream=self.buf, color=False)
+        c.short_divider()
+        short = len(self.buf.getvalue().rstrip("\n").strip())
+        self.buf.seek(0); self.buf.truncate()
+        c.divider()
+        full = len(self.buf.getvalue().rstrip("\n").strip())
+        self.assertLess(short, full)
+
     def test_welcome_renders_without_error(self):
         c = ui.Console(stream=self.buf, color=False)
         c.welcome("1.0", "id", "/cache", "/home", "http://x", "model",