wizolt 0.37.0__tar.gz

wizolt-0.37.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, hit9
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT INCLUDING NEGLIGENCE OR OTHERWISE ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

wizolt-0.37.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include LICENSE
+recursive-include wizolt/builtin_skills *.md
+prune demo*
+prune tests

wizolt-0.37.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: wizolt
+Version: 0.37.0
+Summary: A terminal coding agent written in Python
+Author-email: hit9 <hit9@icloud.com>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/hit9/wizolt
+Project-URL: Repository, https://github.com/hit9/wizolt
+Project-URL: Issues, https://github.com/hit9/wizolt/issues
+Project-URL: Documentation, https://wizolt.readthedocs.io
+Keywords: ai,coding-agent,cli,terminal
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Software Development
+Classifier: Topic :: Terminals
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=1.0.0
+Requires-Dist: code-symbol-index>=0.5.1
+Requires-Dist: json-repair
+Requires-Dist: fastmcp-slim[client]<4,>=3
+Requires-Dist: openai>=3.0.0
+Requires-Dist: pathspec>=1.0
+Requires-Dist: pillow>=11.0
+Requires-Dist: prompt-toolkit>=3.0.53
+Requires-Dist: rich>=13.0
+Requires-Dist: socksio>=1.0.0
+Requires-Dist: websockets>=15.0.1
+Provides-Extra: dev
+Requires-Dist: pyright>=1.1.411; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.8; extra == "dev"
+Requires-Dist: ruff==0.16.0; extra == "dev"
+Dynamic: license-file
+
+<h1 align="center">wizolt</h1>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt1.gif" alt="wizolt editing code and running tools" width="600">
+</p>
+
+<p align="center">
+  A terminal coding agent I use, maintain, and customize, shipped as a self-contained Python package.
+</p>
+
+## Safety
+
+**Use at your own risk.** wizolt can edit files and run shell commands in the environment where it starts. It does not provide sandbox isolation; use a container or VM when needed.
+
+## What it is
+
+wizolt does not introduce a new kind of coding agent. It combines familiar features — reading and editing files, running commands, follow-ups, sessions, diffs, MCP, and skills — into a tool I use personally.
+
+It works on real repositories, including its own: I use wizolt to build and maintain wizolt. Everything ships in one self-contained Python package, so I can change the behavior directly whenever I want the workflow to work differently.
+
+Wizolt is the former minacode, which began as the single-file nanocode. The implementation outgrew both earlier names; the project history remains continuous.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt2.gif" alt="wizolt resuming a saved session" width="600">
+</p>
+<p align="center"><sub>Resuming a saved session with its conversation and tool history.</sub></p>
+
+## Highlights
+
+- **Worker delegation:** hand a bounded task to a second in-process session on its own provider with `/worker`; the `Delegate` tool keeps worker context across delegations until reset.
+- **Forced reply language:** `/language` or `[runtime] language` pins the reply language for the session.
+- **Smarter retries:** exponential backoff with jitter and provider `Retry-After`, shown as a live `retrying` phase with a countdown.
+- **Prompt-cache aware:** stable request prefixes let supported providers reuse work and can reach 90–99% cache hit rates; `/status` shows the reported result.
+- **Code navigation:** jump to definitions, callers, and implementations with a searchable code index.
+- **Live follow-ups:** type while the agent works; `Enter` queues a message for the next model step, while `Ctrl-C` discards a draft or interrupts the task once the input is empty.
+- **Anchored edits:** structured edits use `line:hash` anchors and reject stale file content.
+- **Resumable sessions:** conversation, tool calls, diffs, and working memory survive `-c` or `--resume`.
+- **Built-in diff viewer:** `/diff` shows the latest round and the net session result.
+- **MCP and skills:** connect Model Context Protocol servers and load Markdown instruction packs on demand.
+- **Provider-side web search:** opt in to a provider's own search tool (OpenAI, Qwen, Anthropic, Z.AI) and see each search and its sources in the transcript.
+- **Provider compatibility:** OpenAI-compatible APIs and Anthropic.
+
+## Install
+
+Requires macOS or Linux, Python 3.11+, and [uv](https://docs.astral.sh/uv/).
+
+```sh
+uv tool install wizolt
+wizolt --init-config
+```
+
+Add your provider to `~/.wizolt/config.toml`:
+
+```toml
+[provider]
+active = "default"
+
+[provider.default]
+url = "https://api.deepseek.com"
+key = "sk-..."
+model = "deepseek-v4-flash"
+```
+
+Then run:
+
+```sh
+wizolt
+```
+
+Upgrade with `uv tool upgrade wizolt`.
+
+## Links
+
+- [Documentation](https://wizolt.readthedocs.io/en/latest/) — full usage guide and reference.
+- [Blog post](https://hit9.dev/post/nanocode) — why and how it was built.
+- [code-symbol-index](https://github.com/hit9/code-symbol-index) — the code index library wizolt uses.

wizolt-0.37.0/README.md

@@ -0,0 +1,76 @@
+<h1 align="center">wizolt</h1>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt1.gif" alt="wizolt editing code and running tools" width="600">
+</p>
+
+<p align="center">
+  A terminal coding agent I use, maintain, and customize, shipped as a self-contained Python package.
+</p>
+
+## Safety
+
+**Use at your own risk.** wizolt can edit files and run shell commands in the environment where it starts. It does not provide sandbox isolation; use a container or VM when needed.
+
+## What it is
+
+wizolt does not introduce a new kind of coding agent. It combines familiar features — reading and editing files, running commands, follow-ups, sessions, diffs, MCP, and skills — into a tool I use personally.
+
+It works on real repositories, including its own: I use wizolt to build and maintain wizolt. Everything ships in one self-contained Python package, so I can change the behavior directly whenever I want the workflow to work differently.
+
+Wizolt is the former minacode, which began as the single-file nanocode. The implementation outgrew both earlier names; the project history remains continuous.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/hit9/wizolt/master/snapshots/wizolt2.gif" alt="wizolt resuming a saved session" width="600">
+</p>
+<p align="center"><sub>Resuming a saved session with its conversation and tool history.</sub></p>
+
+## Highlights
+
+- **Worker delegation:** hand a bounded task to a second in-process session on its own provider with `/worker`; the `Delegate` tool keeps worker context across delegations until reset.
+- **Forced reply language:** `/language` or `[runtime] language` pins the reply language for the session.
+- **Smarter retries:** exponential backoff with jitter and provider `Retry-After`, shown as a live `retrying` phase with a countdown.
+- **Prompt-cache aware:** stable request prefixes let supported providers reuse work and can reach 90–99% cache hit rates; `/status` shows the reported result.
+- **Code navigation:** jump to definitions, callers, and implementations with a searchable code index.
+- **Live follow-ups:** type while the agent works; `Enter` queues a message for the next model step, while `Ctrl-C` discards a draft or interrupts the task once the input is empty.
+- **Anchored edits:** structured edits use `line:hash` anchors and reject stale file content.
+- **Resumable sessions:** conversation, tool calls, diffs, and working memory survive `-c` or `--resume`.
+- **Built-in diff viewer:** `/diff` shows the latest round and the net session result.
+- **MCP and skills:** connect Model Context Protocol servers and load Markdown instruction packs on demand.
+- **Provider-side web search:** opt in to a provider's own search tool (OpenAI, Qwen, Anthropic, Z.AI) and see each search and its sources in the transcript.
+- **Provider compatibility:** OpenAI-compatible APIs and Anthropic.
+
+## Install
+
+Requires macOS or Linux, Python 3.11+, and [uv](https://docs.astral.sh/uv/).
+
+```sh
+uv tool install wizolt
+wizolt --init-config
+```
+
+Add your provider to `~/.wizolt/config.toml`:
+
+```toml
+[provider]
+active = "default"
+
+[provider.default]
+url = "https://api.deepseek.com"
+key = "sk-..."
+model = "deepseek-v4-flash"
+```
+
+Then run:
+
+```sh
+wizolt
+```
+
+Upgrade with `uv tool upgrade wizolt`.
+
+## Links
+
+- [Documentation](https://wizolt.readthedocs.io/en/latest/) — full usage guide and reference.
+- [Blog post](https://hit9.dev/post/nanocode) — why and how it was built.
+- [code-symbol-index](https://github.com/hit9/code-symbol-index) — the code index library wizolt uses.

wizolt-0.37.0/pyproject.toml

@@ -0,0 +1,97 @@
+[build-system]
+requires = ["setuptools>=77.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wizolt"
+version = "0.37.0"
+description = "A terminal coding agent written in Python"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+authors = [
+    { name = "hit9", email = "hit9@icloud.com" },
+]
+keywords = ["ai", "coding-agent", "cli", "terminal"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Software Development",
+    "Topic :: Terminals",
+]
+
+dependencies = [
+    # anthropic 1.x and openai 3.x both moved their HTTP client to httpx2, which stops installing
+    # certifi and verifies TLS against the OS trust store instead (SSL_CERT_FILE/SSL_CERT_DIR
+    # override it). The floors pin that migration rather than leaving it to the resolver: an older
+    # pair would land on plain httpx, a combination retryable_error's transport-error matching is
+    # tested against but the rest of the tree no longer is.
+    "anthropic>=1.0.0",
+    "code-symbol-index>=0.5.1",
+    "json-repair",
+    "fastmcp-slim[client]>=3,<4",
+    "openai>=3.0.0",
+    "pathspec>=1.0",
+    "pillow>=11.0",
+    # 3.0.53 fixed Application.invalidate() so it is safe to call from any thread; older versions
+    # crash with "no running event loop" when the agent thread asks for a redraw.
+    "prompt-toolkit>=3.0.53",
+    "rich>=13.0",
+    "socksio>=1.0.0",
+    "websockets>=15.0.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/hit9/wizolt"
+Repository = "https://github.com/hit9/wizolt"
+Issues = "https://github.com/hit9/wizolt/issues"
+Documentation = "https://wizolt.readthedocs.io"
+
+[project.scripts]
+wizolt = "wizolt.__main__:main"
+
+[project.optional-dependencies]
+dev = [
+    "pyright>=1.1.411",
+    "pytest>=8.0",
+    "pytest-xdist>=3.8",
+    "ruff==0.16.0",
+]
+
+[tool.setuptools]
+packages = ["wizolt", "wizolt.builtin_skills", "wizolt.cli", "wizolt.model", "wizolt.mcp", "wizolt.providers", "wizolt.session", "wizolt.tools", "wizolt.tui"]
+
+[tool.setuptools.package-data]
+wizolt = ["builtin_skills/*/SKILL.md", "providers/catalog.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = ["-n", "auto"]
+
+[tool.ruff]
+line-length = 160
+target-version = "py311"
+
+[tool.ruff.lint]
+extend-select = ["F403"]
+per-file-ignores = { "wizolt/__init__.py" = ["F401"] }
+
+[tool.pyright]
+include = ["wizolt"]
+# `uv build` leaves a full copy of the package under build/lib. An editor that analyzes any file in
+# the workspace type-checks that copy as a second definition of every class, so an assignment there
+# reports a mismatch between two same-named types (`ToolRunner* is not assignable to ToolRunner`).
+# `include` alone does not stop it, because the file is analyzed when opened.
+exclude = ["build", "dist", "**/__pycache__", "**/.venv"]
+pythonVersion = "3.11"
+typeCheckingMode = "basic"

wizolt-0.37.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wizolt-0.37.0/wizolt/__init__.py

@@ -0,0 +1,5 @@
+"""A terminal coding agent."""
+
+from wizolt.base import __version__
+
+__all__ = ["__version__"]

wizolt-0.37.0/wizolt/__main__.py

@@ -0,0 +1,163 @@
+"""wizolt entry point: command-line argument parsing and dispatch.
+
+Invoked through the ``wizolt`` console script or ``python -m wizolt``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import contextlib
+import os
+import subprocess
+import sys
+import threading
+
+from wizolt.base import ConfigError, UpdateStatus, WizoltError, __version__, configure_logging
+from wizolt.cli import CommandLoop
+from wizolt.cli.update import UpdateChecker
+from wizolt.config import (
+    Config,
+    ConfigFile,
+    RuntimeSettings,
+)
+from wizolt.engine import Agent
+from wizolt.providers.schema import CatalogError
+from wizolt.providers.sync import CatalogRuntime
+from wizolt.render import Theme
+from wizolt.session import Session
+
+
+def run_update() -> int:
+    """Check PyPI for a newer wizolt and upgrade it via the detected package manager."""
+    print(f"wizolt {__version__}")
+    try:
+        latest = UpdateChecker.fetch_latest()
+    except Exception as error:  # noqa: BLE001 - update failures from any network/backend layer are reported uniformly.
+        print(f"Error: could not check the latest version: {error}", file=sys.stderr)
+        return 1
+    if not UpdateStatus(latest=latest).newer_than(__version__):
+        print(f"already up to date ({__version__})")
+        return 0
+    command = UpdateChecker.upgrade_command()
+    print(f"updating {__version__} -> {latest}: {' '.join(command)}")
+    try:
+        return subprocess.call(command)
+    except OSError as error:
+        print(f"Error: could not run the upgrade command: {error}", file=sys.stderr)
+        return 1
+
+
+def warm_provider_sdks() -> None:
+    """Import the provider SDKs off the main thread so the prompt accepts input immediately.
+
+    ModelClient imports them lazily because they cost ~0.8s, which was the whole of the delay
+    before a fresh prompt echoed keystrokes. Loading them here in the background keeps the prompt
+    instant without moving that cost onto the first request: the user's first message takes far
+    longer to type than the import takes to finish.
+
+    Racing this thread against the request path is safe, and deliberately so:
+
+    - CPython locks imports per module (`importlib._bootstrap._ModuleLock`), so a request-path
+      `from openai import OpenAI` that lands mid-warm-up blocks on that module's lock and then
+      reads the finished module from `sys.modules`. It cannot observe a half-initialized module,
+      and both threads therefore bind the same class object.
+    - Per-module locks can deadlock only on an import cycle entered from two threads at once.
+      `anthropic` and `openai` do not import each other, and their shared dependencies form a DAG,
+      so the lock-wait graph has no cycle. `_DeadlockError` detection is the backstop if that ever
+      stops being true.
+    - The thread is a daemon because warming must never delay exit. CPython freezes daemon threads
+      at finalization rather than letting them run against a torn-down import system, so quitting
+      mid-import is silent.
+
+    Verified by stress test: a barrier-synchronized four-way race and repeated immediate-exit runs
+    produce no deadlock, no exception, and no stderr noise.
+    """
+
+    def load() -> None:
+        # Warming is only an optimization, and an uncaught failure here would print a thread
+        # traceback over the live prompt. Any real problem resurfaces on the request path, which
+        # imports the same modules and reports the failure to the user.
+        with contextlib.suppress(Exception):
+            import anthropic  # noqa: F401 - imported for its side effect of populating sys.modules
+            import openai  # noqa: F401
+
+    threading.Thread(target=load, name="sdk-warmup", daemon=True).start()
+
+
+def main(argv: list[str] | None = None) -> int:
+    configure_logging()
+    if sys.platform == "win32":
+        print("Error: wizolt does not support native Windows; use WSL instead.", file=sys.stderr)
+        return 1
+
+    parser = argparse.ArgumentParser(prog="wizolt", epilog="Documentation: https://wizolt.readthedocs.io")
+    parser.add_argument("--config", default=None, help="Path to config TOML")
+    parser.add_argument("--init-config", action="store_true", help="Create a default config file")
+    parser.add_argument("--yolo", action="store_true", help="Skip confirmations for mutating tools")
+    parser.add_argument(
+        "--theme", choices=["auto", "light", "dark"], default="", help="Color theme (defaults to runtime.theme, then auto-detect via COLORFGBG)"
+    )
+    resume = parser.add_mutually_exclusive_group()
+    resume.add_argument(
+        "--resume",
+        default="",
+        nargs="?",
+        const="latest",
+        help='Resume a session by UID, uid prefix, or name, or "latest"/"last" for this project\'s most recent',
+    )
+    resume.add_argument("-c", "--last", "--latest", dest="continue_project", action="store_true", help="Resume the latest session in the current project")
+    parser.add_argument("-v", "--version", action="store_true", help="Show version")
+    parser.add_argument(
+        "command", nargs="?", choices=["update", "upgrade"], default=None, help="Maintenance command: update/upgrade wizolt to the latest version"
+    )
+    args = parser.parse_args(argv)
+    if args.version:
+        print(__version__)
+        return 0
+    if args.command in {"update", "upgrade"}:
+        return run_update()
+    try:
+        if args.init_config:
+            path, created = ConfigFile.init(args.config)
+            print(("Created" if created else "Exists") + " config: " + path)
+            return 0
+        # Switching sessions ends one run and starts the next rather than re-pointing a live
+        # object graph at another Session: everything below is built around one, and this is the
+        # only moment nothing is running. Teardown stays in the `finally` that already does it.
+        resume = args.resume or ("latest" if args.continue_project else "")
+        while True:
+            if resume:
+                data = ConfigFile.load(args.config)
+                catalog = CatalogRuntime(Config.data_dir_from(data))
+                config = Config.from_dict(data, policy=catalog.policy)
+                session = Session.load_snapshot(
+                    resume,
+                    config=config,
+                    settings=RuntimeSettings.from_dict(data, yolo=args.yolo, theme=args.theme),
+                    cwd=os.getcwd(),
+                    catalog=catalog,
+                )
+            else:
+                session = Session.from_config_file(path=args.config, yolo=args.yolo, theme=args.theme)
+            Theme.set_mode(Theme.resolve(session.settings.theme))
+            warm_provider_sdks()
+            command_loop = CommandLoop(Agent(session))
+            try:
+                code = command_loop.run()
+            finally:
+                command_loop.close_background_output()
+                if session.mcp is not None:
+                    session.mcp.close()
+            resume = command_loop.resume_request
+            if not resume:
+                return code
+    except ConfigError as error:
+        print("ConfigError: " + str(error), file=sys.stderr)
+        return 2
+    except (WizoltError, CatalogError) as error:
+        print("Error: " + str(error), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())