imbue-mngr-opencode-usage 0.1.0__tar.gz

imbue_mngr_opencode_usage-0.1.0/.gitignore

@@ -0,0 +1,364 @@
+# Byte-compiled / optimized / DLL files
+**/__pycache__/
+**/*.py[codz]
+**/*$py.class
+
+# macOS Finder metadata
+**/.DS_Store
+
+# C extensions
+**/*.so
+
+# Distribution / packaging
+**/.Python
+**/build/
+**/develop-eggs/
+**/dist/
+**/downloads/
+**/eggs/
+**/.eggs/
+**/lib/
+**/lib64/
+**/parts/
+**/sdist/
+**/var/
+**/wheels/
+**/share/python-wheels/
+**/*.egg-info/
+**/.installed.cfg
+**/*.egg
+**/MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+**/*.manifest
+**/*.spec
+
+# Installer logs
+**/pip-log.txt
+**/pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+**/htmlcov/
+**/.tox/
+**/.nox/
+**/.coverage
+**/.coverage.*
+**/.cache
+**/nosetests.xml
+**/coverage.xml
+**/*.cover
+**/*.py.cover
+**/.hypothesis/
+**/.pytest_cache/
+**/cover/
+
+# Translations
+**/*.mo
+**/*.pot
+
+# Django stuff:
+**/*.log
+**/local_settings.py
+**/db.sqlite3
+**/db.sqlite3-journal
+
+# Flask stuff:
+**/instance/
+**/.webassets-cache
+
+# Scrapy stuff:
+**/.scrapy
+
+# Sphinx documentation
+**/docs/_build/
+
+# PyBuilder
+**/.pybuilder/
+**/target/
+
+# Jupyter Notebook
+**/.ipynb_checkpoints
+
+# IPython
+**/profile_default/
+**/ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+**/.pdm-python
+**/.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+**/.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+**/__pypackages__/
+
+# Celery stuff
+**/celerybeat-schedule
+**/celerybeat.pid
+
+# SageMath parsed files
+**/*.sage.py
+
+# Environments
+**/.env
+**/.envrc
+**/.venv
+**/.venv-*
+**/env/
+**/venv/
+**/ENV/
+**/env.bak/
+**/venv.bak/
+
+# Spyder project settings
+**/.spyderproject
+**/.spyproject
+
+# Rope project settings
+**/.ropeproject
+
+# mkdocs documentation
+**/site
+
+# mypy
+**/.mypy_cache/
+**/.dmypy.json
+**/dmypy.json
+
+# Pyre type checker
+**/.pyre/
+
+# pytype static type analyzer
+**/.pytype/
+
+# Cython debug symbols
+**/cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+**/.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+**/.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+**/.ruff_cache/
+
+# PyPI configuration file
+**/.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+**/.cursorignore
+**/.cursorindexingignore
+
+# Marimo
+**/marimo/_static/
+**/marimo/_lsp/
+**/__marimo__/
+
+# task folders for local custom claude workflow (at any depth, incl. the
+# root-level `dev` project's `dev/_tasks/`, which `*/*/_tasks/` missed)
+**/_tasks/
+**/.sesskey
+
+# Node.js
+**/node_modules/
+
+# Frontend build artifacts
+**/frontend-dist/
+
+# Claude Code local settings (session-specific permissions)
+**/.claude/settings.local.json
+
+# Local Claude settings backup files
+**/.claude/*.bak
+
+# Claude worktress
+**/.claude/worktrees
+
+# Agent definitions deployed by mngr_subagent_proxy at session start
+**/.claude/agents/
+
+# Local mngr settings (not committed)
+**/.mngr/settings.local.toml
+
+# Local working / scratch markdown (not committed)
+**/*.local.md
+
+# Local working / scratch shell scripts (not committed)
+# (covers user notification scripts like scripts/notify_user.local.sh, too)
+**/*.local.sh
+
+# Local-only throwaway scripts (e.g. one-off test harnesses).
+**/scripts/*.local.sh
+
+# Local working / scratch Python + text (not committed; e.g. one-off validation
+# harnesses or probe scripts). Mirrors the *.local.md / *.local.sh convention.
+**/*.local.py
+**/*.local.txt
+
+# Test output files (slow tests, coverage summaries)
+**/.test_output/
+
+# TMR output directories (reports + test outputs)
+**/tmr_*/
+**/tmr-report/
+
+# Active session marker file (used to detect interrupted sessions)
+**/.claude/active
+
+# we stick the image build artifacts here
+**/.mngr/dev/build/
+**/.mngr/dev/secrets/
+
+# Offload caches and local files
+**/.offload/**
+**/test-results
+
+# Minds deploy-time build artifacts.
+# Ignore contents so we can un-ignore the committed `template/` subtree: git
+# won't descend into a fully-ignored directory, so negations must live below
+# the contents pattern rather than below the directory pattern.
+**/.minds/*
+# The template directory is committed: it defines the expected keys for each
+# <service>.sh file, with empty values. `scripts/push_modal_secrets.py` uses
+# it to check that per-env .sh files declare every template key.
+!/.minds/template/
+!/.minds/template/**
+# Vault ACL policies for the minds tiers. The HCL is non-sensitive and is
+# the source of truth for the policies pushed to Vault via
+# `vault policy write <name> .minds/policies/<name>.hcl`.
+!/.minds/policies/
+!/.minds/policies/**
+
+# Autofix session artifacts
+**/.autofix/
+**/.reviewer/logs/
+**/.reviewer/outputs/
+**/.reviewer/settings.local.json
+**/.reviewer/.stop_hook_consecutive_blocks
+**/.reviewer/conversation-issues.jsonl
+**/.reviews/
+
+# Stuck agent tracking (stop hook escape valve)
+**/.claude/blocked_stop_commits
+
+# Scheduled tasks lock file
+**/.claude/scheduled_tasks.lock
+
+# Demo recordings (asciinema .cast, .txt, and scripts)
+**/.demos/
+
+# for git worktrees from other repos
+**/.external_worktrees/
+
+# ignore coverage files generated within subprojects
+**/cov.xml
+
+# ignore demos
+**/recordings
+apps/minds_workspace_server/package-lock.json
+**/*.local.md
+
+# Generated by the _generate-dockerignore justfile recipe before each
+# test-offload* run. The recipe strips this self-reference so offload's
+# copy_untracked_files ships the generated file into the build context.
+/.dockerignore
+
+# Transient offload image-cache marker written by test-offload runs; not
+# checked in (unlike the committed .offload-*-cache-key files which pin CI
+# image versions).
+/.offload-image-cache
+
+# Generated by _generate-release-dockerfile from Dockerfile + .release.extras.
+/libs/mngr/imbue/mngr/resources/Dockerfile.release
+**/.reviewer/autofix/issues/
+.reviewer/logs/
+
+# Tailwind Play CDN JS for the minds desktop client. Fetched once via
+# `just minds-tailwind` (plain curl, no build) and shipped with the
+# distributable. Not checked in because it's a ~300KB blob we can always
+# re-fetch.
+/apps/minds/imbue/minds/desktop_client/static/tailwind.js
+
+# macOS Finder metadata
+**/.DS_Store
+**/.env.swp
+# Vim swap files for any file (`.foo.swp`, `.foo.swo`, etc.) -- generated
+# while a file is open in vim. Never checked in.
+**/.*.sw[a-p]
+
+# `minds env deploy` writes a recover-target file at the monorepo root
+# on failed deploys; `minds env recover` deletes it after rolling back.
+# Never checked in. Per-env naming
+# (``.minds-deploy-recover-target-<env-name>.json``) means each in-flight
+# deploy has its own file, so concurrent deploys against different envs
+# don't trip over each other.
+**/.minds-deploy-*.json
+# Per-env deploy lock files (kernel-level ``flock`` targets). Created
+# by ``hold_deploy_lock`` in ``apps/minds/imbue/minds/envs/recover.py``
+# and held for the entire duration of ``minds env deploy`` /
+# ``minds env recover`` so two concurrent invocations against the same
+# env serialize. The file itself is empty and cheap to leave around.
+**/.minds-deploy-lock-*.lock
+**/.antigravitycli/
+
+# Playwright MCP scratch artifacts (mock screenshots, page snapshots)
+**/.playwright-mcp/
+
+# tmr (task-runner) orchestration scratch report
+**/tmr-report/

imbue_mngr_opencode_usage-0.1.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog - mngr_opencode_usage
+
+A concise, human-friendly summary of changes for the `mngr_opencode_usage` library. Entries are categorized using the [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) categories: Added, Changed, Deprecated, Removed, Fixed, Security.
+
+For the full, unedited changelog entries, see [UNABRIDGED_CHANGELOG.md](UNABRIDGED_CHANGELOG.md).
+
+## [Unreleased]
+
+## [v0.1.0] - 2026-06-16
+
+### Added
+
+- Added: New package `imbue-mngr-opencode-usage` providing cost/usage tracking for opencode agents in `mngr usage`. Installs a second in-process opencode plugin (alongside the lifecycle one) that appends one `cost_snapshot` event per assistant message (opencode's reported per-message cost, plus tokens and the provider-qualified model) to `events/opencode/usage/events.jsonl`. A reader hookimpl claims the `opencode` source and aggregates session-incrementally. After provisioning, an opencode agent's spend shows up in `mngr usage` like Claude's.

imbue_mngr_opencode_usage-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: imbue-mngr-opencode-usage
+Version: 0.1.0
+Summary: OpenCode usage data provider for `mngr usage` (per-agent in-process plugin that captures per-message cost + tokens)
+Requires-Python: >=3.12
+Requires-Dist: imbue-mngr-opencode==0.2.16
+Requires-Dist: imbue-mngr-usage==0.1.5
+Requires-Dist: imbue-mngr==0.2.16
+Description-Content-Type: text/markdown
+
+# imbue-mngr-opencode-usage
+
+OpenCode data provider for `mngr usage`. Single responsibility: install a second
+in-process TypeScript plugin into each OpenCode agent so each assistant message
+appends one event to `$MNGR_AGENT_STATE_DIR/events/opencode/usage/events.jsonl`.
+The `mngr usage` CLI walks those events files itself (see `imbue-mngr-usage`).
+
+## How the pieces fit
+
+```
+mngr_opencode_usage's on_after_provisioning hookimpl
+  └─→ installs <config_dir>/plugin/mngr_opencode_usage_plugin.ts
+        (alongside mngr_opencode's lifecycle plugin; OpenCode auto-loads plugin/*.ts)
+
+OpenCode serve process, on each assistant message.updated
+  └─→ mngr_opencode_usage_plugin.ts
+        └─→ events/opencode/usage/events.jsonl (append one cost_snapshot event)
+
+mngr usage
+  └─→ aggregate_usage_source hookimpl (claims the "opencode" source)
+        └─→ aggregate_session_incremental: sum each session's messages
+```
+
+All file I/O goes through `host.write_text_file`, so provisioning works for local
+**and** remote agents.
+
+## What gets captured
+
+OpenCode computes cost and tokens per message and exposes them on each assistant
+`message.updated` event. The writer emits, per message, a self-contained event
+carrying:
+
+- `cost.total_cost_usd` -- OpenCode's own per-message cost (provenance is
+  **REPORTED**; no estimation needed).
+- `tokens` -- `{input, output, cache_read, cache_creation}` (reasoning folded
+  into output), for auditability.
+- `model` -- the provider-qualified `<providerID>/<modelID>`.
+- `session_id` + `message_id` -- the reader sums per session, keeping the freshest
+  event per `message_id` so a streaming message's re-fires collapse to its final
+  reading.
+
+## Why session-incremental
+
+OpenCode reports each message's **own** cost, not a session running total. So the
+writer is stateless -- it appends one self-contained event per message and keeps
+nothing in memory. The reader (`aggregate_session_incremental`) recomputes each
+session's total from the append-only log, which makes it robust across
+`mngr stop`/`start` (a fresh serve process with empty memory loses no history).
+
+`cost_mode` is `API_KEY`: OpenCode bills against a real provider key, so the cost
+is real spend, never an imputed subscription value.

imbue_mngr_opencode_usage-0.1.0/README.md

@@ -0,0 +1,51 @@
+# imbue-mngr-opencode-usage
+
+OpenCode data provider for `mngr usage`. Single responsibility: install a second
+in-process TypeScript plugin into each OpenCode agent so each assistant message
+appends one event to `$MNGR_AGENT_STATE_DIR/events/opencode/usage/events.jsonl`.
+The `mngr usage` CLI walks those events files itself (see `imbue-mngr-usage`).
+
+## How the pieces fit
+
+```
+mngr_opencode_usage's on_after_provisioning hookimpl
+  └─→ installs <config_dir>/plugin/mngr_opencode_usage_plugin.ts
+        (alongside mngr_opencode's lifecycle plugin; OpenCode auto-loads plugin/*.ts)
+
+OpenCode serve process, on each assistant message.updated
+  └─→ mngr_opencode_usage_plugin.ts
+        └─→ events/opencode/usage/events.jsonl (append one cost_snapshot event)
+
+mngr usage
+  └─→ aggregate_usage_source hookimpl (claims the "opencode" source)
+        └─→ aggregate_session_incremental: sum each session's messages
+```
+
+All file I/O goes through `host.write_text_file`, so provisioning works for local
+**and** remote agents.
+
+## What gets captured
+
+OpenCode computes cost and tokens per message and exposes them on each assistant
+`message.updated` event. The writer emits, per message, a self-contained event
+carrying:
+
+- `cost.total_cost_usd` -- OpenCode's own per-message cost (provenance is
+  **REPORTED**; no estimation needed).
+- `tokens` -- `{input, output, cache_read, cache_creation}` (reasoning folded
+  into output), for auditability.
+- `model` -- the provider-qualified `<providerID>/<modelID>`.
+- `session_id` + `message_id` -- the reader sums per session, keeping the freshest
+  event per `message_id` so a streaming message's re-fires collapse to its final
+  reading.
+
+## Why session-incremental
+
+OpenCode reports each message's **own** cost, not a session running total. So the
+writer is stateless -- it appends one self-contained event per message and keeps
+nothing in memory. The reader (`aggregate_session_incremental`) recomputes each
+session's total from the append-only log, which makes it robust across
+`mngr stop`/`start` (a fresh serve process with empty memory loses no history).
+
+`cost_mode` is `API_KEY`: OpenCode bills against a real provider key, so the cost
+is real spend, never an imputed subscription value.

imbue_mngr_opencode_usage-0.1.0/UNABRIDGED_CHANGELOG.md

@@ -0,0 +1,13 @@
+# Unabridged Changelog - mngr_opencode_usage
+
+Full, unedited changelog entries consolidated nightly from individual files in `libs/mngr_opencode_usage/changelog/`.
+
+For a concise summary, see [CHANGELOG.md](CHANGELOG.md).
+
+## 2026-06-16
+
+Corrected the package version back to 0.1.0 (it had been bumped to 0.1.1, but that version was never actually released).
+
+## 2026-06-16
+
+New package `imbue-mngr-opencode-usage`: cost/usage tracking for OpenCode agents in `mngr usage`. It installs a second in-process OpenCode plugin (alongside the lifecycle one) that appends one `cost_snapshot` event per assistant message -- OpenCode's own per-message cost (reported, not estimated) plus tokens and the provider-qualified model -- to `events/opencode/usage/events.jsonl`. A reader hookimpl claims the `opencode` source and aggregates it with the session-incremental strategy (sum each session's messages). After provisioning an OpenCode agent, its spend now shows up in `mngr usage` like Claude's.

imbue_mngr_opencode_usage-0.1.0/conftest.py

@@ -0,0 +1,7 @@
+"""Project-level conftest for mngr_opencode_usage."""
+
+from imbue.imbue_common.conftest_hooks import register_conftest_hooks
+from imbue.mngr.utils.logging import suppress_warnings
+
+suppress_warnings()
+register_conftest_hooks(globals())

imbue_mngr_opencode_usage-0.1.0/imbue/mngr_opencode_usage/aggregate_usage_source_test.py

@@ -0,0 +1,56 @@
+"""Unit tests for the OpenCode ``aggregate_usage_source`` reader hookimpl."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from imbue.mngr_opencode_usage.plugin import aggregate_usage_source
+from imbue.mngr_usage.api import parse_usage_events
+from imbue.mngr_usage.data_types import CostMode
+from imbue.mngr_usage.data_types import CostProvenance
+
+_NOW = 2_800_000_000
+_SINCE = 10**12
+
+
+def _message_event(session_id: str, message_id: str, second: int, total_cost_usd: float) -> dict[str, Any]:
+    return {
+        "timestamp": f"2056-01-01T00:00:{second:02d}.000000000Z",
+        "session_id": session_id,
+        "message_id": message_id,
+        "event_id": f"evt-{message_id}-{second}",
+        "cost": {"total_cost_usd": total_cost_usd},
+    }
+
+
+def test_opencode_hookimpl_sums_per_message_as_reported() -> None:
+    snapshot = aggregate_usage_source(
+        source_name="opencode",
+        agents_events={
+            "agent-1": parse_usage_events(
+                [
+                    _message_event("s1", "m1", 1, 0.10),
+                    _message_event("s1", "m2", 2, 0.25),
+                ],
+                "opencode",
+            )
+        },
+        since_seconds=_SINCE,
+        now=_NOW,
+    )
+    assert snapshot is not None
+    assert snapshot.source_name == "opencode"
+    record = snapshot.sessions[0]
+    assert record.cost.total_cost_usd == 0.35
+    assert record.cost_provenance == CostProvenance.REPORTED
+    assert record.cost_mode == CostMode.API_KEY
+
+
+def test_opencode_hookimpl_declines_non_opencode_sources() -> None:
+    snapshot = aggregate_usage_source(
+        source_name="claude",
+        agents_events={"agent-1": parse_usage_events([_message_event("s1", "m1", 1, 0.10)], "claude")},
+        since_seconds=_SINCE,
+        now=_NOW,
+    )
+    assert snapshot is None

imbue_mngr_opencode_usage-0.1.0/imbue/mngr_opencode_usage/conftest.py

@@ -0,0 +1,3 @@
+from imbue.mngr.utils.plugin_testing import register_plugin_test_fixtures
+
+register_plugin_test_fixtures(globals())

imbue_mngr_opencode_usage-0.1.0/imbue/mngr_opencode_usage/cross_boundary_test.py

@@ -0,0 +1,21 @@
+"""Guard the TS-writer <-> Python-reader source-name seam.
+
+The writer (`.ts`) and the reader (`plugin.py`) agree on the source name only by
+hand-synced string literals across the language boundary. A rename on one side
+would silently disable usage tracking, so pin the invariant here.
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+
+from imbue.mngr_opencode_usage import resources as _resources
+from imbue.mngr_opencode_usage.plugin import _OPENCODE_USAGE_SOURCE_NAME
+from imbue.mngr_opencode_usage.plugin import _USAGE_PLUGIN_FILENAME
+
+
+def test_writer_ts_emits_the_source_the_reader_claims() -> None:
+    writer_ts = importlib.resources.files(_resources).joinpath(_USAGE_PLUGIN_FILENAME).read_text()
+    # The writer emits `source: "<name>/usage"`; the reader strips "/usage" and
+    # claims "<name>". Assert the writer's literal matches the reader's constant.
+    assert f'"{_OPENCODE_USAGE_SOURCE_NAME}/usage"' in writer_ts