hardhats 0.1.0__tar.gz

hardhats-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vincent Gonzalez / F-Keys Creative LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hardhats-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: hardhats
+Version: 0.1.0
+Summary: hardHats: a framework for crews of agents, each wearing a hat — an LLM instruction or a deterministic gate — run across a federation of free model backends.
+Author: Vincent Gonzalez
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vince-gonzalez/hardhats
+Project-URL: Repository, https://github.com/vince-gonzalez/hardhats
+Keywords: agents,llm,orchestration,multi-model,crew,factory
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# hardHats
+
+**coldHat is for play; hardHats are for work.** hardHats is the framework — the
+factory that makes crews. A crew is a line-up of agents, each **wearing a hat**,
+run across a federation of free model backends.
+
+A **hat** is one of two things:
+- an **LLM hat** — a model wearing an instruction (a role, a method, an output rule), or
+- a **gate hat** — a deterministic function: a real check, a linter, a measurement.
+
+The same engine runs both, so a crew can put an LLM drafter and a deterministic
+verifier on the same line. That is the point: the LLM hats do the judgement, the
+gate hats do the facts, and nobody has to trust a model for something a rule can decide.
+
+## A crew is config, not code
+```python
+from hardhats import Hat, Crew
+
+crew = Crew("grant", [
+    Hat("researcher", model=("groq", "openai/gpt-oss-20b"),
+        instruction="List what a Statement of Need must establish."),
+    Hat("writer", model=("github", "openai/gpt-4o"),
+        instruction="Draft it in a cold, plain register. No AI-tell words."),
+    Hat("critic", gate=slopgate),          # a deterministic gate hat
+])
+
+# pre-flight the crew against a conflict graph before it runs
+conflicts = crew.preflight(load("dataset/prompt-conflicts.json"))
+
+outputs = crew.run("Write a Statement of Need for an accessibility tool.")
+```
+Each hat sees the task and every prior hat's output, down the line.
+
+## The federation
+`hardhats.backends` speaks to one `chat()` over many OpenAI-compatible (and Gemini)
+backends — Gemini, Groq, OpenRouter, Ollama, plus GitHub Models, Cloudflare Workers
+AI, Cerebras, Mistral, NVIDIA NIM, SambaNova and Cohere — each read from the
+environment, keys never printed. Add a key, gain a perspective.
+
+## Crews in the family
+- **a11yhat** — the WCAG accessibility machine, four crew leads as deterministic gate hats.
+- a grant crew, a compliance crew, a prompt-check crew — each a few lines of config.
+
+## Tests
+`python -m unittest discover -s tests` — the engine (pipeline + pre-flight) is
+verified with gate hats only, so it proves out with zero model calls.
+
+## License
+MIT. Copyright Vincent Gonzalez / F-Keys Creative LLC.

hardhats-0.1.0/README.md

@@ -0,0 +1,49 @@
+# hardHats
+
+**coldHat is for play; hardHats are for work.** hardHats is the framework — the
+factory that makes crews. A crew is a line-up of agents, each **wearing a hat**,
+run across a federation of free model backends.
+
+A **hat** is one of two things:
+- an **LLM hat** — a model wearing an instruction (a role, a method, an output rule), or
+- a **gate hat** — a deterministic function: a real check, a linter, a measurement.
+
+The same engine runs both, so a crew can put an LLM drafter and a deterministic
+verifier on the same line. That is the point: the LLM hats do the judgement, the
+gate hats do the facts, and nobody has to trust a model for something a rule can decide.
+
+## A crew is config, not code
+```python
+from hardhats import Hat, Crew
+
+crew = Crew("grant", [
+    Hat("researcher", model=("groq", "openai/gpt-oss-20b"),
+        instruction="List what a Statement of Need must establish."),
+    Hat("writer", model=("github", "openai/gpt-4o"),
+        instruction="Draft it in a cold, plain register. No AI-tell words."),
+    Hat("critic", gate=slopgate),          # a deterministic gate hat
+])
+
+# pre-flight the crew against a conflict graph before it runs
+conflicts = crew.preflight(load("dataset/prompt-conflicts.json"))
+
+outputs = crew.run("Write a Statement of Need for an accessibility tool.")
+```
+Each hat sees the task and every prior hat's output, down the line.
+
+## The federation
+`hardhats.backends` speaks to one `chat()` over many OpenAI-compatible (and Gemini)
+backends — Gemini, Groq, OpenRouter, Ollama, plus GitHub Models, Cloudflare Workers
+AI, Cerebras, Mistral, NVIDIA NIM, SambaNova and Cohere — each read from the
+environment, keys never printed. Add a key, gain a perspective.
+
+## Crews in the family
+- **a11yhat** — the WCAG accessibility machine, four crew leads as deterministic gate hats.
+- a grant crew, a compliance crew, a prompt-check crew — each a few lines of config.
+
+## Tests
+`python -m unittest discover -s tests` — the engine (pipeline + pre-flight) is
+verified with gate hats only, so it proves out with zero model calls.
+
+## License
+MIT. Copyright Vincent Gonzalez / F-Keys Creative LLC.

hardhats-0.1.0/hardhats/__init__.py

@@ -0,0 +1,6 @@
+"""hardHats - the crew framework. coldHat is for play; hardHats are for work."""
+from .backends import BACKENDS, chat
+from .crew import Crew, Hat
+
+__all__ = ["Crew", "Hat", "chat", "BACKENDS"]
+__version__ = "0.1.0"

hardhats-0.1.0/hardhats/backends.py

@@ -0,0 +1,193 @@
+"""
+Multi-backend model caller for the atom-effectiveness study.
+
+One chat() over four free backends: Gemini (native), and Groq, OpenRouter and
+Ollama (all OpenAI-compatible, so one adapter). Keys are read from the
+environment or, failing that, the Windows user settings that `setx` writes to -
+the same fallback the atom pipeline uses - and are NEVER printed. Standard
+library only; nothing is pip-installed into his environment.
+
+A per-backend daily call budget guards each free tier: call budget_left() /
+spend() around real runs so a study can never overrun a free quota.
+
+  python tools/backends.py            # smoke-test connectivity (one tiny call each)
+"""
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+
+# --- keys: environment first, then HKCU\Environment (what setx writes) ---------
+
+
+def read_key(name: str) -> str | None:
+    key = os.environ.get(name)
+    if key:
+        return key
+    try:
+        import winreg
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Environment") as k:
+            return winreg.QueryValueEx(k, name)[0] or None
+    except (ImportError, OSError, FileNotFoundError):
+        return None
+
+
+# --- backend registry ----------------------------------------------------------
+# kind "gemini" uses Google's native API; "openai" uses the chat/completions
+# shape that Groq, OpenRouter and Ollama all speak. Models are candidates: the
+# smoke test reports which resolve, so no name is trusted without a check.
+BACKENDS: dict[str, dict] = {
+    "gemini": {
+        "kind": "gemini", "key_env": "GEMINI_API_KEY",
+        "models": ["gemini-flash-lite-latest", "gemini-3.5-flash"],
+    },
+    "groq": {
+        "kind": "openai", "base": "https://api.groq.com/openai/v1", "key_env": "GROQ_API_KEY",
+        # Live on this account's free tier 2026-10-16. gpt-oss is OpenAI's open model.
+        "models": ["openai/gpt-oss-20b", "openai/gpt-oss-120b"],
+    },
+    "openrouter": {
+        "kind": "openai", "base": "https://openrouter.ai/api/v1", "key_env": "OPENROUTER_API_KEY",
+        # Live :free ids 2026-10-16 (OpenRouter rotates these; refresh from /models).
+        "models": ["google/gemma-4-31b-it:free", "nvidia/nemotron-3-super-120b-a12b:free",
+                   "google/gemma-4-26b-a4b-it:free"],
+    },
+    "ollama": {
+        "kind": "openai", "base": "http://localhost:11434/v1", "key_env": None,
+        "models": ["llama3.2", "qwen2.5"],
+    },
+    # --- additional free perspectives (OpenAI-compatible); add keys to enable ---
+    "github": {  # GitHub Models: free frontier (GPT-4o, Llama) via a GitHub PAT
+        "kind": "openai", "base": "https://models.github.ai/inference", "key_env": "GITHUB_MODELS_TOKEN",
+        "models": ["openai/gpt-4o-mini", "openai/gpt-4o", "meta/Llama-3.3-70B-Instruct"],
+    },
+    "cloudflare": {  # Workers AI; base carries the account id, filled from env
+        "kind": "openai", "base": "https://api.cloudflare.com/client/v4/accounts/{acct}/ai/v1",
+        "key_env": "CLOUDFLARE_API_TOKEN",
+        "models": ["@cf/meta/llama-3.3-70b-instruct-fp8-fast", "@cf/openai/gpt-oss-120b"],
+    },
+    "cerebras": {
+        "kind": "openai", "base": "https://api.cerebras.ai/v1", "key_env": "CEREBRAS_API_KEY",
+        "models": ["llama-3.3-70b", "llama3.1-8b"],
+    },
+    "mistral": {
+        "kind": "openai", "base": "https://api.mistral.ai/v1", "key_env": "MISTRAL_API_KEY",
+        "models": ["mistral-small-latest", "open-mistral-nemo"],
+    },
+    "nvidia": {
+        "kind": "openai", "base": "https://integrate.api.nvidia.com/v1", "key_env": "NVIDIA_API_KEY",
+        "models": ["meta/llama-3.3-70b-instruct", "nvidia/llama-3.1-nemotron-70b-instruct"],
+    },
+    "sambanova": {
+        "kind": "openai", "base": "https://api.sambanova.ai/v1", "key_env": "SAMBANOVA_API_KEY",
+        "models": ["Meta-Llama-3.3-70B-Instruct"],
+    },
+    "cohere": {  # non-commercial free tier - perspective/research only, not paid products
+        "kind": "openai", "base": "https://api.cohere.ai/compatibility/v1", "key_env": "COHERE_API_KEY",
+        "models": ["command-r-plus", "command-r"],
+    },
+}
+
+
+# A real browser User-Agent: Groq (and other Cloudflare-fronted APIs) answer 403
+# "error 1010" to urllib's default agent. This is the same bot-screen seen on the
+# worker's /verify. Sending a normal UA clears it.
+UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+      "(KHTML, like Gecko) Chrome/131.0 Safari/537.36")
+
+
+def _post(url: str, body: bytes, headers: dict, timeout: int = 120) -> dict:
+    headers = {"user-agent": UA, **headers}
+    req = urllib.request.Request(url, data=body, headers=headers)
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return json.load(r)
+
+
+def _openai_chat(base: str, key: str | None, model: str, prompt: str,
+                 temperature: float, max_tokens: int) -> str:
+    headers = {"content-type": "application/json"}
+    if key:
+        headers["authorization"] = f"Bearer {key}"
+    if "openrouter" in base:  # optional attribution headers OpenRouter asks for
+        headers["HTTP-Referer"] = "https://coldhat.f-keys.com"
+        headers["X-Title"] = "coldHat atom study"
+    body = json.dumps({
+        "model": model, "temperature": temperature, "max_tokens": max_tokens,
+        "messages": [{"role": "user", "content": prompt}],
+    }).encode()
+    data = _post(base + "/chat/completions", body, headers)
+    msg = data["choices"][0]["message"]
+    return msg.get("content") or msg.get("reasoning") or ""
+
+
+def _gemini_chat(key: str, model: str, prompt: str,
+                 temperature: float, max_tokens: int) -> str:
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+    body = json.dumps({
+        "contents": [{"role": "user", "parts": [{"text": prompt}]}],
+        "generationConfig": {"temperature": temperature, "maxOutputTokens": max_tokens},
+    }).encode()
+    data = _post(url, body, {"content-type": "application/json", "x-goog-api-key": key})
+    return data["candidates"][0]["content"]["parts"][0]["text"]
+
+
+def chat(backend: str, prompt: str, model: str | None = None,
+         temperature: float = 0.0, max_tokens: int = 700) -> str:
+    """One completion. Falls back across the backend's candidate models on a
+    bad-model error; waits out rate limits. Raises RuntimeError on total failure."""
+    spec = BACKENDS[backend]
+    key = read_key(spec["key_env"]) if spec["key_env"] else None
+    if spec["key_env"] and not key:
+        raise RuntimeError(f"{backend}: {spec['key_env']} is not set")
+    base = spec.get("base", "")
+    if "{acct}" in base:
+        acct = read_key("CLOUDFLARE_ACCOUNT_ID")
+        if not acct:
+            raise RuntimeError(f"{backend}: CLOUDFLARE_ACCOUNT_ID is not set")
+        base = base.replace("{acct}", acct)
+    models = [model] if model else spec["models"]
+    last = ""
+    for m in models:
+        for attempt in range(4):
+            try:
+                if spec["kind"] == "gemini":
+                    return _gemini_chat(key, m, prompt, temperature, max_tokens)
+                return _openai_chat(base, key, m, prompt, temperature, max_tokens)
+            except urllib.error.HTTPError as e:
+                last = f"{backend}/{m} HTTP {e.code}"
+                if e.code in (429, 500, 502, 503) and attempt < 3:
+                    time.sleep(12 * (attempt + 1))
+                    continue
+                break  # 400/401/404 -> try the next candidate model
+            except (KeyError, IndexError, json.JSONDecodeError) as e:
+                last = f"{backend}/{m} unreadable: {e}"
+                break
+            except (TimeoutError, urllib.error.URLError) as e:
+                last = f"{backend}/{m} no answer: {type(e).__name__}"
+                if attempt < 2:
+                    time.sleep(8)
+                    continue
+                break
+    raise RuntimeError(last or f"{backend}: all models failed")
+
+
+def smoke() -> None:
+    """One tiny call per backend; reports which backend/model pair answers."""
+    for name, spec in BACKENDS.items():
+        key_ok = not spec["key_env"] or read_key(spec["key_env"])
+        if not key_ok:
+            print(f"  {name:11} SKIP  ({spec['key_env']} not set)")
+            continue
+        try:
+            t0 = time.time()
+            reply = chat(name, "Reply with exactly: OK", max_tokens=10)
+            dt = time.time() - t0
+            print(f"  {name:11} OK    {dt:4.1f}s  reply={reply.strip()[:30]!r}")
+        except Exception as e:  # noqa: BLE001 - report, don't crash the sweep
+            print(f"  {name:11} FAIL  {e}")
+
+
+if __name__ == "__main__":
+    print("backends smoke test (one call each):")
+    smoke()

hardhats-0.1.0/hardhats/crew.py

@@ -0,0 +1,89 @@
+"""
+hardHats - the crew engine. A crew is config, not code: an ordered list of hats.
+A hat is either an LLM hat (a model wearing an instruction) or a gate hat (a
+deterministic function - a real check, a linter, a measurement). The same engine
+runs both, so a crew can mix an LLM drafter with a deterministic verifier.
+
+  from hardhats import Hat, Crew
+
+  crew = Crew("grant", [
+      Hat("researcher", model=("groq", "openai/gpt-oss-20b"),
+          instruction="List what a Statement of Need must establish."),
+      Hat("writer", model=("groq", "openai/gpt-oss-120b"),
+          instruction="Draft it in a cold, plain register. No AI-tell words."),
+      Hat("critic", gate=my_slopgate_function),   # deterministic hat
+  ])
+  outputs = crew.run("Write a Statement of Need for ...")
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from .backends import chat
+
+
+@dataclass
+class Hat:
+    """A role in the crew. LLM hat: set model + instruction. Gate hat: set gate."""
+    name: str
+    instruction: str = ""
+    model: tuple | None = None          # (backend, model)
+    gate: object = None                 # callable(payload: str) -> str
+    temperature: float = 0.4
+    max_tokens: int = 700
+
+    @property
+    def kind(self) -> str:
+        return "gate" if self.gate else "llm"
+
+    def wear(self, payload: str) -> str:
+        if self.gate:
+            return str(self.gate(payload))
+        if not self.model:
+            raise ValueError(f"hat '{self.name}' has neither a model nor a gate")
+        prompt = f"{self.instruction}\n\n---\n{payload}" if self.instruction else payload
+        return chat(self.model[0], prompt, model=self.model[1],
+                    temperature=self.temperature, max_tokens=self.max_tokens)
+
+
+class Crew:
+    """An ordered pipeline of hats. Each hat sees the task and every prior output."""
+
+    def __init__(self, name: str, hats: list[Hat]):
+        self.name = name
+        self.hats = hats
+
+    def preflight(self, conflicts: list | None = None):
+        """Check the crew's LLM hats for conflicting instructions before they run.
+        `conflicts` is a list of (text_a, text_b, reason); supply the atom conflict
+        graph (dataset/prompt-conflicts.json) to use the measured one."""
+        if not conflicts:
+            return []
+        hats = [h for h in self.hats if h.kind == "llm"]
+
+        def present(atom, text):
+            words = {w for w in re.findall(r"[a-z]{4,}", atom.lower())
+                     if w not in ("output", "section", "list", "only", "nothing", "your", "with")}
+            if not words:
+                return False
+            return sum(1 for w in words if w in text.lower()) >= max(1, len(words) // 2)
+
+        found = []
+        for a, b, reason in conflicts:
+            for i, ha in enumerate(hats):
+                for hb in hats[i + 1:]:
+                    if present(a, ha.instruction) and present(b, hb.instruction):
+                        found.append((ha.name, hb.name, reason))
+        return found
+
+    def run(self, task: str, log=print) -> dict:
+        context = f"Task: {task}"
+        outputs: dict[str, str] = {}
+        for hat in self.hats:
+            if log:
+                log(f"[{hat.name}] ({hat.kind}) ...")
+            out = hat.wear(context).strip()
+            outputs[hat.name] = out
+            context += f"\n\n{hat.name} produced:\n{out}"
+        return outputs

hardhats-0.1.0/hardhats.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: hardhats
+Version: 0.1.0
+Summary: hardHats: a framework for crews of agents, each wearing a hat — an LLM instruction or a deterministic gate — run across a federation of free model backends.
+Author: Vincent Gonzalez
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vince-gonzalez/hardhats
+Project-URL: Repository, https://github.com/vince-gonzalez/hardhats
+Keywords: agents,llm,orchestration,multi-model,crew,factory
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# hardHats
+
+**coldHat is for play; hardHats are for work.** hardHats is the framework — the
+factory that makes crews. A crew is a line-up of agents, each **wearing a hat**,
+run across a federation of free model backends.
+
+A **hat** is one of two things:
+- an **LLM hat** — a model wearing an instruction (a role, a method, an output rule), or
+- a **gate hat** — a deterministic function: a real check, a linter, a measurement.
+
+The same engine runs both, so a crew can put an LLM drafter and a deterministic
+verifier on the same line. That is the point: the LLM hats do the judgement, the
+gate hats do the facts, and nobody has to trust a model for something a rule can decide.
+
+## A crew is config, not code
+```python
+from hardhats import Hat, Crew
+
+crew = Crew("grant", [
+    Hat("researcher", model=("groq", "openai/gpt-oss-20b"),
+        instruction="List what a Statement of Need must establish."),
+    Hat("writer", model=("github", "openai/gpt-4o"),
+        instruction="Draft it in a cold, plain register. No AI-tell words."),
+    Hat("critic", gate=slopgate),          # a deterministic gate hat
+])
+
+# pre-flight the crew against a conflict graph before it runs
+conflicts = crew.preflight(load("dataset/prompt-conflicts.json"))
+
+outputs = crew.run("Write a Statement of Need for an accessibility tool.")
+```
+Each hat sees the task and every prior hat's output, down the line.
+
+## The federation
+`hardhats.backends` speaks to one `chat()` over many OpenAI-compatible (and Gemini)
+backends — Gemini, Groq, OpenRouter, Ollama, plus GitHub Models, Cloudflare Workers
+AI, Cerebras, Mistral, NVIDIA NIM, SambaNova and Cohere — each read from the
+environment, keys never printed. Add a key, gain a perspective.
+
+## Crews in the family
+- **a11yhat** — the WCAG accessibility machine, four crew leads as deterministic gate hats.
+- a grant crew, a compliance crew, a prompt-check crew — each a few lines of config.
+
+## Tests
+`python -m unittest discover -s tests` — the engine (pipeline + pre-flight) is
+verified with gate hats only, so it proves out with zero model calls.
+
+## License
+MIT. Copyright Vincent Gonzalez / F-Keys Creative LLC.

hardhats-0.1.0/hardhats.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+hardhats/__init__.py
+hardhats/backends.py
+hardhats/crew.py
+hardhats.egg-info/PKG-INFO
+hardhats.egg-info/SOURCES.txt
+hardhats.egg-info/dependency_links.txt
+hardhats.egg-info/top_level.txt
+tests/test_crew.py

hardhats-0.1.0/hardhats.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hardhats-0.1.0/hardhats.egg-info/top_level.txt

@@ -0,0 +1 @@
+hardhats

hardhats-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hardhats"
+version = "0.1.0"
+description = "hardHats: a framework for crews of agents, each wearing a hat — an LLM instruction or a deterministic gate — run across a federation of free model backends."
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{ name = "Vincent Gonzalez" }]
+keywords = ["agents", "llm", "orchestration", "multi-model", "crew", "factory"]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Libraries",
+  "Operating System :: OS Independent",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/vince-gonzalez/hardhats"
+Repository = "https://github.com/vince-gonzalez/hardhats"
+
+[tool.setuptools]
+packages = ["hardhats"]

hardhats-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hardhats-0.1.0/tests/test_crew.py

@@ -0,0 +1,63 @@
+"""
+Engine tests for hardHats - gate hats only, so the pipeline and pre-flight are
+verified with zero model calls. LLM hats are exercised separately against the
+live federation.
+
+  python -m unittest discover -s tests
+"""
+import unittest
+
+from hardhats import Crew, Hat
+
+
+class Pipeline(unittest.TestCase):
+    def test_gate_hats_pass_outputs_down_the_line(self):
+        seen = {}
+
+        def upper(payload):
+            seen["upper"] = payload
+            return "A, B, C"
+
+        def count(payload):
+            seen["count"] = payload          # must contain the first hat's output
+            return f"items={payload.count(',') + 1 if ',' in payload else 0}"
+
+        crew = Crew("demo", [
+            Hat("lister", gate=upper),
+            Hat("counter", gate=count),
+        ])
+        out = crew.run("make a list", log=None)
+        self.assertEqual(out["lister"], "A, B, C")
+        self.assertIn("A, B, C", seen["count"], "the counter should see the lister's output")
+        self.assertIn("items=", out["counter"])
+
+    def test_hat_kind(self):
+        self.assertEqual(Hat("g", gate=lambda p: p).kind, "gate")
+        self.assertEqual(Hat("l", model=("groq", "x"), instruction="hi").kind, "llm")
+
+    def test_hat_without_model_or_gate_raises(self):
+        with self.assertRaises(ValueError):
+            Hat("bad").wear("x")
+
+
+class Preflight(unittest.TestCase):
+    def test_detects_conflicting_instructions_across_hats(self):
+        crew = Crew("c", [
+            Hat("a", model=("groq", "x"), instruction="Use a bulleted list for the output."),
+            Hat("b", model=("groq", "x"), instruction="Use a numbered list for the output."),
+        ])
+        conflicts = [("Use a bulleted list", "Use a numbered list", "cannot be both")]
+        found = crew.preflight(conflicts)
+        self.assertTrue(found, "bulleted-vs-numbered hats should be flagged")
+        self.assertEqual(found[0][2], "cannot be both")
+
+    def test_clean_crew_has_no_conflicts(self):
+        crew = Crew("c", [
+            Hat("a", model=("groq", "x"), instruction="Think step by step."),
+            Hat("b", model=("groq", "x"), instruction="Write in a plain register."),
+        ])
+        self.assertEqual(crew.preflight([("Use a bulleted list", "Use a numbered list", "x")]), [])
+
+
+if __name__ == "__main__":
+    unittest.main()