octomate 0.0.2__tar.gz

octomate-0.0.2/.dockerignore

@@ -0,0 +1,11 @@
+.venv/
+__pycache__/
+*.py[cod]
+**/node_modules/
+web/dist/
+.git/
+.github/
+.vscode/
+.octomate/
+.env
+/octomate.yaml

octomate-0.0.2/.github/checks/changed.py

@@ -0,0 +1,25 @@
+"""Check changed Python files without adding unrelated repository cleanup to a PR."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+base = sys.argv[1]
+command = (
+    ["git", "ls-files", "-z"]
+    if not base.strip("0")
+    else ["git", "diff", "--name-only", "--diff-filter=ACMR", "-z", base, "HEAD"]
+)
+paths = [
+    path
+    for path in subprocess.check_output(command).decode().split("\0")
+    if path.endswith(".py") and Path(path).is_file()
+]
+if paths:
+    subprocess.run(["uvx", "ruff==0.16.4", "check", *paths], check=True)
+    subprocess.run(["uvx", "ruff==0.16.4", "format", "--check", *paths], check=True)
+    subprocess.run(
+        ["uvx", "pyright==1.1.409", "--pythonpath", sys.executable, *paths], check=True
+    )
+else:
+    print("No changed Python files.")

octomate-0.0.2/.github/checks/distributions.py

@@ -0,0 +1,116 @@
+"""Rebuild source distributions and exercise wheels in isolated installations."""
+
+import subprocess
+import sys
+import tempfile
+import tomllib
+from email import message_from_bytes
+from pathlib import Path
+from zipfile import ZipFile
+
+from packaging.requirements import Requirement
+
+root = Path(__file__).resolve().parents[2]
+dist = root / "dist"
+projects = [
+    tomllib.loads((root / path / "pyproject.toml").read_text())["project"]
+    for path in (".", "cli", "protocol")
+]
+versions = {project["name"]: project["version"] for project in projects}
+assert len(list(dist.glob("*.whl"))) == 3
+assert len(list(dist.glob("*.tar.gz"))) == 3
+for wheel in dist.glob("*.whl"):
+    with ZipFile(wheel) as archive:
+        metadata_file = next(
+            name for name in archive.namelist() if name.endswith("/METADATA")
+        )
+        metadata = message_from_bytes(archive.read(metadata_file))
+        assert metadata["Version"] == versions[metadata["Name"]], wheel
+        dependencies = {
+            dependency.name: dependency
+            for value in metadata.get_all("Requires-Dist", [])
+            if (dependency := Requirement(value)).name in versions
+        }
+        expected = {
+            "octomate": {"octomate-cli", "octomate-protocol"},
+            "octomate-cli": {"octomate-protocol"},
+            "octomate-protocol": set(),
+        }
+        assert dependencies.keys() == expected[metadata["Name"]], wheel
+        for name, dependency in dependencies.items():
+            assert versions[name] in dependency.specifier, (wheel, dependency)
+            assert all(spec.operator != "==" for spec in dependency.specifier)
+        if metadata["Name"] == "octomate":
+            assert "octomate/app.py" in archive.namelist()
+            assert "octomate/migrations/alembic.ini" in archive.namelist()
+            assert any(
+                name.startswith("octomate/migrations/versions/")
+                for name in archive.namelist()
+            )
+
+with tempfile.TemporaryDirectory(prefix="octomate-distributions-") as temporary:
+    directory = Path(temporary)
+    constraints = directory / "constraints.txt"
+    subprocess.run(
+        [
+            "uv",
+            "export",
+            "--locked",
+            "--no-dev",
+            "--no-emit-workspace",
+            "--no-hashes",
+            "--output-file",
+            str(constraints),
+        ],
+        cwd=root,
+        check=True,
+        stdout=subprocess.DEVNULL,
+    )
+    for source in sorted(dist.glob("*.tar.gz")):
+        subprocess.run(
+            [
+                "uv",
+                "build",
+                "--wheel",
+                "--no-sources",
+                "--out-dir",
+                str(directory / "rebuilt"),
+                str(source),
+            ],
+            cwd=directory,
+            check=True,
+        )
+    for mode in ("client", "server"):
+        environment = directory / mode
+        subprocess.run(
+            ["uv", "venv", "--python", sys.executable, str(environment)],
+            cwd=directory,
+            check=True,
+        )
+        python = environment / "bin" / "python"
+        subprocess.run(
+            [
+                "uv",
+                "pip",
+                "install",
+                "--python",
+                str(python),
+                "--constraint",
+                str(constraints),
+                *[
+                    str(wheel)
+                    for wheel in sorted(dist.glob("*.whl"))
+                    if mode == "server" or not wheel.name.startswith("octomate-")
+                ],
+            ],
+            cwd=directory,
+            check=True,
+        )
+        subprocess.run(
+            [str(python), "-I", str(root / ".github/checks/installed.py"), mode],
+            cwd=directory,
+            check=True,
+        )
+print(
+    "Verified 3 wheels, 3 source distributions, and isolated client/server installations."
+)

octomate-0.0.2/.github/checks/installed.py

@@ -0,0 +1,96 @@
+"""Exercise an installed CLI or server without loading a source checkout."""
+
+import importlib.util
+import os
+import socket
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from octomate_protocol import deployment, stream
+
+assert "octomate_cli" not in sys.modules
+assert "octomate" not in sys.modules
+assert deployment.DatabaseBackup.__module__ == "octomate_protocol.deployment"
+assert stream.STREAM_PROTOCOL >= 1
+executable = Path(sys.executable).parent / "octomate"
+for command in (["--version"], ["--help"], ["serve", "--help"], ["upgrade", "--help"]):
+    subprocess.run([str(executable), *command], check=True, stdout=subprocess.DEVNULL)
+
+if sys.argv[1] == "client":
+    for package in ("octomate", "fastapi", "uvicorn", "alembic", "sqlalchemy"):
+        assert importlib.util.find_spec(package) is None, package
+    from octomate_cli.streaming import deepseek, files
+
+    assert "site-packages" in str(files.__file__)
+    assert "site-packages" in str(deepseek.__file__)
+    print("Client installation imports both transports without server dependencies.")
+else:
+    with tempfile.TemporaryDirectory(prefix="octomate-installed-") as temporary:
+        directory = Path(temporary).resolve()
+        config = directory / "config"
+        config.mkdir()
+        (config / "users.yaml").write_text(
+            "users:\n  tester:\n    secret: release-check\n"
+        )
+        database = directory / "test.sqlite3"
+        with socket.socket() as listener:
+            listener.bind(("127.0.0.1", 0))
+            port = listener.getsockname()[1]
+        environment = {
+            key: value
+            for key, value in os.environ.items()
+            if not key.startswith(("OCTOMATE", "PYTHONPATH"))
+        }
+        environment.update(
+            {
+                "OCTOMATE_HOME": str(config),
+                "OCTOMATE_DB_URL": f"sqlite+aiosqlite:///{database}",
+                "OCTOMATE__PORT": str(port),
+            }
+        )
+        command = [sys.executable, "-I", "-m", "octomate.deployment"]
+        backup = subprocess.check_output(
+            [*command, "backup"], cwd=directory, env=environment, text=True
+        )
+        resolved = deployment.DatabaseBackup.model_validate_json(backup)
+        assert resolved.database == database
+        assert resolved.backup is None
+        assert database.parent == directory
+        assert not database.exists()
+        subprocess.run(
+            [*command, "migrate"],
+            cwd=directory,
+            env=environment,
+            input=backup,
+            text=True,
+            check=True,
+        )
+        assert database.is_file()
+        with (directory / "server.log").open("w+") as log:
+            server = subprocess.Popen(
+                [str(executable), "serve"],
+                cwd=directory,
+                env=environment,
+                stdout=log,
+                stderr=log,
+            )
+            try:
+                subprocess.run(
+                    [*command, "verify"], cwd=directory, env=environment, check=True
+                )
+            except subprocess.CalledProcessError:
+                log.seek(0)
+                print(log.read())
+                raise
+            finally:
+                server.terminate()
+                try:
+                    server.wait(timeout=15)
+                except subprocess.TimeoutExpired:
+                    server.kill()
+                    server.wait()
+        print(
+            "Installed server started, migrated a disposable database, and passed authenticated MCP verification."
+        )

octomate-0.0.2/.github/workflows/checks.yml

@@ -0,0 +1,87 @@
+name: Checks
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    branches: [main]
+  workflow_dispatch:
+  workflow_call:
+    inputs:
+      ref:
+        type: string
+        required: true
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    name: Ruff and types
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.sha }}
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v10.0.1
+        with:
+          version: "0.8.13"
+          python-version: "3.12"
+          enable-cache: true
+      - run: uv sync --locked
+      - name: Check changed Python files
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha || github.event.before || 'HEAD^' }}
+        run: uv run --no-sync python .github/checks/changed.py "$BASE_SHA"
+
+  test:
+    name: Unit tests (Python ${{ matrix.python }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.sha }}
+      - uses: astral-sh/setup-uv@v10.0.1
+        with:
+          version: "0.8.13"
+          python-version: ${{ matrix.python }}
+          enable-cache: true
+      - run: uv sync --locked
+      - name: Run unit tests
+        run: uv run --no-sync pytest -q
+
+  packages:
+    name: Packages (Python ${{ matrix.python }})
+    needs: [lint, test]
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.sha }}
+      - uses: astral-sh/setup-uv@v10.0.1
+        with:
+          version: "0.8.13"
+          python-version: ${{ matrix.python }}
+          enable-cache: true
+      - run: uv sync --locked
+      - name: Build all distributions
+        run: uv build --all-packages --no-sources
+      - name: Validate distribution metadata
+        run: uvx twine check dist/*
+      - name: Test installed packages outside the checkout
+        run: uv run --no-sync python .github/checks/distributions.py
+      - uses: actions/upload-artifact@v4
+        if: matrix.python == '3.13'
+        with:
+          name: distributions
+          path: dist/*
+          if-no-files-found: error

octomate-0.0.2/.github/workflows/pr-title.yml

@@ -0,0 +1,16 @@
+name: PR title
+
+on:
+  pull_request:
+    types: [opened, edited, synchronize, reopened]
+
+permissions:
+  pull-requests: read
+
+jobs:
+  title:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v6
+        env:
+          GITHUB_TOKEN: ${{ github.token }}

octomate-0.0.2/.github/workflows/release.yml

@@ -0,0 +1,120 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+    outputs:
+      created: ${{ steps.release.outputs.releases_created }}
+      packages: ${{ steps.packages.outputs.matrix }}
+      sha: ${{ steps.release.outputs.sha || steps.release.outputs['cli--sha'] || steps.release.outputs['protocol--sha'] }}
+    steps:
+      - uses: googleapis/release-please-action@v4
+        id: release
+        with:
+          token: ${{ secrets.RELEASE_PLEASE_TOKEN }}
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+      - name: Verify releases share the checked commit
+        if: steps.release.outputs.releases_created == 'true'
+        env:
+          SERVER_SHA: ${{ steps.release.outputs.sha }}
+          CLI_SHA: ${{ steps.release.outputs['cli--sha'] }}
+          PROTOCOL_SHA: ${{ steps.release.outputs['protocol--sha'] }}
+        run: |
+          release_sha="${SERVER_SHA:-${CLI_SHA:-$PROTOCOL_SHA}}"
+          for sha in "$SERVER_SHA" "$CLI_SHA" "$PROTOCOL_SHA"; do
+            if [ -n "$sha" ]; then test "$sha" = "$release_sha"; fi
+          done
+      - name: Select released packages
+        id: packages
+        if: steps.release.outputs.releases_created == 'true'
+        env:
+          SERVER_TAG: ${{ steps.release.outputs.tag_name }}
+          CLI_TAG: ${{ steps.release.outputs['cli--tag_name'] }}
+          PROTOCOL_TAG: ${{ steps.release.outputs['protocol--tag_name'] }}
+        run: |
+          matrix=$(jq -cn \
+            --arg server "$SERVER_TAG" --arg cli "$CLI_TAG" --arg protocol "$PROTOCOL_TAG" \
+            '{include: [
+              {package: "protocol", distribution: "octomate_protocol", tag: $protocol},
+              {package: "cli", distribution: "octomate_cli", tag: $cli},
+              {package: "server", distribution: "octomate", tag: $server}
+            ] | map(select(.tag != ""))}')
+          echo "matrix=$matrix" >> "$GITHUB_OUTPUT"
+      - uses: actions/checkout@v4
+        if: steps.release.outputs.prs_created == 'true'
+        with:
+          ref: ${{ fromJSON(steps.release.outputs.pr).headBranchName }}
+          token: ${{ secrets.RELEASE_PLEASE_TOKEN }}
+      - uses: astral-sh/setup-uv@v10.0.1
+        if: steps.release.outputs.prs_created == 'true'
+        with:
+          version: "0.8.13"
+      - name: Synchronize the release PR lockfile
+        if: steps.release.outputs.prs_created == 'true'
+        run: |
+          uv lock
+          if ! git diff --quiet -- uv.lock; then
+            git config user.name 'github-actions[bot]'
+            git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+            git add uv.lock
+            git commit -m 'chore: sync release lockfile'
+            git push
+          fi
+
+  checks:
+    needs: release
+    if: needs.release.outputs.created == 'true'
+    uses: ./.github/workflows/checks.yml
+    with:
+      ref: ${{ needs.release.outputs.sha }}
+
+  publish:
+    name: Publish ${{ matrix.package }}
+    needs: [release, checks]
+    if: needs.release.outputs.created == 'true'
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJSON(needs.release.outputs.packages) }}
+    environment: pypi-${{ matrix.package }}
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: distributions
+          path: dist
+      - name: Select package distributions
+        env:
+          DISTRIBUTION: ${{ matrix.distribution }}
+        run: |
+          mkdir package
+          mv dist/"$DISTRIBUTION"-* package/
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: package/
+          skip-existing: true
+      - name: Attach package to its release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ matrix.tag }}
+          GH_REPO: ${{ github.repository }}
+        run: gh release upload "$RELEASE_TAG" package/* --clobber

octomate-0.0.2/.gitignore

@@ -0,0 +1,213 @@
+# Virtual environments
+.venv/
+
+# Environments / secrets
+.env
+# Written by `octomate claude mcp install --scope project`; holds the literal bearer.
+/.mcp.json
+# Anchored: a deployment's config home is `.octomate/` below, and an unanchored
+# pattern would also swallow `octomate/config/defaults/octomate.yaml` and
+# `tests/config/octomate.yaml` — both committed, and one of them ships in the wheel.
+# This line covers the pre-config-home file only, and goes with it.
+/octomate.yaml
+
+# Github
+.github/prompts/
+
+# Octomate runtime data and this checkout's config home
+.octomate/
+
+# Agent tooling: local settings, and skills symlinked into a machine's own install
+.claude/
+.codex/
+
+# Tarot card images (download manually, see octotools/tarot/resources/README.md)
+octotools/tarot/resources/*/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+# Anchored: the unanchored form swallowed web/src/lib/ (the console's API layer)
+/lib/
+/lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.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
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# poetry
+poetry.lock
+
+# pdm
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.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
+.idea/
+*.iml
+*.iws
+.idea_modules/
+
+# VS Code — shared editor setup is checked in; tasks are each developer's own.
+.vscode/tasks.json
+*.code-workspace
+.history/
+
+# Sublime Text
+*.sublime-project
+*.sublime-workspace
+
+# Vim
+*.swp
+*.swo
+*~
+
+# Emacs
+*~
+\#*\#
+/.emacs.desktop
+/.emacs.desktop.lock
+*.elc
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+._*
+
+# Windows
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+*.stackdump
+[Dd]esktop.ini
+$RECYCLE.BIN/
+*.lnk
+
+# Linux
+.directory
+.Trash-*
+.nfs*

octomate-0.0.2/.release-please-manifest.json

@@ -0,0 +1,5 @@
+{
+  ".": "0.0.2",
+  "cli": "0.0.2",
+  "protocol": "0.0.2"
+}