yeschef-cli 0.1.0__py3-none-any.whl

yeschef/tools/executor.py

@@ -0,0 +1,296 @@
+"""Worker-side tool execution.
+
+Off by default. An agent gets only the tools its config names, shell commands must match
+an explicit allowlist, and file access is jailed to one root. Everything runs on the
+worker node; the hub never executes anything.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import fnmatch
+import ipaddress
+import os
+import shlex
+import socket
+from dataclasses import dataclass, field
+from pathlib import Path
+from urllib.parse import urlparse
+
+import httpx
+
+from ..models import ToolCall, ToolResult
+
+MAX_OUTPUT_CHARS = 20_000
+
+_POSIX_METACHARACTERS = (";", "&&", "||", "|", "`", "$(", ">", "<", "\n", "&")
+# cmd.exe adds its own chaining and expansion characters; `create_subprocess_shell`
+# uses cmd on Windows, so a worker there must screen for these too.
+_WINDOWS_METACHARACTERS = _POSIX_METACHARACTERS + ("%", "^", "\r")
+
+SHELL_METACHARACTERS = _WINDOWS_METACHARACTERS if os.name == "nt" else _POSIX_METACHARACTERS
+"""Anything that could chain or redirect a second command past the allowlist."""
+
+MAX_REDIRECTS = 3
+
+
+def _reject_internal_url(url: str) -> str | None:
+    """Return a reason to refuse this URL, or None if it looks externally routable."""
+    parsed = urlparse(url)
+    if parsed.scheme not in ("http", "https"):
+        return "url must be http(s)"
+    if not parsed.hostname:
+        return "url has no host"
+    try:
+        infos = socket.getaddrinfo(parsed.hostname, parsed.port or 0, proto=socket.IPPROTO_TCP)
+    except socket.gaierror as exc:
+        return f"could not resolve host: {exc}"
+    for info in infos:
+        address = ipaddress.ip_address(info[4][0])
+        if (
+            address.is_private
+            or address.is_loopback
+            or address.is_link_local
+            or address.is_reserved
+            or address.is_multicast
+            or address.is_unspecified
+        ):
+            return (
+                f"refusing to fetch an internal address ({address}); web_fetch reaches "
+                "the public internet only"
+            )
+    return None
+
+
+@dataclass(slots=True)
+class ToolsConfig:
+    allow: list[str] = field(default_factory=list)
+    shell_allowlist: list[str] = field(default_factory=list)
+    file_root: str | None = None
+    timeout_s: float = 60.0
+    max_fetch_bytes: int = 2_000_000
+
+    @classmethod
+    def from_dict(cls, raw: dict | None) -> ToolsConfig:
+        raw = raw or {}
+        return cls(
+            allow=list(raw.get("allow") or []),
+            shell_allowlist=list(raw.get("shell_allowlist") or []),
+            file_root=raw.get("file_root"),
+            timeout_s=float(raw.get("timeout_s", 60.0)),
+            max_fetch_bytes=int(raw.get("max_fetch_bytes", 2_000_000)),
+        )
+
+
+SPECS: dict[str, dict] = {
+    "shell": {
+        "name": "shell",
+        "description": "Run an allowlisted shell command on this node and return its output.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"command": {"type": "string", "description": "Command to run"}},
+            "required": ["command"],
+        },
+    },
+    "file_read": {
+        "name": "file_read",
+        "description": "Read a UTF-8 text file from this node's agent workspace.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}},
+            "required": ["path"],
+        },
+    },
+    "file_write": {
+        "name": "file_write",
+        "description": "Write a UTF-8 text file into this node's agent workspace.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
+            "required": ["path", "content"],
+        },
+    },
+    "file_list": {
+        "name": "file_list",
+        "description": "List files under a directory in this node's agent workspace.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"path": {"type": "string", "default": "."}},
+        },
+    },
+    "web_fetch": {
+        "name": "web_fetch",
+        "description": "Fetch a URL and return its body as text.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"url": {"type": "string"}},
+            "required": ["url"],
+        },
+    },
+}
+
+
+class ToolExecutor:
+    def __init__(self, config: ToolsConfig) -> None:
+        self.config = config
+        self.root = Path(config.file_root).expanduser().resolve() if config.file_root else None
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.config.allow)
+
+    def specs(self) -> list[dict]:
+        """Tool schemas for the model, limited to what this agent may use."""
+        return [SPECS[name] for name in self.config.allow if name in SPECS]
+
+    async def run(self, call: ToolCall) -> ToolResult:
+        if call.name not in self.config.allow:
+            return self._error(call, f"tool '{call.name}' is not enabled for this agent")
+        handler = {
+            "shell": self._shell,
+            "file_read": self._file_read,
+            "file_write": self._file_write,
+            "file_list": self._file_list,
+            "web_fetch": self._web_fetch,
+        }.get(call.name)
+        if handler is None:
+            return self._error(call, f"unknown tool '{call.name}'")
+        # `shell` enforces its own deadline so it can kill the child; give the generic
+        # backstop extra room rather than racing it.
+        budget = self.config.timeout_s + (5.0 if call.name == "shell" else 0.0)
+        try:
+            return await asyncio.wait_for(handler(call), timeout=budget)
+        except TimeoutError:
+            return self._error(call, f"tool timed out after {self.config.timeout_s}s")
+        except Exception as exc:  # noqa: BLE001 - surfaced to the model, not swallowed
+            return self._error(call, f"{type(exc).__name__}: {exc}")
+
+    # ------------------------------------------------------------- handlers
+
+    async def _shell(self, call: ToolCall) -> ToolResult:
+        command = str(call.arguments.get("command", "")).strip()
+        if not command:
+            return self._error(call, "command is required")
+        if not self._shell_allowed(command):
+            return self._error(
+                call,
+                f"command not allowed. Allowlist: {self.config.shell_allowlist or '(empty)'}",
+            )
+        proc = await asyncio.create_subprocess_shell(
+            command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            cwd=str(self.root) if self.root else None,
+        )
+        try:
+            stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=self.config.timeout_s)
+        except TimeoutError:
+            # Cancelling the wait leaves the process running; kill it or the node
+            # accumulates an orphan per timed-out call.
+            proc.kill()
+            with contextlib.suppress(Exception):
+                await proc.wait()
+            return self._error(call, f"command timed out after {self.config.timeout_s}s (killed)")
+        text = stdout.decode(errors="replace")[:MAX_OUTPUT_CHARS]
+        return ToolResult(
+            call_id=call.id,
+            name=call.name,
+            content=f"exit={proc.returncode}\n{text}",
+            is_error=proc.returncode != 0,
+        )
+
+    def _shell_allowed(self, command: str) -> bool:
+        """Match against the allowlist without letting a wildcard smuggle in a second command.
+
+        A pattern like `rg *` is meant to allow ripgrep, not `rg x; rm -rf /`, and plain
+        fnmatch matches both. So a command carrying shell metacharacters is only accepted
+        by a pattern that carries one itself — checked **per matching pattern**, because a
+        single deliberate pipeline elsewhere in the list must not re-open chaining for
+        every other entry.
+        """
+        if not self.config.shell_allowlist:
+            return False
+        try:
+            # Windows paths use backslashes that POSIX-mode shlex mangles; validate
+            # parseability in the mode that matches the shell we'll actually invoke.
+            shlex.split(command, posix=(os.name != "nt"))
+        except ValueError:
+            return False
+
+        command_chains = any(token in command for token in SHELL_METACHARACTERS)
+        for pattern in self.config.shell_allowlist:
+            if not fnmatch.fnmatch(command, pattern):
+                continue
+            if command_chains and not any(token in pattern for token in SHELL_METACHARACTERS):
+                continue  # this pattern authorized one command, not a chain
+            return True
+        return False
+
+    def _resolve(self, raw: str) -> Path:
+        if self.root is None:
+            raise ValueError("file tools need [tools] file_root to be set")
+        if raw.startswith("~"):
+            # Treating '~' as a literal filename produced opaque FileNotFoundErrors;
+            # say what is actually possible instead.
+            raise ValueError(
+                f"'~' is not expanded here — your workspace is {self.root}; "
+                "use paths relative to it"
+            )
+        target = (self.root / raw).resolve() if not Path(raw).is_absolute() else Path(raw).resolve()
+        if target != self.root and self.root not in target.parents:
+            raise ValueError(f"path escapes the agent workspace ({self.root})")
+        return target
+
+    async def _file_read(self, call: ToolCall) -> ToolResult:
+        target = self._resolve(str(call.arguments.get("path", "")))
+        text = await asyncio.to_thread(target.read_text, "utf-8")
+        return ToolResult(call.id, call.name, text[:MAX_OUTPUT_CHARS])
+
+    async def _file_write(self, call: ToolCall) -> ToolResult:
+        target = self._resolve(str(call.arguments.get("path", "")))
+        content = str(call.arguments.get("content", ""))
+
+        def _write() -> None:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(content, "utf-8")
+
+        await asyncio.to_thread(_write)
+        return ToolResult(call.id, call.name, f"wrote {len(content)} bytes to {target}")
+
+    async def _file_list(self, call: ToolCall) -> ToolResult:
+        target = self._resolve(str(call.arguments.get("path", ".")))
+        entries = sorted(
+            f"{'d' if p.is_dir() else '-'} {p.relative_to(self.root)}" for p in target.iterdir()
+        )
+        return ToolResult(call.id, call.name, "\n".join(entries)[:MAX_OUTPUT_CHARS] or "(empty)")
+
+    async def _web_fetch(self, call: ToolCall) -> ToolResult:
+        """Fetch a public URL.
+
+        Redirects are followed by hand so every hop is re-checked: otherwise a public URL
+        could bounce the worker into the hub's own API, a node's model server, or a cloud
+        metadata endpoint.
+        """
+        url = str(call.arguments.get("url", ""))
+        async with httpx.AsyncClient(timeout=30.0, follow_redirects=False) as client:
+            for _ in range(MAX_REDIRECTS + 1):
+                problem = _reject_internal_url(url)
+                if problem:
+                    return self._error(call, problem)
+                response = await client.get(url)
+                if response.is_redirect and response.headers.get("location"):
+                    url = str(response.next_request.url) if response.next_request else ""
+                    continue
+                response.raise_for_status()
+                body = b""
+                async for chunk in response.aiter_bytes():
+                    body += chunk
+                    if len(body) >= self.config.max_fetch_bytes:
+                        break
+                text = body[: self.config.max_fetch_bytes].decode(errors="replace")
+                return ToolResult(call.id, call.name, text[:MAX_OUTPUT_CHARS])
+        return self._error(call, "too many redirects")
+
+    def _error(self, call: ToolCall, message: str) -> ToolResult:
+        return ToolResult(call.id, call.name, f"error: {message}", is_error=True)

yeschef_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,254 @@
+Metadata-Version: 2.5
+Name: yeschef-cli
+Version: 0.1.0
+Summary: The farm team for Claude Code and Codex: local models on your own hardware that take the grunt work, return the files they build, and never hit a rate limit
+License: MIT
+License-File: LICENSE
+Keywords: agents,claude-code,local-llm,mcp,ollama,self-hosted,vllm
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115
+Requires-Dist: fastmcp>=2.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: rich>=13.9
+Requires-Dist: typer>=0.15
+Requires-Dist: uvicorn[standard]>=0.32
+Provides-Extra: dev
+Requires-Dist: asgi-lifespan>=2.1; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# 🍳 yeschef
+
+**A kitchen for Claude Code and Codex.** Local models on your own hardware — your line
+of *cooks* — that take the grunt work, talk it out in bounded rooms, and never hit a
+rate limit. You call the order; a cook works the ticket; the plate comes back.
+
+You pay per token and wait out rate limits while the GPUs you already own sit idle.
+yeschef turns them into a line Claude Code can actually run: fire a ticket, keep working,
+check the pass whenever — from any session, days later. You're the chef doing the
+thinking; the kitchen does the reps.
+
+![One prompt in Claude Code: fire a ticket to a local cook, the expediter subagent appears on the rail, and the finished plates come back on their own](docs/claude-demo.gif)
+
+*One prompt, live session: Claude shows the line — every cook's model and machine
+(`grill · ollama/qwen2.5:7b-instruct @ miner`) — fires the buildout, and spawns the
+`yeschef-expediter` subagent, visible in the native panel like any subagent. The session
+comes straight back to you; when the cook finishes, the expediter calls it back on its
+own, plates the files in `./site`, and Claude tastes the cook's work against the spec.
+No hovering, no "is it up yet."*
+
+```
+   Claude Code ──MCP/HTTP──▶ ┌─────────┐ ◀──REST+SSE── cook ──▶ Ollama  (office-mac)
+   (any session,             │   hub   │ ◀──REST+SSE── cook ──▶ vLLM    (gpu-box)
+    any machine)             │ SQLite  │ ◀──REST+SSE── cook ──▶ any /v1 (spare-pc)
+                             │  (pass) │
+                             └─────────┘
+```
+
+|   | Without a kitchen | With one |
+|---|---|---|
+| Grunt work (summarize, classify, extract, triage) | burns your Claude tokens | cooks on your hardware, $0 marginal |
+| Rate-limited or throttled | you wait | the line keeps cooking |
+| Long-running work | blocks the session, dies with it | fired to the background; ticket durable in SQLite, checkable from any session |
+| A second opinion | another API call | two of your machines talk it over in a bounded room while you watch — and cut in |
+
+## Two commands
+
+```bash
+uv tool install yeschef-cli    # or: pipx install yeschef-cli — the command is `yeschef`
+
+# 1. On the hub machine (where you run Claude Code) — generates tokens,
+#    wires Claude Code, prints the clock-in line:
+yeschef up
+
+# 2. On each machine that will cook — auto-detects Ollama / vLLM / LM Studio,
+#    verifies the model answers, clocks the cook in. Paste the line `up` printed:
+yeschef join --hub http://hub-host:8787 --token <printed-by-up>
+```
+
+That's the whole setup. Single-box demo: run both on one machine — `join` needs no flags
+at all. `yeschef doctor` diagnoses anything that's off; `--detach`/`down`/`ps` run it all
+in the background from one terminal. macOS, Linux, and Windows.
+
+`yeschef up` wires **both Claude Code and Codex** if they're installed — Claude Code over
+HTTP MCP, Codex over a stdio bridge (`yeschef mcp-proxy`). Same tools, same kitchen,
+either client.
+
+**Or let Claude Code install it.** This repo is also a Claude Code plugin:
+
+```
+/plugin marketplace add labscommunity/yeschef
+/plugin install yeschef@yeschef
+```
+
+Then say "set up yeschef" (or run `/yeschef:setup`) and Claude installs the CLI, opens
+the kitchen, wires the MCP connection, and hands you the cook clock-in line. The plugin
+also ships the skill and the `yeschef-expediter` subagent automatically.
+
+## What it feels like
+
+From Claude Code (wired automatically by `up`) — you just talk to it: *"fire the log
+triage to a fast cook,"* *"have a cook draft the release notes,"* *"send the buildout to
+the line."* Under the hood:
+
+```
+> list_agents                                     # your line, live
+> submit_task("label these 400 log lines", selector="tier:fast")
+  → ticket_9f3k2p                                 # fires immediately
+> task_status("ticket_9f3k2p")                    # any time, any session
+> task_result("ticket_9f3k2p")
+  → … lifetime: 62 tickets · ~1.2M tokens cooked locally · 9.4h on your hardware
+> start_dialogue(["saucier", "grill"], goal="agree on a cache eviction policy")
+> room_transcript("room_x7c2")                    # watch them work it out
+```
+
+From your terminal:
+
+```bash
+yeschef ask saucier "what's in today's error log?"   # send, wait, print the reply
+yeschef submit "draft release notes from this diff" --to grill
+yeschef dialogue saucier grill --goal "pick a caching strategy"   # follows it live
+yeschef watch room_x7c2 --record demo.json           # save a transcript
+yeschef replay demo.json                             # re-stream it, real pacing
+yeschef stats                                        # what the kitchen has cooked for you
+```
+
+The talking-it-out is the part you have to see: two of your machines, in different
+colors, working a problem — and you can cut into the middle of it. Every room is
+**bounded by construction** (message caps, token budgets, idle timeouts, stop phrases —
+enforced by the hub, not by hoping), so nothing loops forever.
+
+![Two local models plan this exact demo while the human cuts in mid-conversation](docs/demo.gif)
+
+*Real conversation, not a script. Two cooks on one GPU box argue about what this demo
+should show — until the chef cuts in and overrules them both. The transcript ships in
+this repo; after install, watch the identical conversation yourself with
+`yeschef replay docs/demo.json`.*
+
+## Fire a buildout, get the dishes back
+
+Every ticket with a workspace returns what it plates. A cook with file tools writes into
+a per-ticket jail; a cook with the **`cli` backend** hands the whole ticket to a real
+coding agent — the flagship config runs the full Claude Code harness against your own
+local model:
+
+```toml
+[backend]
+type = "cli"
+command = ["claude", "-p", "{prompt}", "--dangerously-skip-permissions"]
+[backend.env]
+ANTHROPIC_BASE_URL = "http://localhost:11434"   # Ollama v0.14+ speaks Anthropic
+```
+
+Deep agentic loop, zero API tokens, and everything it plates ships back through the pass:
+
+```
+> submit_task("build the landing page from DESIGN.md", assignee="line-cook")
+> wait_task("ticket_ab12cd")          # one call/min, returns early when it's up
+> task_files("ticket_ab12cd")         # index.html · css/styles.css
+> task_file("ticket_ab12cd", "index.html")   # pull it, write it into the repo
+```
+
+**See it on the rail (the subagent panel).** `yeschef install-skill` also installs the
+`yeschef-expediter` subagent: spawn it in the background after firing a ticket and the
+cook's job shows up in Claude Code's native panel like any subagent — the expo watches
+it efficiently, plates the returned files into the project, and calls the result back
+when the cook is done.
+
+## Isn't this what Agent Teams does?
+
+Complementary, not competing. Native subagents and teams are Claude-only, same billing,
+same cloud — excellent at parallel *thinking*. A kitchen is the other half:
+**heterogeneous cooks that are free after hardware**, that keep going when you're
+throttled, and whose ticket status outlives any session. Claude Code stays the chef and
+fires the verifiable grunt work down the line.
+
+## What a cook is
+
+`yeschef join` clocks one in from whatever model server it finds. A TOML config (see
+[`examples/agents/`](examples/agents/)) is for pinning a persona, capability tags
+(`tier:fast`, `tier:reasoning` — fire by tag and the first free match takes the ticket),
+or **opt-in tools**: shell (pattern-allowlisted, metacharacter-screened), file access
+(jailed to one directory), web fetch (refuses internal addresses) — always executed on
+the cook's machine, never the hub. Anything embedding the Python SDK
+(`yeschef.sdk.AgentClient`) is a first-class cook too.
+
+**Cloud cooks, too.** A cook is just an OpenAI- or Anthropic-compatible client, so a
+hosted provider works exactly like a local one — `yeschef join` has presets:
+
+```bash
+export OPENROUTER_API_KEY=sk-or-...
+yeschef join --provider openrouter --model meta-llama/llama-3.3-70b-instruct --tier fast
+```
+
+Presets: `openrouter`, `openai`, `groq`, `together`, `deepseek`, `fireworks`; any other
+endpoint works with `--base-url` + `--api-key-env`. Mix cloud and local on one hub and
+fire by tag — send bulk grunt work to a cheap cloud cook, keep the private work on your
+own machines.
+
+## Honesty ledger
+
+What this is, and isn't:
+
+- **Local cooks are slower and weaker than Claude** — often 3–30× slower per token.
+  Firing work out wins on bounded, verifiable jobs (bulk transforms, drafts, triage,
+  second opinions), not on deep reasoning. That's why the design keeps the chef in charge.
+- **Total cost isn't $0.** It's your electricity and your hardware. What it isn't is
+  metered, throttled, or revocable.
+- **A cloud cook (OpenRouter etc.) is the opposite trade** — metered, and your data
+  leaves your network. It's supported and useful (cheap bulk work, models you can't run
+  locally), but it's not the "own your hardware" default. Choose per cook.
+- **No TLS termination** — the hub is designed for LAN/Tailscale (which encrypts
+  transport). Never expose it through a public funnel or port-forward.
+- **Talking-it-out is real model output, not magic.** Small models sometimes say dull
+  things. The `--record`/`replay` pipeline exists so demos are replays of real
+  conversations, not scripts.
+- Windows support is tested in CI logic-paths but has had less real-world mileage than
+  macOS/Linux. Reports welcome.
+
+## Security posture
+
+Auth is on by default (`up` generates tokens; `--open` exists for trusted LANs and says
+so loudly). Cooks hold per-cook bearer tokens; a registered name can't be hijacked
+without its token; reads are scoped to the caller once auth is on; cooks can't
+self-register as privileged kinds; every autonomous room is bounded; cook tools are
+opt-in, allowlisted, and jailed. Full details in [SPEC.md](SPEC.md).
+
+## Running the line
+
+```bash
+yeschef cooks / tasks / task <id> / result <id> / rooms / watch <room> / cancel <id>
+yeschef stats            # lifetime: tickets cooked, tokens cooked locally, hours worked
+yeschef ps / down        # background processes on this machine
+```
+
+A background sweep requeues tickets from lost cooks, times out overruns, archives idle
+rooms, and un-sticks stalled conversations. Persistent-service units for launchd,
+systemd, and Windows are in [`examples/deploy/`](examples/deploy/).
+
+## For the cooks (and Claude)
+
+Claude Code sessions get tool docs automatically over MCP. To teach a session *when* to
+fire work out (not just how), install the bundled skill: `yeschef install-skill` (or
+`--user` for all projects). The full agent-facing guide is [docs/AGENTS.md](docs/AGENTS.md).
+
+## Standing on
+
+yeschef is a client of the local-inference ecosystem, not a fork of it: it talks to
+[Ollama](https://github.com/ollama/ollama) (and the
+[llama.cpp](https://github.com/ggml-org/llama.cpp) engine underneath it),
+[vLLM](https://github.com/vllm-project/vllm), LM Studio, and any OpenAI- or
+Anthropic-compatible endpoint. The MCP server is built on
+[FastMCP](https://github.com/jlowin/fastmcp). Those projects do the hard part.
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"
+uv run pytest              # thread-level race regressions included
+uv run ruff check src tests
+```
+
+MIT. Formerly `farmteam` / `cascadia-tasks` — the old CLI names still work as aliases.

yeschef_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+yeschef/__init__.py,sha256=_FzcQLIPygZgFSLBqnkkdkc_fW2Wq2k6cIfqXrb1KgU,86
+yeschef/__main__.py,sha256=ZsTB2n1AVKtQPYdbiT6mXszWhayaEbpCykwoVNP3nOI,134
+yeschef/cli.py,sha256=STggBHWTL2_NbDnKbaNHzg2uZXxXEV_SncGYi3PfNvc,40970
+yeschef/models.py,sha256=pTef0O7s7nemynn8n9vsvGwN-lrgKLyOgKvIsA3W9DE,12960
+yeschef/procs.py,sha256=mfhJs84bruJjpWhND4TP4X6f2zpYFQweCekMIJ3Lpmg,3242
+yeschef/replay.py,sha256=4M5uHoo4LUMfGHJ8e6kk0uJCX0cH5rB-MHwRRCPaXog,8535
+yeschef/settings.py,sha256=nh44-U-H5sda_ukSi_jUkZlb8s1WYtqIa8sG-9LlOIA,3243
+yeschef/agent/__init__.py,sha256=Lf-ZyY1EhBVz4DmL2zb1F5yllRi3NZU2t5zXcqNo-X8,200
+yeschef/agent/config.py,sha256=yp_HDX5p8_HeDc9vuvbIs0cjKkqok44hF9q4Lj_GsOU,3768
+yeschef/agent/detect.py,sha256=exniaRT7QzjMwTT_wmNpmFcyjMpMSMzNlopYifjybe0,3529
+yeschef/agent/harness.py,sha256=kC6TH1oRy5Pt1ZF4EZRrYR-4lNxgdf-ISBWS4w889pw,47671
+yeschef/agent/backends/__init__.py,sha256=FrItIQzaacHdUqxU0sLP0pn9glkd-kDiFcPgo2J_CZw,1690
+yeschef/agent/backends/anthropic_compat.py,sha256=ILpzc8GNuG84mJqsW_oi_TeJusc-arVJqC3pL9kgbwQ,4094
+yeschef/agent/backends/base.py,sha256=oUOTmhv6PbNen4EvTCPibua_GSycuxT1GG3gx7VFfYU,1214
+yeschef/agent/backends/cli.py,sha256=2YIcBvDhBxAAzq7O3qITkUU52KSHJWJmsDMjzyHBIe0,3580
+yeschef/agent/backends/openai_compat.py,sha256=RS_o_439By--lIa3_k04StRJc2BFcS3L68bbMpEOeIE,4097
+yeschef/hub/__init__.py,sha256=17mFrf-B-RaW6hVf3j0TbYl9lbhAodOraJo6zbIqu4U,364
+yeschef/hub/api.py,sha256=FTyWJA2HvyPcBDOlQ2AhFpyNhIq66vcPsmI7qcV2zdo,22776
+yeschef/hub/app.py,sha256=bUrIFgRlYQ1Fcgy_5upalt_Q7YF1E2KXQ2st2MKo73Y,1184
+yeschef/hub/dashboard.html,sha256=aMzE20sZlg9n4qDCM_rOVrx83b7whXtwzyEO6mgWHjI,10532
+yeschef/hub/events.py,sha256=bEEzk7Sc1Y1NdFmcMBb7XmxNlpRL_Vfy4NzPKt2M_Bg,2952
+yeschef/hub/mcp_server.py,sha256=r38siZ2CTisv3-HX2uAEo40snlgAuti_bpCoaof-vlk,40293
+yeschef/hub/schema.sql,sha256=Afe91MvciRaUt0VJSMfYLi9r9Qi6Pe1mpo_VsBzTgZg,3356
+yeschef/hub/store.py,sha256=k9H8JCCktVJXdcOcmH8vd3ECgAgUWS7Pmu87TXrTEoM,68630
+yeschef/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yeschef/resources/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yeschef/resources/agents/yeschef-expediter.md,sha256=ijVcidF3Vr9cm5LxJL-piMFFuE8St6v3UJ5KngxjEAc,4957
+yeschef/resources/skill/SKILL.md,sha256=4u7CK9dp38VsIIsrfZ-97SaqAoqRuYVIzyLoEu4T30g,13918
+yeschef/resources/skill/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yeschef/sdk/__init__.py,sha256=ZtfcfQjVoqTIHLlJRRsNRs2We_zRRRahYAr7DjQIdqo,325
+yeschef/sdk/client.py,sha256=ZhFkbah6vUlXnz7psMeq8DbcR58tPsBkduwvDFMt_zc,13236
+yeschef/tools/__init__.py,sha256=i7mYSa_6OuNy2el6VT4R8SIVTSvts3CkBTGMlaJcfs8,176
+yeschef/tools/executor.py,sha256=M9WRW-teahdQOjRS7bZGnsUEYYNpFIuRCgKG_Ko2EeE,12043
+yeschef_cli-0.1.0.dist-info/METADATA,sha256=k0iVWWML2N8A9ALrGRzCES7aB2C56kA_9fylB2TG6Kk,12227
+yeschef_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+yeschef_cli-0.1.0.dist-info/entry_points.txt,sha256=JDIbMQTZULDSTnMUXWaxK7aN-GASNPLDLU5qWKhUza4,86
+yeschef_cli-0.1.0.dist-info/licenses/LICENSE,sha256=qCXJLZ3T51pEpmH820VebKUnXAC-PJvDrVRZL5Mjcog,1077
+yeschef_cli-0.1.0.dist-info/RECORD,,

yeschef_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

yeschef_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cascadia-tasks = yeschef.cli:legacy_main
+yeschef = yeschef.cli:main

yeschef_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yeschef contributors
+
+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.