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

mini_code_cli/__init__.py

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

mini_code_cli/__main__.py

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

mini_code_cli/agent_files.py

@@ -0,0 +1,90 @@
+"""Agent-owned files kept in ``--allowed-dir/.mini``.
+
+Two opt-in features put a file the *agent* may read and write there, rather
+than in the session directory the loop owns:
+
+  * the **scratchpad** (``--scratchpad``): a free-form note file for thoughts,
+    plans and learnings, plus as many additional scratch files as the agent
+    wants to create;
+  * the **open plan** (``--plan-strategy open-plan``): a plan document the
+    agent maintains itself with the normal file tools.
+
+Both live under the same ``.mini`` directory as the skills folder and the
+latest-session pointer, so they are inside the ``--allowed-dir`` sandbox and
+the normal ``read_file`` / ``write_file`` / ``edit`` tools can reach them. The
+directory name is read from :mod:`mini_code_cli.persistence` at call time, so
+the test suite can redirect it globally (exactly like the session pointer).
+"""
+
+import os
+
+from . import persistence
+
+SCRATCHPAD_FILENAME = "SCRATCHPAD.md"
+OPEN_PLAN_FILENAME = "PLAN.md"
+
+_SCRATCHPAD_HEADER = """# Scratchpad
+
+This file belongs to the agent. It may read and write it freely and may create
+additional scratch files in the same directory. Use it for thoughts, plans,
+learnings and notes that should survive a compaction.
+"""
+
+_OPEN_PLAN_HEADER = """# Agent Plan
+
+This plan document belongs to the agent. Read it before continuing, keep it up
+to date as work progresses, and mark steps done or outstanding.
+"""
+
+
+def mini_dir(allowed_dir):
+    """The ``.mini`` directory inside ``allowed_dir`` (not created)."""
+    return os.path.join(os.path.abspath(allowed_dir), persistence.SESSION_DIRNAME)
+
+
+def scratchpad_path(allowed_dir):
+    """Path to the main scratch-pad file."""
+    return os.path.join(mini_dir(allowed_dir), SCRATCHPAD_FILENAME)
+
+
+def open_plan_path(allowed_dir):
+    """Path to the agent-authored plan document."""
+    return os.path.join(mini_dir(allowed_dir), OPEN_PLAN_FILENAME)
+
+
+def ensure_scratchpad(allowed_dir):
+    """Create the main scratch-pad file (and its directory) if missing."""
+    return _ensure_file(scratchpad_path(allowed_dir), _SCRATCHPAD_HEADER)
+
+
+def ensure_open_plan(allowed_dir):
+    """Create the agent plan document (and its directory) if missing."""
+    return _ensure_file(open_plan_path(allowed_dir), _OPEN_PLAN_HEADER)
+
+
+def read_text(path, limit=None):
+    """Read ``path`` as text, returning ``""`` when it cannot be read.
+
+    ``limit`` caps the returned characters (the open-plan re-injection after a
+    compaction should not be able to re-fill the context with the document).
+    """
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as handle:
+            text = handle.read()
+    except OSError:
+        return ""
+    if limit is not None and len(text) > limit:
+        return text[:limit] + "\n[... truncated ...]\n"
+    return text
+
+
+def _ensure_file(path, header):
+    """Best-effort create-with-header; never raises, always returns ``path``."""
+    try:
+        if not os.path.isfile(path):
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with open(path, "w", encoding="utf-8") as handle:
+                handle.write(header)
+    except OSError:
+        pass
+    return path