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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mini-code-cli
-Version: 0.0.8.4
-Summary: Mini Coding CLI.
+Version: 0.1.0.0
+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
                                Version 3, 19 November 2007
@@ -700,6 +700,9 @@ mini-code --url "https://api.deepseek.com" --model "deepseek-v4-flash"
 ```bash
 mini-code --enable-shell --auto-mode
 mini-code -s -a --sudo
+mini-code -s -a -p -g -l --sudo #plan, previous session, subagents (#or short-hand the next commands)
+mini-code --all
+mini-code --all-last
 ```
 
 4. Advanced usage:

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

@@ -26,6 +26,9 @@ mini-code --url "https://api.deepseek.com" --model "deepseek-v4-flash"
 ```bash
 mini-code --enable-shell --auto-mode
 mini-code -s -a --sudo
+mini-code -s -a -p -g -l --sudo #plan, previous session, subagents (#or short-hand the next commands)
+mini-code --all
+mini-code --all-last
 ```
 
 4. Advanced usage:

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

@@ -16,6 +16,7 @@ smaller, focused modules so each concern is easy to read and test:
   * :mod:`mini_code_cli.runner`      -- running a tool with a wall-clock timeout.
   * :mod:`mini_code_cli.config`      -- shared default settings.
   * :mod:`mini_code_cli.subagents`   -- delegating a task to a sub-agent.
+  * :mod:`mini_code_cli.skills`      -- the ``.mini`` skills feature.
 
 For backward compatibility (and the test-suite) the most commonly imported
 helpers are re-exported from here, so ``from mini_code_cli.agent_loop import ...``
@@ -32,6 +33,7 @@ from . import tools
 from . import utils
 from . import ui
 from . import subagents
+from . import skills
 from . import plan as plan_utils
 from .config import (
     DEFAULT_CACHE_LOCATION,
@@ -116,14 +118,29 @@ def parse_args():
     parser.add_argument("--allowed-dir", type=str, default=".", help="Allowed directory for file operations, default='./'")
     parser.add_argument("-s", "--enable-shell", action="store_true", help="Allow shell execution. default= False")
     parser.add_argument("-g","--enable-subagents", action="store_true", help="Allow the agent to delegate work to sub-agents (exposed as extra tools). default= False")
+    parser.add_argument("--skills", action="store_true", help="Enable the skills feature: a local .mini directory (inside --allowed-dir) of skill.md files, skill sub-dirs, a high-level SKILLS.md summary, and executable Python scripts, exposed to the agent as list_skills/read_skill/create_skill/run_skill tools. default= False")
     parser.add_argument("--llm-timeout", type=int, default=DEFAULT_HTTP_TIMEOUT, help=f"HTTP timeout in seconds for LLM requests (reasoning models can be slow). default={DEFAULT_HTTP_TIMEOUT}")
     parser.add_argument("--tool-timeout", type=int, default=DEFAULT_TOOL_TIMEOUT, help=f"Timeout in seconds for a single tool call. default={DEFAULT_TOOL_TIMEOUT}")
     parser.add_argument("-p","--plan", action="store_true", help="Enable plan mode: the agent keeps a CURRENT_PLAN.md (its step-by-step plan, marked finished when the goal is done) and CURRENT_GOAL.md (the user's latest instruction) in the session directory. Also changes how history compaction works.")
 
+    parser.add_argument("--all", action="store_true", help="Enable: --plan, --subagents, --shell, --automode, --sudo")
+    parser.add_argument("--all-last", action="store_true", help="Enable: --plan, --subagents, --shell, --automode, --sudo, --load-last-session")
+
     # Output verbosity
     parser.add_argument("--verbose", action="store_true", help="Print the full, detailed output. Without it (default), only user/assistant turns, token usage and tool calls are shown.")
 
     args = parser.parse_args()
+
+    if args.all or args.all_last:
+        args.plan = True
+        args.enable_subagents = True
+        args.enable_shell = True
+        args.sudo = True
+        args.auto_mode = True
+    
+    if args.all_last:
+        args.load_last_session = True
+
     return args
 
 
@@ -154,6 +171,10 @@ def print_help(allowed_dir, server_url, args, unique_id, cache_dir, model_name):
         ui.console.emit(ui.console.style("Sub-agents:", bold=True, fg="cyan"))
         for sa in subagents.get_registry().values():
             ui.console.emit(f"  {sa.name:16} {sa.description}")
+    if args.enable_skills or args.verbose:
+        ui.console.emit(ui.console.style("Skills:", bold=True, fg="cyan"))
+        for name in skills.SKILL_TOOL_NAMES:
+            ui.console.emit(f"  {name:16} (from the local .mini directory)")
     ui.console.rule(char="═", fg="cyan")
 
 
@@ -285,6 +306,19 @@ class AgentSession:
             # 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)
+
         # Token accounting for the whole session.
         self.token_stats = {
             "prompt_tokens": 0,
@@ -363,7 +397,11 @@ class AgentSession:
         if self.args.system_prompt:
             system_prompt = self.args.system_prompt
         else:
-            system_prompt = prompts.system_prompt(tools_dict=self.tools_dict, allowed_dir=self.allowed_dir, plan_mode=self.plan_mode)
+            system_prompt = prompts.system_prompt(
+                tools_dict=self.tools_dict, allowed_dir=self.allowed_dir,
+                plan_mode=self.plan_mode,
+                skills_dir=self.allowed_dir if self.enable_skills else None,
+            )
 
         messages = [{"role": "system", "content": system_prompt}]
 
@@ -619,20 +657,39 @@ class AgentSession:
         Appends ``initial_task`` as a user turn, then keeps stepping until the
         model makes no further tool calls (auto-mode). ``max_steps`` caps the
         number of model calls so a misbehaving sub-agent cannot loop forever.
+
+        The sub-agent records its work in its own cache dir: every step persists
+        history / recorder / usage into the child's own session folder, and it
+        seeds CURRENT_GOAL.md / CURRENT_PLAN.md (in plan mode) so each sub-session
+        is self-contained and easy to inspect or resume. A final record is left
+        even on a mid-run failure (the seeded goal is marked finished).
         """
         self.messages.append({"role": "user", "content": initial_task})
+        # Seed the goal up front so the child keeps a self-contained record in
+        # its own cache dir (a sub-agent always records a goal, independent of
+        # the parent's --plan flag). We use the child's own plan_manager here so
+        # nothing is written to the parent's session folder.
+        from .plan import PlanManager
+        child_plan = PlanManager(os.path.join(self.cache_dir, self.unique_id), enabled=True)
+        child_plan.write_goal(initial_task)
         steps = 0
-        while True:
-            should_continue = self._step()
+        try:
+            while True:
+                should_continue = self._step()
+                self._persist()
+                steps += 1
+                if max_steps and steps >= max_steps:
+                    self.console.note(
+                        f"Sub-agent reached max_steps ({max_steps}); stopping.", "warn")
+                    break
+                if not should_continue:
+                    break
+            return self._last_assistant_text()
+        finally:
+            # Leave a clean, finished record in the child's cache dir even on an
+            # error / early stop, so the sub-session is never left open.
+            child_plan.mark_finished()
             self._persist()
-            steps += 1
-            if max_steps and steps >= max_steps:
-                self.console.note(
-                    f"Sub-agent reached max_steps ({max_steps}); stopping.", "warn")
-                break
-            if not should_continue:
-                break
-        return self._last_assistant_text()
 
     def _last_assistant_text(self):
         """Return the content of the most recent assistant (non tool-call) turn."""

{mini_code_cli-0.0.8.4 → mini_code_cli-0.1.0.0}/mini_code_cli/plan.py

@@ -6,14 +6,16 @@ active goal and the plan for reaching it:
 
   * ``CURRENT_GOAL.md``  -- the user's latest instruction / goal (verbatim).
   * ``CURRENT_PLAN.md``  -- the agent's current plan for that goal, followed by
-    a short running log (e.g. an entry recording when a goal was finished).
+    a short running log (e.g. an entry recording when a goal was set/changed,
+    and when it was finished).
 
 The plan document itself is authored by the agent (the system prompt tells it
 to, and it uses its ``write_file`` tool). This manager owns the parts the loop
 is responsible for -- seeding/reading the goal, reading the plan back so history
-compaction can re-inject it, and appending the "goal finished" log entry. It is
-deliberately free of any network or terminal dependency, and every method is a
-no-op when disabled, so it is trivial to unit-test in isolation.
+compaction can re-inject it, and appending the "goal finished" / goal-change log
+entries. It is deliberately free of any network or terminal dependency, and
+every method is a no-op when disabled, so it is trivial to unit-test in
+isolation.
 """
 
 import os
@@ -31,6 +33,11 @@ class PlanManager:
     ``history_{n}.json``). When ``enabled`` is False every method is a no-op, so
     callers can use the manager unconditionally and let the ``--plan`` flag
     decide whether anything actually happens.
+
+    ``session_dir`` is the session directory (``cache_dir/<unique_id>``) -- i.e.
+    the files always live in the *cache* dir, independent of ``--allowed-dir``.
+    The manager writes with plain ``open`` (not through the file tools), so the
+    records are created even when the allowed dir is a different location.
     """
 
     def __init__(self, session_dir, enabled=True, goal=None):
@@ -39,6 +46,10 @@ class PlanManager:
         # The last goal this manager was asked to record, so callers can tell a
         # new goal apart from the previous one. Kept in sync by write_goal().
         self.goal = goal
+        # The last goal (stripped) that was logged into CURRENT_PLAN.md, so
+        # write_goal can tell a genuine change apart from a re-stated goal and
+        # avoid spamming the plan with duplicate "goal updated" entries.
+        self._last_logged_goal = None
 
     # -- paths -------------------------------------------------------------
     @property
@@ -50,20 +61,55 @@ class PlanManager:
         return os.path.join(self.session_dir, GOAL_FILENAME)
 
     # -- writing -----------------------------------------------------------
+    def _append_plan_note(self, text):
+        """Append one dated line to CURRENT_PLAN.md (creating it if needed).
+
+        Shared by the goal-change log and ``mark_finished``. Best-effort and
+        never raises: a plan-tracking hiccup must never break the agent loop.
+        """
+        if not self.enabled:
+            return
+        try:
+            os.makedirs(self.session_dir, exist_ok=True)
+            if not os.path.exists(self.plan_path):
+                with open(self.plan_path, "w", encoding="utf-8") as f:
+                    f.write("# Current Plan\n\n")
+            with open(self.plan_path, "a", encoding="utf-8") as f:
+                f.write(text + "\n")
+        except OSError:
+            pass
+
     def write_goal(self, goal):
         """Persist the user's current goal / last instruction to CURRENT_GOAL.md.
 
         Overwrites any previous goal -- the file always reflects the *latest*
-        instruction. Best-effort and never raises: a plan-tracking hiccup must
-        never break the agent loop.
+        instruction. Also makes sure ``CURRENT_PLAN.md`` exists in the cache dir
+        (so both tracking files are present from the very first goal), and -- in
+        plan mode -- logs the goal into CURRENT_PLAN.md the *first* time it is
+        set and again whenever it changes, so the plan records goal pivots.
+        Best-effort and never raises.
         """
         if not self.enabled:
             return
+        stripped = (goal or "").strip()
         try:
             os.makedirs(self.session_dir, exist_ok=True)
+            # Ensure CURRENT_PLAN.md exists in the cache dir too, so the goal
+            # always has a companion plan file sitting next to it.
+            if not os.path.exists(self.plan_path):
+                with open(self.plan_path, "w", encoding="utf-8") as f:
+                    f.write("# Current Plan\n\n")
             with open(self.goal_path, "w", encoding="utf-8") as f:
                 f.write("# Current Goal\n\n")
-                f.write((goal or "").strip() + "\n")
+                f.write(stripped + "\n")
+            # Log the goal change into the plan -- but only on a genuine change
+            # (compared against the last goal actually logged), so re-stating the
+            # same goal on later turns does not spam the plan log.
+            if stripped and stripped != self._last_logged_goal:
+                verb = "Goal set to" if self._last_logged_goal is None else "Goal updated to"
+                stamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                self._append_plan_note(f"- [{stamp}] {verb}: {stripped}")
+                self._last_logged_goal = stripped
             self.goal = goal
         except OSError:
             pass
@@ -82,16 +128,8 @@ class PlanManager:
         # never captured one itself, e.g. a one-shot --prompt preset), and only
         # then fall back to a generic description.
         goal = goal or self.goal or self._read(self.goal_path) or "current goal"
-        try:
-            os.makedirs(self.session_dir, exist_ok=True)
-            if not os.path.exists(self.plan_path):
-                with open(self.plan_path, "w", encoding="utf-8") as f:
-                    f.write("# Current Plan\n\n")
-            stamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            with open(self.plan_path, "a", encoding="utf-8") as f:
-                f.write(f"\n- [{stamp}] Task finished: {goal}\n")
-        except OSError:
-            pass
+        stamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self._append_plan_note(f"- [{stamp}] Task finished: {goal}")
 
     # -- reading -----------------------------------------------------------
     def read_plan(self):

{mini_code_cli-0.0.8.4 → mini_code_cli-0.1.0.0}/mini_code_cli/prompts.py

@@ -1,5 +1,5 @@
 # System prompt defining available tools and compaction behavior
-def system_prompt(tools_dict=None, allowed_dir=None, plan_mode=False):
+def system_prompt(tools_dict=None, allowed_dir=None, plan_mode=False, skills_dir=None):
     """
     Takes a list of tool names and returns a system prompt string.
 
@@ -26,6 +26,10 @@ def system_prompt(tools_dict=None, allowed_dir=None, plan_mode=False):
     if allowed_dir:
         allowed_dir_prompt = f"\nThe path you are allowed to operate in is called: {allowed_dir}"
 
+    skills_prompt = ""
+    if skills_dir is not None:
+        skills_prompt = "\n" + skills_instructions(skills_dir)
+
     plan_mode_prompt = ""
     if plan_mode:
         plan_mode_prompt = "\n" + plan_instructions()
@@ -33,7 +37,7 @@ def system_prompt(tools_dict=None, allowed_dir=None, plan_mode=False):
     
     prompt = f"""
 {base_prompt}
-{tool_descriptions}{end_prompt}{allowed_dir_prompt}{plan_mode_prompt}
+{tool_descriptions}{end_prompt}{allowed_dir_prompt}{plan_mode_prompt}{skills_prompt}
 Important: Follow the user instruction. Do not create additional .md files (unless asked to do so). Do not create unit tests (unless asked to do so), etc.
 """
     return prompt.strip()
@@ -62,6 +66,36 @@ def plan_instructions():
         "easy to track and resume."
     )
 
+def skills_instructions(skills_dir):
+    """The extra system-prompt block when the skills feature is enabled.
+
+    Tells the agent it has a local ``.mini`` directory of reusable skills and
+    explains the four skill tools (see :mod:`mini_code_cli.skills`). ``skills_dir``
+    is the actual ``.mini`` path so the prompt can point at it concretely.
+    """
+    from . import skills as skills_mod
+    return (
+        "SKILLS MODE: You can work with reusable skills kept in the local "
+        f"`.mini` directory at: {skills_mod.skills_dir(skills_dir)}.\n"
+        "Each skill is a sub-directory containing a `skill.md` (what the skill is "
+        "/ how to use it) and optional executable Python helper scripts. There is "
+        "also a high-level `SKILLS.md` summary of all skills.\n"
+        "Use these tools to work with skills:\n"
+        "  * `list_skills`  - see which skills exist (name + one-line summary).\n"
+        "  * `read_skill`   - read a skill's `skill.md` by name, to learn how to "
+        "use it or which scripts it provides.\n"
+        "  * `create_skill` - create a new skill (its sub-directory and `skill.md`) "
+        "when you build a reusable capability. Give a clear, single-segment name "
+        "and a short summary. It is normal to then add Python helper scripts into "
+        "the skill's directory.\n"
+        "  * `run_skill`    - run one of a skill's Python scripts, passing any "
+        "command-line arguments via its `args`. Read the skill first to know "
+        "which script to run and what arguments it expects.\n"
+        "Prefer turning reusable helpers into skills (with a `skill.md` plus "
+        "scripts) so they can be reused later, rather than repeating one-off work.\n"
+    )
+
+
 def compaction_prompt(messages):
     """
     Takes a messages list and returns a compact prompt string summarizing the conversation.