Sync from GitHub (main)

.gitignore

@@ -0,0 +1 @@
+Python

.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 24.4.2
+    hooks:
+      - id: black
+  - repo: https://github.com/PyCQA/isort
+    rev: 5.13.2
+    hooks:
+      - id: isort
+  - repo: https://github.com/pycqa/flake8
+    rev: 7.1.1
+    hooks:
+      - id: flake8

README.md

@@ -0,0 +1,46 @@
+# ProtocolPilot (RUO)
+
+Convert papers/preprints into draft, **research-use-only** lab protocols with a structured schema, auto-generated Bill of Materials (BOM), guardrails, and CI. Designed to pair with async agents (e.g., Open SWE) that open pull requests instead of just chatting.
+
+## Quick start
+
+**Requirements**: Python 3.11+, GitHub repo, (optional) Open SWE + Daytona for async runs.
+
+```bash
+# Clone and set up
+uv venv -p 3.11  # or python -m venv .venv
+source .venv/bin/activate
+pip install -U uv || true
+uv pip install -e .
+pre-commit install
+pytest -q
+```
+
+## Typical flow
+1. Open a GitHub Issue using the "ProtocolPilot task" template and include links to PDFs/DOIs and constraints.
+2. Agent (or you) runs the extractor → planner → programmer → reviewer flow.
+3. A PR adds `protocols/<slug>.md`, `env/conda.yaml` (optional), `tests/` updates, and a BOM JSON/CSV.
+4. You edit, request changes, and merge when satisfied.
+
+## Open SWE integration (labels)
+- Add labels from `labels.json` to your repo.
+- To run **with plan approval**: label an Issue `open-swe`.
+- To run **auto-execute**: label `open-swe-auto` (use sparingly).
+
+## Safety & scope
+- RUO only; no patient data; no diagnostic/treatment claims.
+- PRs include a RUO disclaimer and the guardrails checker blocks unsafe language.
+
+## Commands
+```bash
+# Validate a protocol Markdown against the schema
+python -m protocol_pilot.extract --validate protocols/examples/qPCR.md
+
+# Generate a BOM stub from a protocol (to JSON)
+python -m protocol_pilot.bom protocols/examples/qPCR.md --out bom.json
+```
+
+## Contributing
+- Keep protocol steps numbered, measurable, and source-cited.
+- Prefer SI units and temperatures in °C.
+- Use PRs; auto-merge should remain off.

labels.json

@@ -0,0 +1,16 @@
+{
+  "open-swe": {
+    "color": "0E8A16",
+    "description": "Plan \u2192 human approval \u2192 execute"
+  },
+  "open-swe-auto": {
+    "color": "1F77B4",
+    "description": "Auto-execute when safe"
+  },
+  "protocols": {
+    "color": "5319E7"
+  },
+  "ruo": {
+    "color": "B60205"
+  }
+}

prompts/planner_system.txt

@@ -0,0 +1,7 @@
+You are the Planner in a multi-agent workflow that converts scientific methods into a RUO protocol.
+Constraints:
+- RUO only. No clinical/diagnostic claims. No patient-specific guidance.
+- Produce: title, sources[], reagents[], equipment[], steps[] with measurable actions, safety_notes[], and a bill-of-materials proposal.
+- SI units; temperatures in °C; durations in minutes; explicit ranges.
+- Flag any missing info as TODOs.
+Output: A structured plan that a Programmer can implement into Markdown + JSON.

prompts/reviewer_system.txt

@@ -0,0 +1,7 @@
+You are the Reviewer. Your job is to block unsafe or low-quality outputs before PR.
+Checklist:
+- Contains RUO disclaimer.
+- No diagnostic/treatment language; no PHI.
+- Steps are numbered, measurable, and feasible; units consistent; ranges plausible.
+- BOM has generic + 2 vendor alternatives where possible.
+If any check fails, return a blocking report with line numbers and fix suggestions.

pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "protocol-pilot"
+version = "0.1.0"
+description = "RUO protocol extraction, schema, and tooling"
+readme = "README.md"
+authors = [{name = "ProtocolPilot"}]
+requires-python = ">=3.11"
+dependencies = [
+  "pydantic>=2.7",
+  "markdown-it-py>=3.0",
+  "jsonschema>=4.22",
+  "click>=8.1",
+  "python-slugify>=8.0",
+  "pre-commit>=3.7",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+addopts = "-q"

qPCR.md

@@ -0,0 +1,26 @@
+> Research Use Only (RUO). Not for use in diagnostic procedures or patient care.
+
+# qPCR for gene expression (example template)
+
+**Sources**: DOI:xx.xxxx/xxxx; Preprint: <link>
+
+## Equipment
+- qPCR thermocycler
+- Calibrated micropipettes (P10, P200)
+
+## Reagents (example)
+- SYBR Green Master Mix — 1x final
+- Forward primer (10 µM); Reverse primer (10 µM)
+- cDNA template
+
+## Steps
+1. Thaw reagents on ice (≈10 min). Mix by gentle inversion.
+2. Prepare master mix (per 20 µL reaction): 10 µL SYBR mix; 0.8 µL fwd primer; 0.8 µL rev primer; x µL template; nuclease-free water to 20 µL.
+3. Plate reactions; seal; brief spin.
+4. Thermocycler program: 95 °C 2 min; 40 cycles of [95 °C 15 s, 60 °C 60 s]; melt curve.
+
+## Safety notes
+- Wear PPE; handle reagents per SDS.
+
+## Bill of Materials (example)
+- SYBR mix (generic), Alt1: Vendor A cat#..., Alt2: Vendor B cat#...

ruodisclaimer.txt

@@ -0,0 +1 @@
+Research Use Only (RUO). Not for use in diagnostic procedures or patient care. Outputs are drafts for expert review; you are responsible for validation and safety.

src/protocol_pilot/__init__.py

@@ -0,0 +1,5 @@
+__all__ = [
+    "Protocol", "Step", "Reagent",
+    "validate_protocol",
+]
+from .schema import Protocol, Step, Reagent, validate_protocol

src/protocol_pilot/bom.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+import json
+import click
+from pathlib import Path
+from slugify import slugify
+from .extract import parse_markdown
+
+DEFAULT_ALTS = [
+    {"vendor": "Vendor A", "catalog_number": "TBD"},
+    {"vendor": "Vendor B", "catalog_number": "TBD"},
+]
+
+@click.command()
+@click.argument("protocol_md", type=click.Path(exists=True))
+@click.option("--out", "out_path", type=click.Path(), help="Output JSON file")
+def main(protocol_md, out_path):
+    proto = parse_markdown(Path(protocol_md).read_text(encoding="utf-8"))
+    items = []
+    for r in proto.reagents:
+        items.append({
+            "name": r.name,
+            "amount": r.amount,
+            "unit": r.unit,
+            "alternatives": DEFAULT_ALTS,
+        })
+    payload = {"protocol": slugify(proto.title), "items": items}
+    if out_path:
+        Path(out_path).write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    else:
+        print(json.dumps(payload, indent=2))
+
+if __name__ == "__main__":
+    main()

src/protocol_pilot/extract.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+import re
+import json
+import click
+from pathlib import Path
+from markdown_it import MarkdownIt
+from .schema import Protocol, Step, Reagent, validate_protocol
+
+md = MarkdownIt()
+
+RUO_PREFIX = "Research Use Only (RUO)."
+
+def parse_markdown(md_text: str) -> Protocol:
+    # Very light parser for the example template
+    title_match = re.search(r"^#\s+(.+)$", md_text, re.M)
+    title = title_match.group(1).strip() if title_match else "Untitled Protocol"
+
+    sources = re.findall(r"^\*\*Sources\*\*:([^\n]+)$", md_text, re.M)
+    sources = [s.strip() for s in ",".join(sources).split(",") if s.strip()] or []
+
+    equipment_section = re.search(r"## Equipment\n([\s\S]*?)\n##", md_text)
+    equipment = []
+    if equipment_section:
+        equipment = [l.strip("- ") for l in equipment_section.group(1).splitlines() if l.strip().startswith("-")]
+
+    reagents_section = re.search(r"## Reagents[\s\S]*?\n([\s\S]*?)\n##", md_text)
+    reagents = []
+    if reagents_section:
+        for l in reagents_section.group(1).splitlines():
+            if l.strip().startswith("-"):
+                name = l.strip("- ").strip()
+                reagents.append(Reagent(name=name))
+
+    # Steps
+    steps = []
+    for i, m in enumerate(re.finditer(r"^\d+\.\s+(.+)$", md_text, re.M), start=1):
+        steps.append(Step(number=i, description=m.group(1).strip()))
+
+    # Safety
+    safety = []
+    safety_sec = re.search(r"## Safety notes\n([\s\S]*?)\n##|$", md_text)
+    if safety_sec:
+        for l in safety_sec.group(1).splitlines():
+            if l.strip().startswith("-"):
+                safety.append(l.strip("- ").strip())
+
+    disclaimer = "Research Use Only (RUO). Not for use in diagnostic procedures or patient care."
+
+    return Protocol(
+        title=title,
+        sources=sources,
+        equipment=equipment,
+        reagents=reagents,
+        steps=steps,
+        safety_notes=safety,
+        ruo_disclaimer=disclaimer,
+    )
+
+@click.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--validate", "do_validate", is_flag=True, help="Validate after parsing")
+@click.option("--json-out", "json_out", is_flag=True, help="Print JSON to stdout")
+def main(path, do_validate, json_out):
+    text = Path(path).read_text(encoding="utf-8")
+    proto = parse_markdown(text)
+    if do_validate:
+        validate_protocol(proto)
+    if json_out:
+        click.echo(proto.model_dump_json(indent=2))
+
+if __name__ == "__main__":
+    main()

src/protocol_pilot/guards.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+import re
+
+BANNED_PATTERNS = [
+    r"diagnos(e|is|tic)",
+    r"treat(ment|ing)?",
+    r"patient\-specific",
+    r"clinical decision",
+]
+
+def contains_banned_language(text: str) -> bool:
+    text_low = text.lower()
+    return any(re.search(p, text_low) for p in BANNED_PATTERNS)

src/protocol_pilot/schema.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from typing import List, Optional
+from pydantic import BaseModel, Field, ValidationError, model_validator
+
+class Reagent(BaseModel):
+    name: str
+    amount: Optional[float] = Field(default=None, description="Numeric amount if known")
+    unit: Optional[str] = Field(default=None, description="Unit for amount, e.g., µL, mg, mM")
+    vendor: Optional[str] = None
+    catalog_number: Optional[str] = None
+
+class Step(BaseModel):
+    number: int
+    description: str
+    duration_minutes: Optional[float] = None
+    temperature_c: Optional[float] = None
+    hazards: List[str] = []
+
+class Protocol(BaseModel):
+    title: str
+    sources: List[str]
+    equipment: List[str] = []
+    reagents: List[Reagent] = []
+    steps: List[Step]
+    safety_notes: List[str] = []
+    ruo_disclaimer: str
+
+    @model_validator(mode="after")
+    def check_steps_sequential(self):
+        nums = [s.number for s in self.steps]
+        if nums != list(range(1, len(nums) + 1)):
+            raise ValueError("Steps must be sequential starting at 1")
+        return self
+
+def validate_protocol(proto: Protocol) -> None:
+    """Raises ValidationError if invalid."""
+    if not proto.ruo_disclaimer.lower().startswith("research use only"):
+        raise ValidationError([{"loc":("ruo_disclaimer",), "msg":"Missing RUO disclaimer"}], Protocol)

tests/test_schema.py

@@ -0,0 +1,26 @@
+from protocol_pilot.schema import Protocol, Step, Reagent, validate_protocol
+
+def test_minimal_protocol_valid():
+    p = Protocol(
+        title="Example",
+        sources=["DOI:10.0000/example"],
+        equipment=["pipette"],
+        reagents=[Reagent(name="water")],
+        steps=[Step(number=1, description="Do a thing.")],
+        safety_notes=["Wear PPE"],
+        ruo_disclaimer="Research Use Only (RUO). Not for use in diagnostic procedures or patient care.",
+    )
+    validate_protocol(p)  # should not raise
+
+def test_steps_must_be_sequential():
+    try:
+        Protocol(
+            title="Bad",
+            sources=["x"],
+            steps=[Step(number=2, description="oops")],
+            ruo_disclaimer="Research Use Only (RUO).",
+        )
+    except Exception:
+        assert True
+    else:
+        assert False, "Expected an error for non-sequential steps"