@kianwoon/modelweaver 0.3.0

package/CONTRIBUTING.md

@@ -0,0 +1,126 @@
+# Contributing to ModelWeaver
+
+Thanks for your interest in contributing. This guide covers what you need to get started.
+
+## Prerequisites
+
+- **Node.js** >= 18 (ESM is required)
+- **npm** (bundled with Node.js)
+
+## Setup
+
+1. Fork the repository and clone your fork locally.
+2. Install dependencies:
+
+```bash
+npm install
+```
+
+3. Verify everything works:
+
+```bash
+npm test
+npm run build
+```
+
+## Development
+
+Start the dev server with hot reload:
+
+```bash
+npm run dev
+```
+
+To test against real providers, create a `modelweaver.yaml` in the project root (or run `npx modelweaver init` to use the interactive wizard). Set the required API keys as environment variables, then start the server. The config file is auto-detected.
+
+## Project Structure
+
+```
+src/
+  index.ts      CLI entry point -- arg parsing, server startup, graceful shutdown
+  server.ts     Hono app setup, request routing, error handling
+  proxy.ts      Request forwarding, SSE streaming, fallback chains
+  router.ts     Model name to tier matching (sonnet/opus/haiku)
+  config.ts     YAML config loading, env var resolution, Zod validation
+  types.ts      TypeScript interfaces and shared types
+  logger.ts     Structured logging (info/warn/error/debug)
+  presets.ts    Provider templates used by the init wizard
+  init.ts       Interactive setup wizard (prompts-based)
+tests/
+  *.test.ts     Vitest test files (one per source module)
+  helpers/      Shared test utilities (mock provider, etc.)
+.github/workflows/
+  ci.yml        CI pipeline: type check, build, test on Node 18/20/22
+```
+
+## Testing
+
+Tests use Vitest. Run them with:
+
+```bash
+npm test          # single run
+npm run test:watch  # watch mode
+```
+
+Test files live in `tests/` and mirror the source structure -- one `.test.ts` file per module. Shared helpers go in `tests/helpers/`. The `mock-provider` helper starts a local HTTP server that returns canned responses for integration tests.
+
+When adding a feature, include tests that cover the happy path and relevant edge cases.
+
+## Building
+
+```bash
+npm run build
+```
+
+tsup bundles the source to `dist/` as ESM. The output is what gets published and what the CLI entry point references.
+
+## Code Style
+
+- **TypeScript strict mode** is enabled. Do not use `any`.
+- **ESM only** -- the project uses `"type": "module"`.
+- **Import extensions**: use `.js` extensions for local imports:
+  ```typescript
+  import { foo } from './bar.js';
+  ```
+- **Node built-ins**: use the `node:` prefix:
+  ```typescript
+  import { readFileSync } from 'node:fs';
+  ```
+- **Config validation**: all config shapes are defined as Zod schemas in `config.ts`.
+- **API keys**: never hardcode keys. Use the `${ENV_VAR}` syntax in config, resolved at runtime.
+- No linter or formatter is configured yet, so follow the patterns you see in the existing code.
+
+## Pull Requests
+
+1. Branch off `main`.
+2. Make your changes and add tests.
+3. Ensure `npm test` and `npm run build` pass locally.
+4. Open a PR with a clear description of what changed and why.
+5. CI must pass before merge. The pipeline runs type checking, the build, and the full test suite on Node 18, 20, and 22.
+
+Keep PRs focused. If a change spans multiple concerns, consider splitting into separate PRs.
+
+## Adding a New Provider
+
+Adding a new provider is a single-step process. Open `src/presets.ts` and add a new entry to the `PRESETS` array following the `ProviderPreset` interface:
+
+```typescript
+{
+  id: "my-provider",           // machine-readable key used in config
+  name: "My Provider",          // display name shown in the init wizard
+  baseUrl: "https://api.example.com",
+  envKey: "MY_PROVIDER_API_KEY", // suggested environment variable
+  authType: "bearer",           // "bearer" or "anthropic"
+  models: {
+    sonnet: "model-id-for-sonnet-tier",
+    opus: "model-id-for-opus-tier",
+    haiku: "model-id-for-haiku-tier",
+  },
+}
+```
+
+The init wizard will automatically offer the new provider. No other files need to change.
+
+## License
+
+By contributing, you agree that your code will be licensed under the [Apache-2.0](https://opensource.org/licenses/Apache-2.0) license.

package/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.

package/README.md

@@ -0,0 +1,289 @@
+<p align="center">
+  <img src="gui/icons/icon.png" alt="ModelWeaver" width="96" />
+</p>
+
+# ModelWeaver
+
+Multi-provider model orchestration proxy for Claude Code. Route different agent roles to different model providers with automatic fallback, exact model routing, config hot-reload, and crash recovery.
+
+[![CI](https://github.com/kianwoon/modelweaver/actions/workflows/ci.yml/badge.svg)](https://github.com/kianwoon/modelweaver/actions/workflows/ci.yml) [![CodeQL](https://github.com/kianwoon/modelweaver/actions/workflows/codeql.yml/badge.svg)](https://github.com/kianwoon/modelweaver/actions/workflows/codeql.yml) [![Release](https://github.com/kianwoon/modelweaver/actions/workflows/release.yml/badge.svg)](https://github.com/kianwoon/modelweaver/actions/workflows/release.yml) [![License: Apache-2.0](https://img.shields.io/badge/License-Apache--2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![GitHub stars](https://img.shields.io/github/stars/kianwoon/modelweaver?style=social)](https://github.com/kianwoon/modelweaver/stargazers)
+
+
+<img width="358" height="479" alt="Screenshot 2026-03-20 at 5 11 55 AM" src="https://github.com/user-attachments/assets/a973a707-0cd7-4701-8d19-f6cd028f6c56" />
+
+
+## How It Works
+
+ModelWeaver sits between Claude Code and upstream model providers as a local HTTP proxy. It inspects the `model` field in each Anthropic Messages API request and routes it to the best-fit provider.
+
+```
+Claude Code  ──→  ModelWeaver  ──→  Anthropic (primary)
+                   (localhost)   ──→  OpenRouter (fallback)
+                   │
+              1. Match exact model name (modelRouting)
+              2. Match tier via substring (tierPatterns)
+              3. Fallback on 429 / 5xx errors
+```
+
+## Features
+
+- **Tier-based routing** — route by model family (sonnet/opus/haiku) using substring pattern matching
+- **Exact model routing** — route specific model names to dedicated providers (checked first)
+- **Automatic fallback** — transparent failover on rate limits (429) and server errors (5xx)
+- **Model name rewriting** — each provider in the chain can use a different model name
+- **Interactive setup wizard** — guided configuration with API key validation
+- **Config hot-reload** — changes to config file are picked up automatically, no restart needed
+- **Daemon mode** — run as a background process with start/stop/status/remove commands
+- **Crash recovery** — auto-restarts on crash with rate limiting (max 5 restarts/60s)
+- **Multiple auth types** — supports `x-api-key` (Anthropic) and `Bearer` token auth
+- **Per-provider timeouts** — configurable timeout with AbortController
+- **Structured logging** — JSON logs with request IDs for tracing
+- **Env var substitution** — config references like `${API_KEY}` resolved from environment
+- **Circuit breaker** — per-provider circuit breaker with closed/open/half-open states, prevents hammering unhealthy providers
+- **Adaptive fallback** — on 429 rate limits, automatically races remaining providers simultaneously instead of sequential fallback
+- **Connection pooling** — per-provider undici Agent dispatcher with configurable pool size, closes old agents on config reload
+- **Health endpoint** — `/api/status` returns circuit breaker state and uptime
+- **Desktop GUI** — native app with one-command launch (`modelweaver gui`), auto-downloads from GitHub Releases
+
+## Prerequisites
+
+- **Node.js** 20 or later — [Install Node.js](https://nodejs.org)
+- `npx` — included with Node.js (no separate install needed)
+
+## Installation
+
+ModelWeaver requires no permanent install — `npx` downloads and runs it on the fly. But if you prefer a global install:
+
+```bash
+npm install -g modelweaver
+```
+
+After that, replace `npx modelweaver` with `modelweaver` in all commands below.
+
+## Quick Start
+
+### 1. Run the setup wizard
+
+```bash
+npx modelweaver init
+```
+
+The wizard guides you through:
+- Selecting from 6 preset providers (Anthropic, OpenRouter, Together AI, GLM/Z.ai, Minimax, Fireworks)
+- Testing API keys to verify connectivity
+- Setting up model routing tiers
+- Auto-configuring `~/.claude/settings.json` for Claude Code integration
+
+### 2. Start ModelWeaver
+
+```bash
+# Foreground (see logs in terminal)
+npx modelweaver
+
+# Background daemon (auto-restarts on crash)
+npx modelweaver start
+```
+
+### 3. Point Claude Code to ModelWeaver
+
+```bash
+export ANTHROPIC_BASE_URL=http://localhost:3456
+export ANTHROPIC_API_KEY=unused-but-required
+claude
+```
+
+## CLI Commands
+
+```bash
+npx modelweaver init              # Interactive setup wizard
+npx modelweaver start             # Start as background daemon
+npx modelweaver stop              # Stop background daemon
+npx modelweaver status            # Show daemon status
+npx modelweaver remove            # Stop daemon + remove PID and log files
+npx modelweaver gui               # Launch desktop GUI (auto-downloads binary)
+npx modelweaver [options]         # Run in foreground
+```
+
+### CLI Options
+
+```
+  -p, --port <number>      Server port                    (default: from config)
+  -c, --config <path>      Config file path               (auto-detected)
+  -v, --verbose            Enable debug logging           (default: off)
+  -h, --help               Show help
+```
+
+## Daemon Mode
+
+Run ModelWeaver as a background process that survives terminal closure and auto-recovers from crashes.
+
+```bash
+npx modelweaver start             # Start (forks monitor + daemon)
+npx modelweaver status            # Check if running
+npx modelweaver stop               # Graceful stop (SIGTERM → SIGKILL after 5s)
+npx modelweaver remove             # Stop + remove PID file + log file
+```
+
+**How it works**: `start` forks a lightweight monitor process that owns the PID file. The monitor spawns the actual daemon worker. If the worker crashes, the monitor auto-restarts it after a 2-second delay (up to 5 restarts per 60-second window to prevent crash loops).
+
+```
+modelweaver.pid        → Monitor process (handles signals, watches child)
+  └── modelweaver.worker.pid → Daemon worker (runs HTTP server)
+```
+
+**Files**:
+- `~/.modelweaver/modelweaver.pid` — monitor PID
+- `~/.modelweaver/modelweaver.worker.pid` — worker PID
+- `~/.modelweaver/modelweaver.log` — daemon output log
+
+## Desktop GUI
+
+ModelWeaver ships a native desktop GUI built with Tauri. No Rust toolchain needed — the binary is auto-downloaded from GitHub Releases.
+
+```bash
+npx modelweaver gui
+```
+
+First run downloads the latest binary for your platform (~10-30 MB). Subsequent launches use the cached version.
+
+**Supported platforms:**
+
+| Platform | Format |
+|---|---|
+| macOS (Apple Silicon) | `.dmg` |
+| macOS (Intel) | `.dmg` |
+| Linux (x86_64) | `.AppImage` |
+| Windows (x86_64) | `.msi` |
+
+**Cached files** are stored in `~/.modelweaver/gui/` with version tracking — new versions download automatically on the next `gui` launch.
+
+## Configuration
+
+### Config file locations
+
+Checked in order (first found wins):
+1. `./modelweaver.yaml` (project-local)
+2. `~/.modelweaver/config.yaml` (user-global)
+
+### Full config schema
+
+```yaml
+server:
+  port: 3456                  # Server port          (default: 3456)
+  host: localhost             # Bind address         (default: localhost)
+
+providers:
+  anthropic:
+    baseUrl: https://api.anthropic.com
+    apiKey: ${ANTHROPIC_API_KEY}  # Env var substitution
+    timeout: 30000                # Request timeout in ms  (default: 30000)
+    poolSize: 10                  # Connection pool size (default: varies by provider)
+    authType: anthropic           # "anthropic" | "bearer"  (default: anthropic)
+  openrouter:
+    baseUrl: https://openrouter.ai/api
+    apiKey: ${OPENROUTER_API_KEY}
+    authType: bearer
+    timeout: 60000
+
+# Tier-based routing (substring pattern matching)
+routing:
+  sonnet:
+    - provider: anthropic
+      model: claude-sonnet-4-20250514      # Optional: rewrite model name
+    - provider: openrouter
+      model: anthropic/claude-sonnet-4      # Fallback
+  opus:
+    - provider: anthropic
+      model: claude-opus-4-20250514
+  haiku:
+    - provider: anthropic
+      model: claude-haiku-4-5-20251001
+
+# Pattern matching: model name includes any string → matched to tier
+tierPatterns:
+  sonnet: ["sonnet", "3-5-sonnet", "3.5-sonnet"]
+  opus: ["opus", "3-opus", "3.5-opus"]
+  haiku: ["haiku", "3-haiku", "3.5-haiku"]
+
+# Exact model name routing (checked FIRST, before tier patterns)
+modelRouting:
+  "glm-5-turbo":
+    - provider: anthropic               # Route to specific provider
+  "MiniMax-M2.7":
+    - provider: openrouter
+      model: minimax/MiniMax-M2.7        # With model name rewrite
+```
+
+### Routing priority
+
+1. **Exact model name** (`modelRouting`) — if the request model matches exactly, use that route
+2. **Tier pattern** (`tierPatterns` + `routing`) — substring match the model name against patterns, then use the tier's provider chain
+3. **No match** — returns 502 with a descriptive error listing configured tiers and model routes
+
+### Provider chain behavior
+
+- **First provider is primary**, rest are fallbacks
+- **Fallback triggers** on: 429 (rate limit), 5xx (server error), network timeout
+- **Adaptive race mode** — when a 429 is received, remaining providers are raced simultaneously (not sequentially) for faster recovery
+- **Circuit breaker** — providers that repeatedly fail are temporarily skipped (auto-recovers after cooldown)
+- **No fallback on**: 4xx (bad request, auth failure, forbidden) — returned immediately
+- **Model rewriting**: each provider entry can override the `model` field in the request body
+
+### Supported providers
+
+| Provider | Auth Type | Base URL |
+|---|---|---|
+| Anthropic | `x-api-key` | `https://api.anthropic.com` |
+| OpenRouter | Bearer | `https://openrouter.ai/api` |
+| Together AI | Bearer | `https://api.together.xyz` |
+| GLM (Z.ai) | `x-api-key` | `https://api.z.ai/api/anthropic` |
+| Minimax | `x-api-key` | `https://api.minimax.io/anthropic` |
+| Fireworks | Bearer | `https://api.fireworks.ai/inference/v1` |
+
+Any OpenAI/Anthropic-compatible API works — just set `baseUrl` and `authType` appropriately.
+
+### Config hot-reload
+
+In daemon mode, ModelWeaver watches the config file for changes and reloads automatically (debounced 300ms). You can also send a manual reload signal:
+
+```bash
+kill -SIGUSR1 $(cat ~/.modelweaver/modelweaver.pid)
+```
+
+Or just re-run `npx modelweaver init` — it automatically signals the running daemon to reload.
+
+## API
+
+### Health check
+
+```bash
+curl http://localhost:3456/api/status
+```
+
+Returns circuit breaker state for all providers and server uptime.
+
+## How Claude Code Uses Model Tiers
+
+Claude Code sends different model names for different agent roles:
+
+| Agent Role | Model Tier | Typical Model Name |
+|---|---|---|
+| Main conversation, coding | Sonnet | `claude-sonnet-4-20250514` |
+| Explore (codebase search) | Haiku | `claude-haiku-4-5-20251001` |
+| Plan (analysis) | Sonnet | `claude-sonnet-4-20250514` |
+| Complex subagents | Opus | `claude-opus-4-20250514` |
+
+ModelWeaver uses the model name to determine which agent tier is calling, then routes accordingly.
+
+## Development
+
+```bash
+npm install          # Install dependencies
+npm test             # Run tests (174 tests)
+npm run build        # Build for production (tsup)
+npm run dev          # Run in dev mode (tsx)
+```
+
+## License
+
+Apache-2.0

package/dist/chunk-OMWFRIHF.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+function s(t){let o={debug:0,info:1,warn:2,error:3};function n(e,r,g){if(o[e]<o[t])return;let i={timestamp:new Date().toISOString(),level:e,message:r,...g};process.stdout.write(JSON.stringify(i)+`
+`)}return{info:(e,r)=>n("info",e,r),debug:(e,r)=>n("debug",e,r),warn:(e,r)=>n("warn",e,r),error:(e,r)=>n("error",e,r)}}export{s as a};
+//# sourceMappingURL=chunk-OMWFRIHF.js.map

package/dist/chunk-OMWFRIHF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/logger.ts"],"sourcesContent":["// src/logger.ts\nexport type LogLevel = \"info\" | \"debug\" | \"warn\" | \"error\";\n\nexport interface Logger {\n  info: (message: string, data?: Record<string, unknown>) => void;\n  debug: (message: string, data?: Record<string, unknown>) => void;\n  warn: (message: string, data?: Record<string, unknown>) => void;\n  error: (message: string, data?: Record<string, unknown>) => void;\n}\n\nexport function createLogger(level: LogLevel): Logger {\n  const levels = { debug: 0, info: 1, warn: 2, error: 3 } as const;\n\n  function log(lvl: LogLevel, message: string, data?: Record<string, unknown>) {\n    if (levels[lvl] < levels[level]) return;\n    const entry = {\n      timestamp: new Date().toISOString(),\n      level: lvl,\n      message,\n      ...data,\n    };\n    process.stdout.write(JSON.stringify(entry) + \"\\n\");\n  }\n\n  return {\n    info: (msg, data?) => log(\"info\", msg, data),\n    debug: (msg, data?) => log(\"debug\", msg, data),\n    warn: (msg, data?) => log(\"warn\", msg, data),\n    error: (msg, data?) => log(\"error\", msg, data),\n  };\n}\n"],"mappings":";AAUO,SAASA,EAAaC,EAAyB,CACpD,IAAMC,EAAS,CAAE,MAAO,EAAG,KAAM,EAAG,KAAM,EAAG,MAAO,CAAE,EAEtD,SAASC,EAAIC,EAAeC,EAAiBC,EAAgC,CAC3E,GAAIJ,EAAOE,CAAG,EAAIF,EAAOD,CAAK,EAAG,OACjC,IAAMM,EAAQ,CACZ,UAAW,IAAI,KAAK,EAAE,YAAY,EAClC,MAAOH,EACP,QAAAC,EACA,GAAGC,CACL,EACA,QAAQ,OAAO,MAAM,KAAK,UAAUC,CAAK,EAAI;AAAA,CAAI,CACnD,CAEA,MAAO,CACL,KAAM,CAACC,EAAKF,IAAUH,EAAI,OAAQK,EAAKF,CAAI,EAC3C,MAAO,CAACE,EAAKF,IAAUH,EAAI,QAASK,EAAKF,CAAI,EAC7C,KAAM,CAACE,EAAKF,IAAUH,EAAI,OAAQK,EAAKF,CAAI,EAC3C,MAAO,CAACE,EAAKF,IAAUH,EAAI,QAASK,EAAKF,CAAI,CAC/C,CACF","names":["createLogger","level","levels","log","lvl","message","data","entry","msg"]}

package/dist/chunk-P2HBWASF.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import{spawn as N,execFile as W,execFileSync as $}from"child_process";import{access as L,readFile as E,writeFile as M,unlink as I,mkdir as G}from"fs/promises";import{join as f}from"path";import{dirname as U}from"path";import{fileURLToPath as _}from"url";import{createServer as O}from"net";function d(){return process.platform==="win32"}var m=f(process.env.HOME||process.env.USERPROFILE||"",".modelweaver"),D=null;function Q(n){D=n}function y(){return f(m,"modelweaver.pid")}function c(){return f(m,"modelweaver.log")}async function R(){try{await L(m)}catch{await G(m,{recursive:!0})}}async function Y(n){await R();try{await M(y(),`${n}
+`,{flag:"wx"})}catch(e){if(e.code==="EEXIST")return;throw e}}async function w(){let n=y();try{let e=await E(n,"utf-8"),t=parseInt(e.trim(),10);return isNaN(t)?null:t}catch{return null}}async function u(){let n=y();try{await I(n)}catch{}}function b(){return f(m,"modelweaver.worker.pid")}async function Z(n){await R(),await M(b(),`${n}
+`)}async function v(){let n=b();try{let e=await E(n,"utf-8"),t=parseInt(e.trim(),10);return isNaN(t)?null:t}catch{return null}}async function P(){let n=b();try{await I(n)}catch{}}function a(n){try{return process.kill(n,0),!0}catch{return!1}}function x(n){return new Promise(e=>{if(d()){try{W("netstat",["-ano"],{encoding:"utf-8",timeout:3e3},(t,r)=>{if(t){e([]);return}let i=[];for(let o of(r||"").split(`
+`))if(o.includes("LISTENING")&&o.includes(`:${n}`)){let s=o.trim().split(/\s+/),l=parseInt(s[s.length-1],10);!isNaN(l)&&l>0&&i.push(l)}e(i)})}catch{e([]);return}return}W("lsof",["-ti",`:${n}`,"-sTCP:LISTEN"],{encoding:"utf-8",timeout:3e3},(t,r)=>{if(t){e([]);return}let i=(r||"").trim();e(i?i.split(`
+`).map(Number).filter(o=>!isNaN(o)):[])})})}async function h(n){if(D!==null)return D;try{let{loadConfig:e}=await import("./config-FYJATRN4.js"),{config:t}=e(n??void 0);return t.server.port}catch{return 3456}}async function T(n,e=5e3){for(let r of n)try{process.kill(r,"SIGTERM")}catch{}let t=Date.now()+e;for(;Date.now()<t;){if(n.every(r=>!a(r)))return!0;await new Promise(r=>setTimeout(r,200))}for(let r of n)if(d())try{$("taskkill",["/F","/PID",String(r),"/T"],{stdio:"ignore"})}catch{}else try{process.kill(r,"SIGKILL")}catch{}return!0}async function C(n){let e=await w();if(e===null){let t=n??await h();if(t!==null&&t>0){let r=await x(t);if(r.length>0){let i=r.filter(o=>a(o));if(i.length>0)return{running:!0,pid:i[0],message:`ModelWeaver is running (PID ${i[0]}, detected on port ${t}; PID file missing)`}}}return{running:!1,message:"ModelWeaver is not running (no PID file found)"}}return a(e)?{running:!0,pid:e,message:`ModelWeaver is running (PID ${e})`}:(await u(),{running:!1,message:"ModelWeaver is not running (stale PID file cleaned up)"})}function A(n){return new Promise(e=>{let t=O();t.once("error",r=>{r.code==="EADDRINUSE"?e(!0):e(!1)}),t.once("listening",()=>{t.close(()=>e(!1))}),t.listen(n)})}async function ee(n,e,t){let r=await C(e);if(r.running)return{success:!1,pid:r.pid,message:`ModelWeaver is already running (PID ${r.pid})`,logPath:c()};let i=e??await h()??3456;if(await A(i))return{success:!1,message:`Port ${i} is already in use. Is ModelWeaver or another process running on it?`,logPath:c()};let o=_(import.meta.url),s=U(o),p=[f(s,"index.js"),"--monitor"];n&&p.push("--config",n),e&&p.push("--port",String(e)),t&&p.push("--verbose"),N(process.execPath,p,{detached:!0,stdio:"ignore",env:{...process.env}}).unref();let g;for(let S=0;S<20;S++){let k=await w();if(k!==null){g=k;break}await new Promise(F=>setTimeout(F,100))}return g?{success:!0,pid:g,message:`ModelWeaver started in background (PID ${g})`,logPath:c()}:{success:!1,message:"Daemon started but PID file was not created. Check logs at "+c(),logPath:c()}}async function K(n){let e=await w();if(e===null){let r=n??await h();if(r!==null&&r>0){let o=(await x(r)).filter(s=>a(s));if(o.length>0){let s=await v(),l=[...o];return s!==null&&a(s)&&!l.includes(s)&&l.push(s),await T(l),await P(),{success:!0,message:`ModelWeaver stopped (found on port ${r}, PIDs ${o.join(", ")}; PID file was missing)`}}}return{success:!1,message:"ModelWeaver is not running (no PID file found)"}}if(!a(e)){let r=await v();return r!==null&&a(r)&&(await T([r]),await P()),await u(),{success:!1,message:"ModelWeaver is not running (stale PID file cleaned up)"}}try{process.kill(e,"SIGTERM")}catch{return{success:!1,message:`Failed to stop daemon (PID ${e})`}}let t=Date.now()+5e3;for(;Date.now()<t;){if(!a(e))return await u(),{success:!0,message:`ModelWeaver stopped (PID ${e})`};await new Promise(r=>setTimeout(r,100))}try{d()?$("taskkill",["/F","/PID",String(e),"/T"],{stdio:"ignore"}):process.kill(e,"SIGKILL")}catch{}return await u(),await P(),{success:!0,message:`ModelWeaver force-stopped (PID ${e})`}}async function j(){let n=c();try{await I(n)}catch{}}async function ne(){let n=await K();return await j(),await P(),{success:n.success||n.message.includes("not running"),message:n.success?"ModelWeaver stopped and cleaned up (PID file + log file removed)":n.message.includes("not running")?"ModelWeaver is not running. Log file cleaned up.":n.message}}async function te(n){let e=await w();if(e===null){let t=n??await h();if(t!==null&&t>0){let i=(await x(t)).filter(o=>a(o));if(i.length>0){for(let o of i)try{d()?console.log(`  Windows detected \u2014 reload signal not supported for PID ${o}. Use 'modelweaver stop && modelweaver start' instead.`):process.kill(o,"SIGHUP")}catch{}console.log(`  Sent reload signal to ${i.length} process(es) on port ${t}.`);return}}console.log("  Daemon is not running.");return}if(!a(e)){await u(),console.log("  Daemon is not running (stale PID file cleaned up).");return}try{if(d()){let t=await v();t!==null?(process.kill(t,"SIGTERM"),console.log(`  Killed worker (PID ${t}) on Windows \u2014 monitor will restart it.`)):console.log("  No worker PID file found \u2014 cannot reload.")}else process.kill(e,"SIGHUP"),console.log(`  Sent reload signal to daemon (PID ${e}).`)}catch{console.log("  Failed to send reload signal \u2014 daemon may not be running.")}}function re(n,e=300){let t=null;return{reload(){t&&clearTimeout(t),t=setTimeout(()=>{t=null,n()},e)},dispose(){t&&(clearTimeout(t),t=null)}}}export{Q as a,y as b,c,R as d,Y as e,w as f,u as g,b as h,Z as i,v as j,P as k,a as l,x as m,h as n,C as o,A as p,ee as q,K as r,j as s,ne as t,te as u,re as v};
+//# sourceMappingURL=chunk-P2HBWASF.js.map