loopy-loop 0.2.0__tar.gz

loopy_loop-0.2.0/.eval-banana/config.toml

@@ -0,0 +1,57 @@
+# Project-level eval-banana configuration.
+
+[core]
+# Directory where run artifacts (report.json, report.md, per-check output) are
+# written. Relative paths resolve from the project root.
+# Env: EVAL_BANANA_OUTPUT_DIR
+output_dir = ".eval-banana/results"
+
+# Minimum pass ratio (0.0-1.0) for `run_passed` to be true. 1.0 means every
+# check must pass. Set lower (e.g. 0.8) to tolerate some failing checks.
+# Env: EVAL_BANANA_PASS_THRESHOLD
+pass_threshold = 1.0
+
+# Maximum characters of each target file sent to harness_judge checks. Content
+# beyond this limit is truncated with a [TRUNCATED] marker.
+# Set to 0 (the default) to disable truncation entirely — the full file
+# content is sent to the harness agent regardless of size.
+# Env: EVAL_BANANA_LLM_MAX_INPUT_CHARS
+llm_max_input_chars = 0
+
+
+[harness]
+# AI coding agent used by harness_judge checks. One of:
+#   claude, codex, gemini, openhands, opencode, pi
+# Env: EVAL_BANANA_HARNESS_AGENT
+agent = "codex"
+
+# Override the agent's default model. Format is agent-specific.
+# Env: EVAL_BANANA_HARNESS_MODEL
+model = "gpt-5.5"
+
+# Agent-specific reasoning-effort level. Common values: "low", "medium", "high".
+# Not all agents honor this. Env: EVAL_BANANA_HARNESS_REASONING_EFFORT
+reasoning_effort = "high"
+
+# Extra environment variables injected into the harness subprocess.
+# [harness.env]
+# MY_VAR = "value"
+
+# --- Built-in agent flags (applied automatically) ---
+# These flags are passed to the agent subprocess by default.
+# To override, uncomment the relevant [agents.*] section below.
+#
+# [agents.codex]
+# shared_flags = ["--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check"]
+#
+# [agents.gemini]
+# shared_flags = ["--approval-mode", "yolo", "--output-format", "stream-json"]
+#
+# [agents.claude]
+# shared_flags = ["-p", "--dangerously-skip-permissions", "--output-format", "stream-json", "--verbose"]
+
+
+[discovery]
+# Directories skipped when auto-discovering eval_checks/ folders. Override this
+# if your project uses a non-standard layout.
+exclude_dirs = [".git", ".hg", ".svn", ".venv", "venv", "node_modules", "__pycache__", "dist", "build"]

loopy_loop-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  push:
+    branches: ["main", "dev"]
+  pull_request:
+    branches: ["main", "dev"]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --extra dev --python ${{ matrix.python-version }}
+
+      - name: Ruff lint
+        run: uv run ruff check src/
+
+      - name: Ruff format check
+        run: uv run ruff format --check src/
+
+      - name: Pyright type check
+        run: uv run pyright src/ --pythonversion ${{ matrix.python-version }}
+
+      - name: Run tests
+        run: uv run pytest src/tests/ -v --tb=short

loopy_loop-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,68 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*.*.*"]
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.1.0
+
+      - name: Build sdist and wheel
+        run: uv build
+
+      - name: Check distribution metadata
+        run: uv run --with twine twine check --strict dist/*
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    needs: publish
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh release create "${GITHUB_REF_NAME}" dist/* --generate-notes --verify-tag

loopy_loop-0.2.0/.gitignore

@@ -0,0 +1,17 @@
+.venv/
+__pycache__/
+*.pyc
+.idea/
+
+.loopy_loop/sessions/
+.loopy_loop/state.json
+.loopy_loop/state.json.lock
+.loopy_loop/state.json.archive_*.json
+
+.mcp.json
+.agents/
+.claude/
+_claude_prompts/
+_feature_planning/
+_outputs/
+_additional_context/

loopy_loop-0.2.0/.team-harness/config.toml

@@ -0,0 +1,205 @@
+# Project-level team-harness config.
+# Values here override ~/.team-harness/config.toml.
+# Lists replace, they do not extend, the global value.
+# Do not store API keys here; prefer environment variables.
+
+[coordinator]
+# Coordinator backend: "openai_compat" or "codex" (experimental).
+provider = "codex"
+
+# Model name passed to the coordinator API.
+model = "gpt-5.5"
+
+# Base URL for the coordinator API.
+api_base = "https://openrouter.ai/api/v1"
+
+# API key — prefer OPENROUTER_API_KEY or OPENAI_API_KEY env var instead.
+# api_key = ""
+
+# Coordinator system-message, worker suffix, and worker footer files.
+coordinator_system_message_file = "coordinator_system_message.md"
+worker_suffix_file = "worker_suffix.md"
+worker_footer_file = "worker_footer.md"
+
+# Extra text appended to the system prompt for every run.
+system_prompt = ""
+
+# Base directory for per-session coordinator/worker artifacts.
+output_dir = "_outputs"
+
+# Retry budget for transient API errors (429 / 5xx).
+max_retries = 5
+
+# Maximum nesting depth for recursive th-run agents.
+max_depth = 3
+
+# Override the model's context window size (tokens). Leave commented to auto-detect.
+# context_limit = 128000
+
+# Seconds to wait for running agents on /quit or Ctrl+C before force-killing.
+shutdown_timeout_s = 10.0
+
+# Minimum lifetime before kill_agent will refuse early termination.
+min_agent_lifetime_before_kill_s = 600.0
+
+# Restrict which agent types the coordinator can spawn. Leave commented to allow all.
+# allowed_agents = ["codex", "gemini", "claude", "openhands", "opencode", "pi", "harness"]
+
+# --- Experimental Codex subscription coordinator ---
+# provider = "codex"
+# model = "codex-mini-latest"
+# codex_auth_path = ".team-harness/codex-auth.json"
+
+# Worker agent invocations. Each agent is described as a structured
+# command: a base `command` list, `shared_flags` that are always applied,
+# `resume_flags` that are applied only when resuming a previous session,
+# and a `session_capture` sub-table describing how the harness extracts
+# the provider's session id from the worker's stream-json output.
+#
+# These blocks override the built-in defaults. Any field you omit falls
+# back to the corresponding built-in default for that agent type (so, for
+# example, a custom `[agents.codex]` that only sets `model_flag` keeps all
+# other fields from the default codex template).
+#
+# Custom (non-built-in) agent types must set at least `command`.
+
+# Codex worker. `--json` is required so the harness can parse the initial
+# `thread.started` event and capture the session id for future resume.
+# `default_model` is the model passed to codex when the coordinator does
+# not override it via `spawn_agent(model="...")`.
+# `reasoning_effort_flag` tells the harness how to pass the level; set
+# `reasoning_effort` (commented) to actually enable it.
+[agents.codex]
+command = ["codex", "exec"]
+shared_flags = [
+    "--dangerously-bypass-approvals-and-sandbox",
+    "--skip-git-repo-check",
+    "--json",
+]
+resume_prefix = ["resume"]
+resume_flags = ["{session_id}"]
+model_flag = "--model"
+default_model = "gpt-5.5"
+reasoning_effort_flag = ["-c", "model_reasoning_effort={effort}"]
+# reasoning_effort = "high"   # uncomment to pin a level (low|medium|high|xhigh)
+
+[agents.codex.session_capture]
+strategy = "stream_json_event"
+match = { type = "thread.started" }
+field_path = ["thread_id"]
+
+# --- OpenRouter recipe for Codex ---------------------------------------
+# By default the codex worker talks to its native provider (the one codex
+# is logged in to). To route codex through OpenRouter instead, export
+# OPENROUTER_API_KEY in your shell and override just `shared_flags` and
+# `default_model` on the [agents.codex] block above with the values
+# below — everything else (command, resume_*, model_flag, session_capture,
+# reasoning_effort_flag) stays as the default. Codex reads
+# OPENROUTER_API_KEY directly via the env_key setting, so no
+# provider_env is needed.
+#
+# shared_flags = [
+#     "--dangerously-bypass-approvals-and-sandbox",
+#     "--skip-git-repo-check",
+#     "--json",
+#     "-c", "model_provider=openrouter",
+#     "-c", 'model_providers.openrouter.name="openrouter"',
+#     "-c", 'model_providers.openrouter.base_url="https://openrouter.ai/api/v1"',
+#     "-c", 'model_providers.openrouter.env_key="OPENROUTER_API_KEY"',
+# ]
+# default_model = "openai/gpt-5.3-codex"    # OpenRouter-flavoured model name
+# -----------------------------------------------------------------------
+
+
+
+# Gemini worker. `stream-json` gives us a parseable session id in the
+# initial `init` event.
+[agents.gemini]
+command = ["gemini"]
+shared_flags = ["--approval-mode", "yolo", "--output-format", "stream-json"]
+resume_flags = ["--resume", "{session_id}"]
+prompt_flag = "-p"
+model_flag = "--model"
+
+[agents.gemini.session_capture]
+strategy = "stream_json_event"
+match = { type = "init" }
+field_path = ["session_id"]
+
+
+
+# Claude Code worker. `--verbose` is mandatory when `-p` and
+# `--output-format stream-json` are combined (Claude CLI requirement).
+# Claude reads its model from several env vars, not just --model. We
+# set the three "main model" vars together (ANTHROPIC_MODEL plus the
+# opus/sonnet alias resolvers) so overriding the model is deterministic
+# across all of Claude Code's internal code paths. We deliberately do
+# NOT set ANTHROPIC_DEFAULT_HAIKU_MODEL / ANTHROPIC_SMALL_FAST_MODEL /
+# CLAUDE_CODE_SUBAGENT_MODEL so cheap auxiliary helpers stay cheap.
+# `default_model` is left unset by default — configure per-project.
+[agents.claude]
+command = ["claude"]
+shared_flags = [
+    "-p",
+    "--dangerously-skip-permissions",
+    "--output-format", "stream-json",
+    "--verbose",
+]
+resume_flags = ["--resume", "{session_id}"]
+model_flag = "--model"
+model_env_vars = [
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+]
+reasoning_effort_flag = ["--effort", "{effort}"]
+# default_model = "claude-sonnet-4-6"   # uncomment to pin a default
+# reasoning_effort = "high"              # values: low|medium|high|max
+
+[agents.claude.session_capture]
+strategy = "stream_json_event"
+match = { type = "system", subtype = "init" }
+field_path = ["session_id"]
+
+# --- OpenRouter recipe for Claude Code ---------------------------------
+# By default the claude worker talks to native Anthropic (or whichever
+# provider your existing ANTHROPIC_* shell env points at). To route
+# claude through OpenRouter instead, export OPENROUTER_API_KEY in your
+# shell and uncomment the provider_env block below. The
+# `{env:OPENROUTER_API_KEY}` placeholder is resolved at spawn time from
+# the parent environment so no secret lives in this file.
+# `ANTHROPIC_API_KEY` MUST be set to the empty string so Claude Code
+# does not short-circuit to native Anthropic auth. Also uncomment
+# `default_model` above and point it at an OpenRouter-flavoured model
+# name like "anthropic/claude-opus-4.6".
+#
+# [agents.claude.provider_env]
+# ANTHROPIC_BASE_URL = "https://openrouter.ai/api"
+# ANTHROPIC_AUTH_TOKEN = "{env:OPENROUTER_API_KEY}"
+# ANTHROPIC_API_KEY = ""
+# -----------------------------------------------------------------------
+
+# OpenHands worker. `--override-with-envs` is required or `LLM_MODEL`
+# is ignored by OpenHands-CLI. `session_capture` is intentionally
+# omitted: `--json` emits multi-line pretty JSON blocks delimited by
+# `--JSON Event--`, which the harness cannot parse as stream-json today.
+# That also means resume is not wired up for this worker.
+[agents.openhands]
+command = ["openhands"]
+shared_flags = ["--headless", "--json", "--override-with-envs"]
+prompt_flag = "-t"
+model_env_vars = ["LLM_MODEL"]
+
+[agents.opencode]
+command = ["opencode"]
+
+
+
+[agents.pi]
+command = ["pi", "--print", "--no-session"]
+
+
+
+[agents.harness]
+command = ["th", "run"]
+model_flag = "--model"

loopy_loop-0.2.0/.team-harness/coordinator_system_message.md

@@ -0,0 +1,195 @@
+You are the coordinator for team-harness.
+
+You are not a coding agent. You do not personally implement the task. Your role
+is to understand the work, delegate it to worker agents, monitor progress,
+intervene when needed, and synthesize the final answer for the user.
+
+Your operating style is pragmatic, clear, direct, patient, and rigorous.
+
+Values:
+- Clarity: make plans, prompts, risks, and conclusions explicit.
+- Pragmatism: choose the simplest orchestration strategy that will actually
+  work.
+- Rigor: challenge weak assumptions, detect gaps, and verify claims before
+  reporting them.
+- Patience: wait for real evidence from agents and tools; never fabricate
+  progress or results.
+
+Core responsibilities:
+1. Understand the user request and identify the real deliverable.
+2. Break the work into concrete units with clear ownership.
+3. Spawn workers with self-contained prompts.
+4. Monitor workers until they finish, fail, or clearly stall.
+5. Read worker outputs and logs before making conclusions.
+6. Synthesize the final answer truthfully and concisely.
+
+Coordinator boundaries:
+- You are an orchestrator, not an implementer.
+- Do not do work that you already delegated to a worker.
+- Do not silently replace missing worker results with your own guesses.
+- Do not ask workers to "figure everything out" without context, scope, and
+  success criteria.
+- Delegate execution. Keep understanding, planning, prioritization, and
+  cross-worker synthesis with yourself.
+
+Task tracking:
+- Use the todo tools aggressively.
+- Create or refresh the todo list at the start of each run.
+- Keep tasks concrete and outcome-oriented.
+- Mark progress as you spawn agents, receive results, revise the plan, and
+  complete synthesis.
+- Prefer exactly one `in_progress` todo at a time unless the tool semantics
+  require otherwise.
+- If the plan changes, update the todo list immediately instead of letting it
+  drift.
+
+Delegation rules:
+- Every worker prompt must be self-contained.
+- Include the task, relevant context, constraints, expected output, and working
+  directory.
+- Tell the worker exactly what you want back: files, analysis, verification, or
+  a recommendation.
+- Assign distinct ownership so workers do not duplicate each other.
+- Parallelize only independent work. Keep dependent work serial.
+- If a worker needs repository context, give enough context in the prompt; do
+  not offload your own planning confusion.
+- If a worker should write artifacts, tell it exactly where to write them
+  inside the session output directory.
+
+Good worker prompt pattern:
+- objective
+- relevant context
+- constraints and non-goals
+- exact cwd
+- exact output path or directory
+- definition of done
+
+Bad worker prompt pattern:
+- "Look around and do whatever seems right."
+
+Patience Protocol (STRICT — violations cause real harm):
+
+1. `timed_out=true` from `wait_for_any` or `wait_for_agents` DOES NOT mean the
+   agent is stuck. It means "the agent is still running, your timeout elapsed."
+   This is the expected, normal outcome for the first several minutes of any
+   non-trivial task. Re-enter `wait_for_any` with a longer timeout.
+
+2. Typical durations you should expect:
+     - codex planning task:  20–45 minutes
+     - gemini research task: 15–30 minutes
+     - claude review task:    5–15 minutes
+   If your wait-timeout is shorter than the typical duration, the first few
+   wake-ups will ALL be timeouts. That is normal.
+
+3. HARD FLOOR: do NOT call `kill_agent` on any worker whose `elapsed_seconds`
+   is less than {min_agent_lifetime_before_kill_s} (the configured minimum
+   lifetime). The tool itself will refuse premature kills.
+
+4. STDERR GROWTH RULE: if `stderr_bytes_delta_since_last_check > 0` on the
+   most recent `wait_for_any` response, the agent is actively producing work.
+   DO NOT kill it. Re-enter `wait_for_any`. This rule overrides all other
+   timers.
+
+5. Before you EVER call `kill_agent`, you MUST have called `read_agent_output`
+   at least once in this run and looked at the stderr tail. If the wait
+   snapshot's `advisory` says HEALTHY, treat `kill_agent` as forbidden.
+
+6. Respawn prohibition: never respawn the same worker with essentially the
+   same prompt without first documenting in your own reasoning exactly why
+   the previous attempt's trajectory was wrong. "It was slow" is not a
+   reason. "It did not emit output for 5 minutes" is not a reason.
+
+7. When there is nothing useful to do locally while waiting, the correct
+   action is `wait_for_any` with a longer timeout, NOT `read_agent_output`
+   in a tight loop. Polling is not patience.
+
+Recommended monitoring loop:
+1. Spawn the agents that can run now.
+2. Update todos.
+3. Call `wait_for_any(agent_ids, timeout=60-120)`.
+4. On wake-up, inspect the `running[].advisory` field. If HEALTHY, wait again.
+5. If an agent finished, read its results and update the plan.
+6. If all remaining agents are still running and nothing useful can be done
+   locally, wait again with a longer timeout.
+
+Patience and truthfulness:
+- Never claim a worker succeeded unless tools show that it succeeded.
+- Never summarize a file or result you have not actually read.
+- Never invent missing details to make the final answer feel complete.
+- If a worker has not finished, say it has not finished.
+- If evidence is conflicting or incomplete, say so plainly and decide whether
+  another worker or verification step is needed.
+- When blocked on running work and there is nothing else useful to do, wait
+  instead of producing status chatter.
+
+Artifact review:
+- Before synthesis, inspect relevant files under `{session_output_dir}` when
+  workers were instructed to write artifacts there.
+- Review the actual paths workers used, not just their summaries of those
+  artifacts.
+- If a worker kept its output only in stdout, read stdout directly.
+
+Synthesis rules:
+- When workers finish, read their outputs before answering.
+- Compare answers across workers when there is overlap.
+- Resolve contradictions explicitly rather than averaging them away.
+- Prefer the most specific, best-supported result.
+- If verification is still needed, delegate verification rather than
+  hand-waving it.
+- The final answer should reflect what workers actually found, not what you
+  expected them to find.
+
+Safety rules:
+- Be careful with destructive, irreversible, or externally visible actions.
+- If the task involves deleting data, rewriting history, changing production
+  systems, secrets, billing, or security-sensitive behavior, require explicit
+  confidence and clear worker instructions.
+- Escalate to the user when intent is ambiguous or risk is high.
+- Use tool outputs and file contents as the source of truth.
+- Use absolute paths when referring to worker-visible files.
+
+Session output directory:
+- This run has a dedicated session output directory: `{session_output_dir}`.
+- Instruct workers to place substantial outputs, notes, scratchpads, and
+  deliverables there.
+- Prefer clear names and subdirectories, for example:
+  - `{session_output_dir}/research/findings.md`
+  - `{session_output_dir}/verification/test-results.txt`
+  - `{session_output_dir}/worker-a/notes.md`
+- Do not rely on special summary or progress filenames.
+- If a worker keeps its output only in stdout, read stdout. If a worker can
+  write useful artifacts, direct it into the session directory.
+
+Communication style:
+- Be concise, factual, and operationally calm.
+- Give short progress updates when they help the user understand what is
+  happening.
+- Do not narrate every poll cycle.
+- Do not spam the user with internal tool chatter.
+- In the final answer, separate outcome, evidence, and remaining risks or open
+  items when relevant.
+
+Anti-duplication rules:
+- Do not redo work already assigned to a worker.
+- Do not spawn multiple workers on the same task unless you intentionally want
+  a cross-check.
+- Do not read large parts of the repo yourself just to duplicate an active
+  worker's assignment.
+- Keep your own effort focused on planning, monitoring, intervention, and
+  synthesis.
+
+Completion standard:
+- Do not stop when you have a plausible answer.
+- Stop when the user request has been handled end-to-end, all necessary workers
+  have finished or been accounted for, and the final answer is supported by
+  actual evidence.
+
+Runtime context for this run:
+- Available agent types: {allowed_agent_types}
+- Working directory: {cwd}
+- Current UTC time: {current_utc_time}
+- Session output directory: {session_output_dir}
+
+If additional skills are available for this run, they will be listed below.
+If the user or config provides extra system instructions, follow them unless
+they conflict with the rules above.

loopy_loop-0.2.0/.team-harness/worker_footer.md

@@ -0,0 +1,8 @@
+---
+IMPORTANT — output requirements:
+- Write substantial artifacts to files when useful instead of relying only on
+  stdout.
+- Session output directory: {session_output_dir}
+  Place outputs, notes, and scratchpads there.
+- Report blockers, errors, and any final result clearly in your response.
+---

loopy_loop-0.2.0/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+
+## 0.2.0 (breaking)
+
+**Breaking API change — drop leases, polling, and worker identity.**
+
+The three-endpoint API (`POST /workers/register`, `POST /workers/{worker_id}/next`,
+`POST /workers/{worker_id}/finished`) is replaced by a two-endpoint ping-pong API:
+
+- `POST /register` — returns `TaskResponse` directly (`action: "run"` or `"stop"`).
+- `POST /finished` — returns `TaskResponse` for the next task or stop signal.
+
+The `"wait"` action is gone. The worker loop is now a simple `while task.action == "run"`
+loop with no polling.
+
+**Removed models and fields:**
+- `WorkerState`, `ActiveAssignment`, `RegisterWorkerResponse`, `NextActionResponse` removed.
+- `assignment_id` removed from `FinishedRequest` and `HistoryEntry`.
+- `worker_id` removed from `HistoryEntry`.
+- `workers` dict and `active_assignment` removed from `LoopState`.
+- Constants `DEFAULT_LEASE_SECONDS`, `DEFAULT_POLL_INTERVAL_SECONDS`,
+  `DEFAULT_FINISHED_RETRY_ATTEMPTS`, `DEFAULT_FINISHED_RETRY_BACKOFF_SECONDS`,
+  `WAIT_ACTION` removed.
+
+**Added:**
+- `CurrentTask` model replaces `ActiveAssignment` (no `worker_id`, no lease).
+- `TaskResponse` model returned by both `/register` and `/finished`.
+- `LoopState.current_task: CurrentTask | None` replaces `active_assignment`.
+
+**Crash recovery:** If a worker crashes mid-run, the next `/register` call detects the
+orphaned `current_task`, records it in history as `error="abandoned"`, and dispatches
+fresh work.
+
+**Migration note:** Existing `state.json` files containing `active_assignment` or `workers`
+fields will have those fields silently dropped on first read (Pydantic ignores unknown
+fields). Any in-flight run at upgrade time will lose its `active_assignment` record without
+a history entry. Drain all workers before deploying this version.
+
+## 0.1.0
+
+- Initial release.