probiotic 0.1.0__tar.gz

probiotic-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.eggs/
+*.lock
+*.log
+.env
+.venv/
+.pytest_cache/

probiotic-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: probiotic
+Version: 0.1.0
+Summary: Autonomous self-improving agent framework for code repositories
+Project-URL: Homepage, https://github.com/penthoy/probiotic
+Project-URL: Repository, https://github.com/penthoy/probiotic
+Project-URL: Issues, https://github.com/penthoy/probiotic/issues
+Keywords: agents,automation,cli,symbiont
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: hive-server
+Requires-Dist: fastapi>=0.110; extra == 'hive-server'
+Requires-Dist: uvicorn>=0.30; extra == 'hive-server'
+Description-Content-Type: text/markdown
+
+# Probiotic
+
+Probiotic is a lightweight runtime for repository-native autonomous agents.
+
+It provides:
+
+- a DNA runtime that installs as a Python package
+- repo-local cells under `symbiont/cells/`
+- a nightly scheduler
+- optional hive reporting and prompt improvement distribution
+
+## Status
+
+This project is currently alpha.
+
+The v2 loop implemented in this repo includes:
+
+- prompt hashing based on shareable prompt text
+- passive approval metrics from local run history
+- hive prompt snapshot storage
+- analyzer-generated prompt patches
+- nightly `apply_updates()` before cell execution
+
+## Install
+
+Until the package is published to PyPI, install it from GitHub or from a built wheel:
+
+```bash
+pip install git+https://github.com/penthoy/probiotic.git
+```
+
+or
+
+```bash
+pip install probiotic-0.1.0-py3-none-any.whl
+```
+
+## CLI
+
+```bash
+probiotic init
+probiotic spawn janitor --template janitor
+probiotic run-nightly
+probiotic connect-hive http://<host>:8000 --api-key <key>
+probiotic update-check
+```
+
+## Development
+
+```bash
+uv sync --extra dev --extra hive-server
+uv run pytest
+uv build
+```

probiotic-0.1.0/README.md

@@ -0,0 +1,54 @@
+# Probiotic
+
+Probiotic is a lightweight runtime for repository-native autonomous agents.
+
+It provides:
+
+- a DNA runtime that installs as a Python package
+- repo-local cells under `symbiont/cells/`
+- a nightly scheduler
+- optional hive reporting and prompt improvement distribution
+
+## Status
+
+This project is currently alpha.
+
+The v2 loop implemented in this repo includes:
+
+- prompt hashing based on shareable prompt text
+- passive approval metrics from local run history
+- hive prompt snapshot storage
+- analyzer-generated prompt patches
+- nightly `apply_updates()` before cell execution
+
+## Install
+
+Until the package is published to PyPI, install it from GitHub or from a built wheel:
+
+```bash
+pip install git+https://github.com/penthoy/probiotic.git
+```
+
+or
+
+```bash
+pip install probiotic-0.1.0-py3-none-any.whl
+```
+
+## CLI
+
+```bash
+probiotic init
+probiotic spawn janitor --template janitor
+probiotic run-nightly
+probiotic connect-hive http://<host>:8000 --api-key <key>
+probiotic update-check
+```
+
+## Development
+
+```bash
+uv sync --extra dev --extra hive-server
+uv run pytest
+uv build
+```

probiotic-0.1.0/hive/__init__.py

@@ -0,0 +1,4 @@
+"""Optional Probiotic hive server package."""
+
+from __future__ import annotations
+

probiotic-0.1.0/hive/analyzer.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from collections import defaultdict
+
+from .models import HiveStore, RunRecord, VerifiedImprovement
+
+
+def _confidence(delta: float, repo_count: int) -> float:
+    return min(0.99, max(0.0, 0.65 + delta + repo_count * 0.05))
+
+
+def find_verified_improvements(
+    records: list[RunRecord],
+    *,
+    prompt_lookup: Callable[[str, str], str | None] | None = None,
+    min_repos: int = 3,
+    min_delta: float = 0.10,
+    min_confidence: float = 0.80,
+) -> list[VerifiedImprovement]:
+    by_hash: dict[str, list[RunRecord]] = defaultdict(list)
+    for record in records:
+        if record.approval_rate_30d is not None:
+            by_hash[record.prompt_hash].append(record)
+
+    improvements: list[VerifiedImprovement] = []
+    for prompt_hash, grouped in by_hash.items():
+        repos = {record.instance_id for record in grouped}
+        if len(repos) < min_repos:
+            continue
+        previous_rates = [
+            float(record.metrics["previous_approval_rate_30d"])
+            for record in grouped
+            if "previous_approval_rate_30d" in record.metrics
+        ]
+        if not previous_rates:
+            continue
+        previous = sum(previous_rates) / len(previous_rates)
+        current = sum(float(record.approval_rate_30d or 0.0) for record in grouped) / len(grouped)
+        delta = current - previous
+        confidence = _confidence(delta, len(repos))
+        if delta >= min_delta and confidence >= min_confidence:
+            sample = grouped[0]
+            patch = prompt_lookup(prompt_hash, sample.agent) if prompt_lookup is not None else ""
+            if prompt_lookup is not None and not patch:
+                continue
+            improvements.append(
+                VerifiedImprovement(
+                    agent_template=sample.agent,
+                    prompt_hash=prompt_hash,
+                    change_type="prompt_patch",
+                    description=f"{sample.agent} prompt correlated with {delta:.0%} approval-rate lift across {len(repos)} repos",
+                    patch=patch,
+                    confidence=confidence,
+                    verified_repos=len(repos),
+                )
+            )
+    return improvements
+
+
+def analyze_and_store(
+    store: HiveStore,
+    *,
+    min_repos: int = 3,
+    min_delta: float = 0.10,
+    min_confidence: float = 0.80,
+) -> list[VerifiedImprovement]:
+    improvements = find_verified_improvements(
+        store.reports(),
+        prompt_lookup=lambda prompt_hash, agent: store.get_prompt_by_hash(prompt_hash, agent=agent),
+        min_repos=min_repos,
+        min_delta=min_delta,
+        min_confidence=min_confidence,
+    )
+    for improvement in improvements:
+        store.save_improvement(improvement)
+    return improvements
+

probiotic-0.1.0/hive/config.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class HiveServerConfig:
+    database_path: Path = Path("hive.sqlite3")
+    api_key: str = ""
+    min_repos: int = 2
+    min_delta: float = 0.10
+    min_confidence: float = 0.80
+
+    @classmethod
+    def from_env(cls) -> "HiveServerConfig":
+        return cls(
+            database_path=Path(os.environ.get("PROBIOTIC_HIVE_DB", "hive.sqlite3")),
+            api_key=os.environ.get("PROBIOTIC_HIVE_API_KEY", ""),
+            min_repos=int(os.environ.get("PROBIOTIC_HIVE_MIN_REPOS", "2")),
+            min_delta=float(os.environ.get("PROBIOTIC_HIVE_MIN_DELTA", "0.10")),
+            min_confidence=float(os.environ.get("PROBIOTIC_HIVE_MIN_CONFIDENCE", "0.80")),
+        )
+

probiotic-0.1.0/hive/distributor.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+
+from .models import HiveStore
+
+
+def updates_for_instance(store: HiveStore, *, instance_id: str) -> dict:
+    return {
+        "improvements": [asdict(improvement) for improvement in store.improvements()],
+        "new_templates": [],
+        "instance_id": instance_id,
+    }
+

probiotic-0.1.0/hive/models.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Instance:
+    instance_id: str
+    repo_name: str
+    last_seen: str
+
+
+@dataclass(frozen=True)
+class RunRecord:
+    instance_id: str
+    repo_name: str
+    agent: str
+    run_date: str
+    outcome: str
+    prompt_hash: str
+    approval_rate_30d: float | None = None
+    metrics: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class VerifiedImprovement:
+    agent_template: str
+    prompt_hash: str
+    change_type: str
+    description: str
+    patch: str
+    confidence: float
+    verified_repos: int
+
+
+@dataclass(frozen=True)
+class PromptSnapshot:
+    prompt_hash: str
+    agent: str
+    content: str
+    first_seen: str
+
+
+class HiveStore:
+    def __init__(self, path: Path | str = "hive.sqlite3") -> None:
+        self.path = Path(path)
+        self.init_db()
+
+    def connect(self) -> sqlite3.Connection:
+        con = sqlite3.connect(str(self.path))
+        con.row_factory = sqlite3.Row
+        return con
+
+    def init_db(self) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.connect() as con:
+            con.execute(
+                """
+                CREATE TABLE IF NOT EXISTS instances (
+                    instance_id TEXT PRIMARY KEY,
+                    repo_name TEXT NOT NULL,
+                    last_seen TEXT NOT NULL
+                )
+                """
+            )
+            con.execute(
+                """
+                CREATE TABLE IF NOT EXISTS run_records (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    instance_id TEXT NOT NULL,
+                    repo_name TEXT NOT NULL,
+                    agent TEXT NOT NULL,
+                    run_date TEXT NOT NULL,
+                    outcome TEXT NOT NULL,
+                    prompt_hash TEXT NOT NULL,
+                    approval_rate_30d REAL,
+                    metrics_json TEXT NOT NULL
+                )
+                """
+            )
+            con.execute(
+                """
+                CREATE TABLE IF NOT EXISTS verified_improvements (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    agent_template TEXT NOT NULL,
+                    prompt_hash TEXT NOT NULL UNIQUE,
+                    change_type TEXT NOT NULL,
+                    description TEXT NOT NULL,
+                    patch TEXT NOT NULL,
+                    confidence REAL NOT NULL,
+                    verified_repos INTEGER NOT NULL
+                )
+                """
+            )
+            con.execute(
+                """
+                CREATE TABLE IF NOT EXISTS prompt_snapshots (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    prompt_hash TEXT NOT NULL,
+                    agent TEXT NOT NULL,
+                    content TEXT NOT NULL,
+                    first_seen TEXT NOT NULL,
+                    UNIQUE(prompt_hash, agent)
+                )
+                """
+            )
+
+    def save_report(self, report: RunRecord) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as con:
+            con.execute(
+                """
+                INSERT INTO instances(instance_id, repo_name, last_seen)
+                VALUES (?, ?, ?)
+                ON CONFLICT(instance_id) DO UPDATE SET repo_name=excluded.repo_name, last_seen=excluded.last_seen
+                """,
+                (report.instance_id, report.repo_name, now),
+            )
+            con.execute(
+                """
+                INSERT INTO run_records(
+                    instance_id, repo_name, agent, run_date, outcome,
+                    prompt_hash, approval_rate_30d, metrics_json
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    report.instance_id,
+                    report.repo_name,
+                    report.agent,
+                    report.run_date,
+                    report.outcome,
+                    report.prompt_hash,
+                    report.approval_rate_30d,
+                    json.dumps(report.metrics),
+                ),
+            )
+
+    def reports(self) -> list[RunRecord]:
+        with self.connect() as con:
+            rows = con.execute("SELECT * FROM run_records ORDER BY id").fetchall()
+        return [
+            RunRecord(
+                instance_id=row["instance_id"],
+                repo_name=row["repo_name"],
+                agent=row["agent"],
+                run_date=row["run_date"],
+                outcome=row["outcome"],
+                prompt_hash=row["prompt_hash"],
+                approval_rate_30d=row["approval_rate_30d"],
+                metrics=json.loads(row["metrics_json"]),
+            )
+            for row in rows
+        ]
+
+    def save_prompt_snapshot(self, *, prompt_hash: str, agent: str, content: str) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as con:
+            con.execute(
+                """
+                INSERT INTO prompt_snapshots(prompt_hash, agent, content, first_seen)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(prompt_hash, agent) DO NOTHING
+                """,
+                (prompt_hash, agent, content, now),
+            )
+
+    def get_prompt_by_hash(self, prompt_hash: str, *, agent: str | None = None) -> str | None:
+        query = "SELECT content FROM prompt_snapshots WHERE prompt_hash = ?"
+        params: list[Any] = [prompt_hash]
+        if agent is not None:
+            query += " AND agent = ?"
+            params.append(agent)
+        query += " ORDER BY first_seen LIMIT 1"
+        with self.connect() as con:
+            row = con.execute(query, params).fetchone()
+        if row is None:
+            return None
+        return str(row["content"])
+
+    def save_improvement(self, improvement: VerifiedImprovement) -> None:
+        with self.connect() as con:
+            con.execute(
+                """
+                INSERT INTO verified_improvements(
+                    agent_template, prompt_hash, change_type, description,
+                    patch, confidence, verified_repos
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(prompt_hash) DO UPDATE SET
+                    agent_template=excluded.agent_template,
+                    change_type=excluded.change_type,
+                    description=excluded.description,
+                    patch=excluded.patch,
+                    confidence=excluded.confidence,
+                    verified_repos=excluded.verified_repos
+                """,
+                (
+                    improvement.agent_template,
+                    improvement.prompt_hash,
+                    improvement.change_type,
+                    improvement.description,
+                    improvement.patch,
+                    improvement.confidence,
+                    improvement.verified_repos,
+                ),
+            )
+
+    def improvements(self) -> list[VerifiedImprovement]:
+        with self.connect() as con:
+            rows = con.execute("SELECT * FROM verified_improvements ORDER BY id").fetchall()
+        return [
+            VerifiedImprovement(
+                agent_template=row["agent_template"],
+                prompt_hash=row["prompt_hash"],
+                change_type=row["change_type"],
+                description=row["description"],
+                patch=row["patch"],
+                confidence=row["confidence"],
+                verified_repos=row["verified_repos"],
+            )
+            for row in rows
+        ]
+

probiotic-0.1.0/hive/registry.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from .models import HiveStore, RunRecord
+
+
+class Registry:
+    def __init__(self, store: HiveStore) -> None:
+        self.store = store
+
+    def record_report(self, report: RunRecord, *, prompt_text: str | None = None) -> dict[str, str]:
+        self.store.save_report(report)
+        if prompt_text and prompt_text.strip():
+            self.store.save_prompt_snapshot(prompt_hash=report.prompt_hash, agent=report.agent, content=prompt_text)
+        return {"status": "ok"}
+

probiotic-0.1.0/hive/server.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Any
+
+from .analyzer import analyze_and_store
+from .config import HiveServerConfig
+from .distributor import updates_for_instance
+from .models import HiveStore, RunRecord
+from .registry import Registry
+
+try:  # pragma: no cover - exercised only when optional dependency is installed
+    from fastapi import Depends, FastAPI, Header, HTTPException
+except ImportError:  # pragma: no cover
+    Depends = FastAPI = Header = HTTPException = None  # type: ignore[assignment]
+
+
+config = HiveServerConfig.from_env()
+store = HiveStore(config.database_path)
+registry = Registry(store)
+
+
+def _require_fastapi() -> None:
+    if FastAPI is None:
+        raise RuntimeError("Install probiotic[hive-server] to run the hive server")
+
+
+def _auth(authorization: str | None = None) -> None:
+    if not config.api_key:
+        return
+    expected = f"Bearer {config.api_key}"
+    if authorization != expected:
+        raise HTTPException(status_code=401, detail="invalid hive API key")
+
+
+def create_app():
+    _require_fastapi()
+    app = FastAPI(title="Probiotic Hive")
+
+    @app.get("/health")
+    def health() -> dict[str, str]:
+        return {"status": "ok"}
+
+    @app.post("/report")
+    def report(payload: dict[str, Any], authorization: str | None = Header(default=None)) -> dict[str, str]:
+        _auth(authorization)
+        record = RunRecord(
+            instance_id=str(payload["instance_id"]),
+            repo_name=str(payload["repo_name"]),
+            agent=str(payload["agent"]),
+            run_date=str(payload["run_date"]),
+            outcome=str(payload["outcome"]),
+            prompt_hash=str(payload["prompt_hash"]),
+            approval_rate_30d=payload.get("approval_rate_30d"),
+            metrics=dict(payload.get("metrics", {})),
+        )
+        result = registry.record_report(record, prompt_text=payload.get("prompt_text"))
+        analyze_and_store(
+            store,
+            min_repos=config.min_repos,
+            min_delta=config.min_delta,
+            min_confidence=config.min_confidence,
+        )
+        return result
+
+    @app.get("/updates")
+    def updates(instance_id: str, since: str | None = None, authorization: str | None = Header(default=None)) -> dict:
+        _auth(authorization)
+        return updates_for_instance(store, instance_id=instance_id)
+
+    @app.post("/analyze")
+    def analyze(authorization: str | None = Header(default=None)) -> dict:
+        _auth(authorization)
+        improvements = analyze_and_store(
+            store,
+            min_repos=config.min_repos,
+            min_delta=config.min_delta,
+            min_confidence=config.min_confidence,
+        )
+        return {"improvements": [asdict(item) for item in improvements]}
+
+    return app
+
+
+app = create_app() if FastAPI is not None else None
+

probiotic-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "probiotic"
+version = "0.1.0"
+description = "Autonomous self-improving agent framework for code repositories"
+requires-python = ">=3.11"
+readme = "README.md"
+keywords = ["agents", "automation", "cli", "symbiont"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/penthoy/probiotic"
+Repository = "https://github.com/penthoy/probiotic"
+Issues = "https://github.com/penthoy/probiotic/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+]
+hive-server = [
+    "fastapi>=0.110",
+    "uvicorn>=0.30",
+]
+
+[project.scripts]
+probiotic = "probiotic.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/probiotic"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

probiotic-0.1.0/src/probiotic/__init__.py

@@ -0,0 +1,6 @@
+"""Probiotic: autonomous symbiont runtime for code repositories."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+