chad-code 1.0.5__tar.gz → 1.0.6__tar.gz

{chad_code-1.0.5 → chad_code-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chad-code
-Version: 1.0.5
+Version: 1.0.6
 Summary: Local MLX-backed, Claude-Code-style coding agent (Apple Silicon, Ornith 35B/9B)
 License-Expression: MIT
 Project-URL: Repository, https://github.com/nathansutton/chad
@@ -21,7 +21,7 @@ Requires-Dist: mlx<0.33,>=0.32.0; sys_platform == "darwin"
 Requires-Dist: mlx-lm<0.32,>=0.31.3; sys_platform == "darwin"
 Requires-Dist: transformers<5.13,>=5.0
 Requires-Dist: jinja2>=3.1
-Requires-Dist: numpy<2,>=1.26
+Requires-Dist: numpy<3,>=1.26
 Requires-Dist: huggingface-hub>=1.22.0
 Requires-Dist: jedi>=0.19.2
 Requires-Dist: prompt_toolkit>=3.0.43
@@ -33,6 +33,8 @@ Provides-Extra: highlight
 Requires-Dist: pygments>=2.17; extra == "highlight"
 Provides-Extra: lsp
 Requires-Dist: serena-agent>=1.5; extra == "lsp"
+Provides-Extra: speech
+Requires-Dist: sounddevice>=0.5; extra == "speech"
 Dynamic: license-file
 
 # chad — a local, MLX-backed coding agent
@@ -81,10 +83,12 @@ instrument:
 | **Harness**     | open-ended, anything you can imagine            | plan. execute. nothing else.    |
 | **When wrong**  | reasons a way out                               | already shipped                 |
 
-![chad fixing a failing test end to end — reason, read, edit, rerun pytest, all on a local 35B](docs/demo.gif)
+![chad fixing a failing test end to end — reason, read, edit, run pytest, confirm green, all on a local 35B](docs/demo.gif)
 
-> Real session, unedited (cold model load cut): a local 35B reasons through the failure,
-> edits the file, reruns the tests, confirms green.
+> Real session, unedited (the silent prefill is cut): a local 35B finds the cent that
+> floor division loses, fixes it, and verifies itself — then your own `pytest`, in your
+> own shell. Recorded with `--yolo` so nothing pauses for a keypress; the default mode
+> stops and asks before every edit and every command.
 
 ## Frontier scores, laptop cost
 
@@ -171,7 +175,10 @@ it chad uses the tree-sitter fallback automatically.
 `uv run chad` launches a full-screen terminal UI (built on prompt_toolkit):
 
 - **shift-tab cycles permission modes** — `normal` (confirm each bash/write/edit) →
-  `auto-accept edits` → `plan mode` (read-only: investigate + propose a numbered plan) → back.
+  `auto-accept edits` (edits land silently; **terminal commands still ask**) → `yolo`
+  (nothing asks) → `plan mode` (read-only: investigate + propose a numbered plan) → back.
+- **the approval prompt shows what you're approving** — the full command on its own lines
+  above the input, not a clipped single line. Approving blind isn't approving.
 - **type-ahead message queue** — keep typing while the agent works; messages run in order.
 - **ctrl-c interrupts the running turn** without killing the session.
 - **live status line** — model, mode, context %, a state glyph + verb, elapsed seconds, and
@@ -181,6 +188,14 @@ it chad uses the tree-sitter fallback automatically.
   `/model`, `/mode`, `/help`, `/exit`. Same set in the `--repl` line interface.
 - **`@file` / `@dir` mentions** and **`!command` shell passthrough** — pull a file into
   context inline, or run a shell command without invoking the model.
+- **voice mode, all local** — `/speech`, then ctrl-t to talk: Parakeet-on-MLX transcribes
+  into the input box for you to review before Enter sends it (esc discards a take);
+  replies are read aloud via macOS `say`. A pre-roll buffer means your first syllable
+  isn't clipped, and a personal word table (`~/.chad/speech_words.json`) teaches it your
+  identifiers — `{"pie test": "pytest"}`. Dictation cost is linear in take length, so a
+  long thought is fine; `/speech` off releases both the mic and the weights. Nothing
+  leaves the machine. Needs the `speech` extra (`uv sync --extra speech` — just a mic
+  library; no torch, no numba).
 
 **Usage.** `uv run chad --help` is the source of truth:
 

{chad_code-1.0.5 → chad_code-1.0.6}/README.md

@@ -44,10 +44,12 @@ instrument:
 | **Harness**     | open-ended, anything you can imagine            | plan. execute. nothing else.    |
 | **When wrong**  | reasons a way out                               | already shipped                 |
 
-![chad fixing a failing test end to end — reason, read, edit, rerun pytest, all on a local 35B](docs/demo.gif)
+![chad fixing a failing test end to end — reason, read, edit, run pytest, confirm green, all on a local 35B](docs/demo.gif)
 
-> Real session, unedited (cold model load cut): a local 35B reasons through the failure,
-> edits the file, reruns the tests, confirms green.
+> Real session, unedited (the silent prefill is cut): a local 35B finds the cent that
+> floor division loses, fixes it, and verifies itself — then your own `pytest`, in your
+> own shell. Recorded with `--yolo` so nothing pauses for a keypress; the default mode
+> stops and asks before every edit and every command.
 
 ## Frontier scores, laptop cost
 
@@ -134,7 +136,10 @@ it chad uses the tree-sitter fallback automatically.
 `uv run chad` launches a full-screen terminal UI (built on prompt_toolkit):
 
 - **shift-tab cycles permission modes** — `normal` (confirm each bash/write/edit) →
-  `auto-accept edits` → `plan mode` (read-only: investigate + propose a numbered plan) → back.
+  `auto-accept edits` (edits land silently; **terminal commands still ask**) → `yolo`
+  (nothing asks) → `plan mode` (read-only: investigate + propose a numbered plan) → back.
+- **the approval prompt shows what you're approving** — the full command on its own lines
+  above the input, not a clipped single line. Approving blind isn't approving.
 - **type-ahead message queue** — keep typing while the agent works; messages run in order.
 - **ctrl-c interrupts the running turn** without killing the session.
 - **live status line** — model, mode, context %, a state glyph + verb, elapsed seconds, and
@@ -144,6 +149,14 @@ it chad uses the tree-sitter fallback automatically.
   `/model`, `/mode`, `/help`, `/exit`. Same set in the `--repl` line interface.
 - **`@file` / `@dir` mentions** and **`!command` shell passthrough** — pull a file into
   context inline, or run a shell command without invoking the model.
+- **voice mode, all local** — `/speech`, then ctrl-t to talk: Parakeet-on-MLX transcribes
+  into the input box for you to review before Enter sends it (esc discards a take);
+  replies are read aloud via macOS `say`. A pre-roll buffer means your first syllable
+  isn't clipped, and a personal word table (`~/.chad/speech_words.json`) teaches it your
+  identifiers — `{"pie test": "pytest"}`. Dictation cost is linear in take length, so a
+  long thought is fine; `/speech` off releases both the mic and the weights. Nothing
+  leaves the machine. Needs the `speech` extra (`uv sync --extra speech` — just a mic
+  library; no torch, no numba).
 
 **Usage.** `uv run chad --help` is the source of truth:
 

{chad_code-1.0.5 → chad_code-1.0.6}/pyproject.toml

@@ -4,7 +4,7 @@
 # import name, and command name are independent. `uvx chad-code` runs the alias
 # script added under [project.scripts].
 name = "chad-code"
-version = "1.0.5"
+version = "1.0.6"
 description = "Local MLX-backed, Claude-Code-style coding agent (Apple Silicon, Ornith 35B/9B)"
 readme = "README.md"
 license = "MIT"
@@ -49,7 +49,10 @@ dependencies = [
     # absent in a clean install (e.g. chad inside a Linux benchmark container), where its
     # absence crashes the first turn. Declare it directly.
     "jinja2>=3.1",
-    "numpy>=1.26,<2",
+    # <3: the old <2 cap was 1.0.0-era caution, not a known break. numpy 2.4.6
+    # verified end-to-end (full gate + live Parakeet-on-MLX transcription +
+    # `chad prove` 4/4); staying open keeps 2.x-floored ASR deps adoptable.
+    "numpy>=1.26,<3",
     "huggingface-hub>=1.22.0", # first-run model download (cli.py/engine.py); imported directly, not just transitively
     "jedi>=0.19.2", # in-process symbolic code intelligence (read/search/edit)
     "prompt_toolkit>=3.0.43",
@@ -78,6 +81,16 @@ highlight = ["pygments>=2.17"]
 # heavyweight tree; absent, every caller falls back to the tree-sitter backend.
 # Install with `uv sync --extra lsp`.
 lsp = ["serena-agent>=1.5"]
+# Voice mode (/speech in the TUI): push-to-talk dictation via chad's vendored
+# Parakeet-on-MLX (src/chad/parakeet — the PyPI parakeet-mlx drags librosa's
+# numba/scipy tree for one mel-filterbank call) + spoken replies via macOS
+# `say`. All on-device, nothing leaves the machine. mlx/numpy/huggingface-hub
+# are already core deps, so the extra adds only the mic (sounddevice/PortAudio).
+# Optional and import-guarded in speech.py: absent, /speech prints the install
+# hint and everything else is untouched. Install with `uv sync --extra speech`.
+speech = [
+    "sounddevice>=0.5",
+]
 
 # The one entrypoint: `uv run chad`. (`chad-bench` reproduces docs/benchmarks.md.)
 # `chad-code` is an alias so `uvx chad-code` (which runs the console script matching
@@ -107,6 +120,10 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 where = ["src"]
 
+# The vendored Parakeet code is Apache-2.0; its license text must travel with
+# the code, wheel included.
+[tool.setuptools.package-data]
+"chad.parakeet" = ["LICENSE"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 # No "-q" here: CI/docs/agents all invoke `pytest -q` explicitly, and stacking the two
@@ -127,6 +144,12 @@ src = ["src", "tests"]
 select = ["F", "E9", "I"]
 ignore = ["E741"]  # ambiguous var names (l/I) appear in existing math code
 
+[tool.ruff.lint.per-file-ignores]
+# Vendored upstream (see chad/parakeet/__init__.py), kept byte-close for
+# future re-syncs — not held to chad's own lint standard. (F401: imports left
+# in place for upstream fidelity after the transcribe(path) cut.)
+"src/chad/parakeet/*" = ["F401", "F821", "F841", "E741"]
+
 [tool.mypy]
 python_version = "3.11"
 files = ["src/chad"]
@@ -142,6 +165,12 @@ disable_error_code = ["var-annotated"]
 # Tighten (disallow_untyped_defs, re-enable var-annotated, add B/UP/SIM in ruff) in a
 # follow-up once this baseline holds.
 
+[[tool.mypy.overrides]]
+# Vendored upstream inference code (see chad/parakeet/__init__.py) is not held
+# to chad's gate so re-syncs stay a plain re-copy.
+module = "chad.parakeet.*"
+ignore_errors = true
+
 [[tool.mypy.overrides]]
 # mlx_fastpath patches mlx_lm classes that only exist on macOS: with mlx installed
 # (dev Macs, the macos CI jobs) its `type: ignore[method-assign]` comments are load-

{chad_code-1.0.5 → chad_code-1.0.6}/src/chad/__init__.py

@@ -4,7 +4,7 @@ A flat collection of cooperating modules behind one console script (``chad``):
 the inference engine, the tool layer, the agent loop, and the terminal UI.
 """
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"
 
 # chad sets no MLX_* runtime vars. MLX_METAL_FAST_SYNCH, MLX_MAX_OPS_PER_BUFFER
 # and MLX_MAX_MB_PER_BUFFER were each measured end-to-end on the 35B and every

{chad_code-1.0.5 → chad_code-1.0.6}/src/chad/agent.py

@@ -57,11 +57,12 @@ SUBAGENT_READ_ONLY = {
 
 def subagent_tools_for(parent_mode: str, requested: str) -> str:
     """The toolset a sub-agent may run with. A sub-agent auto-approves its own tool
-    calls (mode='auto', no confirm callback), so it must never hold more autonomy
-    than its parent: only an 'auto' parent (--yolo / headless) may delegate 'all';
-    a 'normal' parent's human-approval promise and plan mode's read-only promise
-    both clamp the sub-agent to read-only."""
-    if parent_mode == "auto" and requested == "all":
+    calls (mode='yolo', no confirm callback), so it must never hold more autonomy
+    than its parent: only a 'yolo' parent (--yolo / headless) may delegate 'all'.
+    A 'normal' parent's human-approval promise, an 'auto' parent's narrower promise
+    (edits yes, shell no — and 'all' includes bash), and plan mode's read-only
+    promise all clamp the sub-agent to read-only."""
+    if parent_mode == "yolo" and requested == "all":
         return "all"
     return "read-only"
 
@@ -209,10 +210,30 @@ def close_unclosed_think(text: str, thinking: bool) -> str:
 
 # Permission modes (Claude Code parity, cycled with shift-tab in the TUI):
 #   normal — confirm each mutating tool (bash/write/edit)
-#   auto   — auto-approve mutating tools (yolo)
+#   auto   — auto-approve FILE EDITS only; bash and MCP tools still ask
+#   yolo   — auto-approve every mutating tool (--yolo starts here)
 #   plan   — read-only: changes are blocked; the model researches and proposes a plan
-MODES = ("normal", "auto", "plan")
-MODE_LABEL = {"normal": "normal", "auto": "auto-accept edits", "plan": "plan mode"}
+MODES = ("normal", "auto", "yolo", "plan")
+MODE_LABEL = {"normal": "normal", "auto": "auto-accept edits", "yolo": "yolo",
+              "plan": "plan mode"}
+
+# What `auto` waves through: edits to files in the workspace, whose blast radius is a
+# diff you can read and revert. `bash` is excluded on purpose — a shell command can
+# touch anything on the machine, is the one tool whose preview is genuinely hard to
+# eyeball, and is exactly what a human is still in the loop for. MCP tools are excluded
+# for the same reason (a server-side tool can send mail or hit an API). The list is
+# explicit rather than `MUTATING - {"bash"}` so it fails CLOSED: a mutating tool added
+# later asks for approval until someone deliberately adds it here.
+AUTO_EDIT_TOOLS = {"write", "edit", "replace_lines", "insert_lines",
+                   "replace_symbol", "insert_symbol", "rename_symbol"}
+
+
+def auto_approves(mode: str, name: str) -> bool:
+    """Does `mode` clear tool `name` without asking a human? Read-only tools never
+    reach here (the caller checks is_mutating first)."""
+    if mode == "yolo":
+        return True
+    return mode == "auto" and name in AUTO_EDIT_TOOLS
 _PLAN_PREFIX = (
     "[PLAN MODE. Research first (read/grep/glob/repo_map/overview) — do NOT edit "
     "project files or run commands. Then write ONE self-contained plan to "
@@ -325,7 +346,7 @@ class Agent:
             skills.reset_session()
             from . import mcp
             mcp.reset_session()
-        self.mode = mode or ("auto" if yolo else "normal")
+        self.mode = mode or ("yolo" if yolo else "normal")
         self.thinking = thinking  # Ornith is a reasoning model; toggles <think> blocks
         # Steps per WINDOW, not a hard kill: a window that landed+verified a change
         # earns an extension (see guardrails.extend_step_cap; absolute ceiling 4x).
@@ -460,7 +481,7 @@ class Agent:
 
     @property
     def yolo(self) -> bool:
-        return self.mode == "auto"
+        return self.mode == "yolo"
 
     @property
     def tok_per_s(self) -> float:
@@ -586,18 +607,18 @@ class Agent:
 
     def _confirm(self, name, args) -> bool:
         # Destructive-bash seatbelt: a catastrophic shell command (rm -rf ~, mkfs,
-        # curl|sh, …) is screened even in --yolo/auto mode, because the model acts on
-        # untrusted repo contents and auto mode has no human in the loop. If a confirm
+        # curl|sh, …) is screened even in --yolo mode, because the model acts on
+        # untrusted repo contents and yolo mode has no human in the loop. If a confirm
         # channel exists (TTY or callback) we force the prompt; headless with no channel
         # we BLOCK rather than execute on injection. CHAD_NO_DESTRUCTIVE_GUARD=1 opts out.
         dangerous = (name == "bash" and isinstance(args, dict)
                      and not config.flag("CHAD_NO_DESTRUCTIVE_GUARD")
                      and guardrails.is_destructive_bash(str(args.get("command", ""))))
-        if self.mode == "auto" or not is_mutating(name):
+        if not is_mutating(name) or auto_approves(self.mode, name):
             if not dangerous:
                 return True
             if self._confirm_cb is None and not sys.stdin.isatty():
-                self._emit("info", f"  [blocked destructive command in auto mode: "
+                self._emit("info", f"  [blocked destructive command — nobody to approve it: "
                                    f"{args.get('command', '')!r}; set CHAD_NO_DESTRUCTIVE_GUARD=1 to allow]")
                 # Tell the MODEL the truth about who blocked it and why: "[denied by
                 # user]" reads as a human refusal and teaches the wrong lesson (the
@@ -642,12 +663,13 @@ class Agent:
         parent. Its grep/read churn never enters the main transcript; only this return
         does. Depth 1 only: a sub-agent can't itself call `task` (its schema omits it)."""
         # Never grant a sub-agent more autonomy than its parent: the sub-agent runs
-        # mode='auto' with no confirm callback, so an 'all' toolset is honored only when
-        # the parent itself is auto-approved (--yolo/headless); 'normal' (human confirms
-        # every mutation) and 'plan' (read-only) parents clamp it to read-only.
+        # mode='yolo' with no confirm callback, so an 'all' toolset is honored only when
+        # the parent itself is fully auto-approved (--yolo/headless); 'normal' (human
+        # confirms every mutation), 'auto' (human still confirms shell) and 'plan'
+        # (read-only) parents clamp it to read-only.
         requested, tools = tools, subagent_tools_for(self.mode, tools)
         if requested == "all" and tools == "read-only":
-            self._emit("muted", "   ⌊ sub-agent clamped to read-only (parent mode is not auto)")
+            self._emit("muted", "   ⌊ sub-agent clamped to read-only (parent mode is not yolo)")
         self._emit("muted", f"   ⌊ delegating to sub-agent: {description}")
         log.info("TASK start | desc=%r | tools=%s | prompt=%r",
                  description, tools, redact(prompt[:300]))
@@ -657,7 +679,7 @@ class Agent:
         try:
             sub = Agent(
                 self.engine,
-                mode="auto",                       # auto-approve within its restricted toolset
+                mode="yolo",                       # auto-approve within its restricted toolset
                 max_steps=SUBAGENT_MAX_STEPS,
                 ctx_limit=min(self.ctx_limit, SUBAGENT_CTX_LIMIT),
                 thinking=self.thinking,
@@ -1509,7 +1531,8 @@ class Agent:
                 # fire, which is how a turn once shipped a 28-token garble as its final
                 # answer. read_only/explain asks are exempt. Banks a note so
                 # auto-continue relaunches fresh instead of shipping nothing.
-                did_nothing = self.mode == "auto" and not read_only_intent and not did_work
+                did_nothing = (self.mode in ("auto", "yolo")
+                               and not read_only_intent and not did_work)
                 if (action_task and not read_only_intent
                         and (not made_edit or unverified_edit)) or did_nothing:
                     # Churn→audit handoff: this hard stop used to fire with the

{chad_code-1.0.5 → chad_code-1.0.6}/src/chad/cli.py

@@ -712,7 +712,7 @@ def _main(argv=None):
         sys.stderr.write(f"ready in {load_s:.1f}s | context {eng.effective_ctx} tokens "
                          f"(compact at {ctx_limit})\n")
 
-    start_mode = "plan" if args.plan else ("auto" if args.yolo else "normal")
+    start_mode = "plan" if args.plan else ("yolo" if args.yolo else "normal")
     thinking = not args.no_think
 
     # Live per-turn ctx-limit recheck: the startup number was
@@ -758,9 +758,9 @@ def _main(argv=None):
         # auto-approve mutating tools unless the user asked for read-only --plan.
         run_mode = start_mode
         if run_mode == "normal" and not sys.stdin.isatty():
-            run_mode = "auto"
+            run_mode = "yolo"
             sys.stderr.write("[headless: auto-approving tools (use --plan for read-only)]\n")
-        agent = Agent(eng, yolo=(run_mode == "auto"), ctx_limit=ctx_limit,
+        agent = Agent(eng, yolo=(run_mode == "yolo"), ctx_limit=ctx_limit,
                       mode=run_mode, thinking=thinking, resume=resume, persist=True,
                       think_budget=args.think_budget,
                       turn_budget_s=turn_budget_s, ctx_limit_fn=ctx_limit_fn)
@@ -777,7 +777,7 @@ def _main(argv=None):
         # ships as an empty diff — the measured bail signature.
         auto_continue = config.env_int("CHAD_AUTO_CONTINUE")
         continues = auto_continue if auto_continue is not None \
-            else (2 if run_mode == "auto" else 0)
+            else (2 if run_mode == "yolo" else 0)
         used_continues = 0
         while agent.budget_note:
             # Base allowance first; past it, keep granting fresh attempts while most
@@ -819,7 +819,7 @@ def _main(argv=None):
             if getattr(eng, "temp", None) is not None:
                 eng.temp = max(eng.temp, 0.6)
             eng.reset()
-            agent = Agent(eng, yolo=(run_mode == "auto"), ctx_limit=ctx_limit,
+            agent = Agent(eng, yolo=(run_mode == "yolo"), ctx_limit=ctx_limit,
                           mode=run_mode, thinking=thinking, persist=True,
                           think_budget=args.think_budget,
                           turn_budget_s=relaunch_s, ctx_limit_fn=ctx_limit_fn)
@@ -841,7 +841,7 @@ def _main(argv=None):
             sys.stderr.write(f"[review] task finished with {turn_budget_s - elapsed:.0f}s "
                              "of budget left; running one fresh-context verification pass\n")
             eng.reset()
-            agent = Agent(eng, yolo=(run_mode == "auto"), ctx_limit=ctx_limit,
+            agent = Agent(eng, yolo=(run_mode == "yolo"), ctx_limit=ctx_limit,
                           mode=run_mode, thinking=thinking, persist=True,
                           think_budget=args.think_budget,
                           turn_budget_s=review_budget, ctx_limit_fn=ctx_limit_fn)

chad_code-1.0.6/src/chad/parakeet/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

chad_code-1.0.6/src/chad/parakeet/__init__.py

@@ -0,0 +1,27 @@
+"""Vendored Parakeet-on-MLX inference — chad's STT engine, MLX-only by design.
+
+Copied from parakeet-mlx 0.5.2 (Apache-2.0, Copyright Senstella,
+https://github.com/senstella/parakeet-mlx — license text in this directory's
+LICENSE file). Parakeet TDT v3 (0.6B) replaces the earlier vendored Whisper:
+same speed class as the coding model's own stack, better dictation accuracy,
+and its TDT decoder doesn't have Whisper's repetition-loop hallucination mode.
+Crucially, its tokenizer vocabulary ships inside the model repo's config.json —
+no vocab data files in this repo or the wheel.
+
+Vendored rather than depended on because the PyPI package drags librosa
+(→ numba/scipy/scikit-learn) for a single mel-filterbank call, plus typer for
+a CLI chad doesn't use. What changed, relative to upstream:
+- audio.py: librosa.filters.mel replaced by a local numpy implementation,
+  validated against librosa to <1e-8 (goldens in tests/test_speech.py);
+  load_audio (ffmpeg file decode) removed — chad feeds mic arrays.
+- utils.py: dacite.from_dict replaced by a local recursive dataclass builder.
+- parakeet.py: transcribe(path) raises (it needed the ffmpeg loader); the
+  array-level pipeline chad uses — get_logmel() + generate() — is untouched.
+- cli.py dropped.
+Every change is marked "VENDORED CHANGE"; the rest is byte-identical to
+upstream, so a version bump is a re-copy plus re-applying those edits.
+
+Runtime deps beyond chad's core tree (mlx, numpy, huggingface-hub): none.
+"""
+from .audio import get_logmel, mel_filters  # noqa: F401
+from .utils import from_config, from_pretrained  # noqa: F401