@oneciel-ai/claude-any 0.1.24

package/docs/manual.md

@@ -0,0 +1,496 @@
+# Claude Any Manual
+
+Claude Any is a pre-launch configuration layer for Claude Code. It lets you
+choose a provider, model, base URL, API key, and provider options before Claude
+Code starts, while passing normal Claude Code arguments through unchanged.
+
+Credits: One Ciel LLC
+
+Current version: `0.1.22`
+
+## Install
+
+Requirements:
+
+- Python 3.10+
+- Claude Code installed as `claude`
+- Node/npm only if you enable optional MCP web tooling
+
+Current install from GitHub:
+
+```sh
+npm install -g https://github.com/OneCielAI/claude-any.git
+claude-any
+```
+
+Source install:
+
+```sh
+git clone https://github.com/OneCielAI/claude-any.git
+cd claude-any
+./install.sh
+claude-any
+```
+
+Windows PowerShell source install:
+
+```powershell
+git clone https://github.com/OneCielAI/claude-any.git
+cd claude-any
+.\install.ps1
+claude-any
+```
+
+Registry install, after the first npm publish:
+
+```sh
+npm install -g @oneciel-ai/claude-any
+claude-any
+```
+
+Upgrade:
+
+```sh
+# GitHub install, current recommended path
+npm install -g https://github.com/OneCielAI/claude-any.git --force
+claude-any version
+```
+
+To make `npm update -g @oneciel-ai/claude-any` work, the package must be
+published to the public npm registry under the same package name:
+
+```sh
+npm login
+npm publish --access public
+npm install -g @oneciel-ai/claude-any
+npm update -g @oneciel-ai/claude-any
+```
+
+For automated publishing, create an npm automation token, save it as the
+repository secret `NPM_TOKEN`, then publish a GitHub Release or run the
+`Publish to npm` workflow manually.
+
+Versioning uses SemVer. For future releases, bump `version` in `package.json`,
+create a matching Git tag such as `v0.1.1`, and publish a GitHub Release to
+trigger the npm publish workflow. After registry publication, the normal
+registry upgrade command will be:
+
+```sh
+npm update -g @oneciel-ai/claude-any
+```
+
+
+macOS has not been fully tested by the maintainer yet. The project uses
+portable Python and shell wrappers, so it is expected to work; please report
+issues if you find them.
+
+## Interactive Menu
+
+Run:
+
+```sh
+claude-any
+```
+
+The menu appears before Claude Code starts. Use arrow keys to move and Enter to
+edit or select:
+
+- Language: English, Korean, Japanese, Chinese.
+- Provider: Anthropic, Ollama, Ollama Cloud, vLLM, NVIDIA hosted, self-hosted NIM.
+- API key: enter only when the selected provider needs one.
+- Base URL: provider-aware default or custom endpoint.
+- Model: provider model picker when available, custom input otherwise.
+- Options: provider-specific generation, timeout, and preset settings.
+- Compatibility test: checks a plain text response, a required `tool_use`, and
+  a `tool_result` follow-up before launching Claude Code.
+- Launch Claude Code: starts Claude Code with the selected configuration.
+
+The lower status area shows connection checks, API-key state, provider notes,
+and compatibility-test results.
+For vLLM and self-hosted NIM, the compatibility test also reads `/v1/models`
+when available and prints the runtime `max_model_len` next to Claude Any's
+configured `context_window` and `max_output_tokens`.
+If the runtime model reports one context size but Claude Any is configured for
+another, the test output shows both values so you can fix either the server
+startup flags or the client preset.
+
+### LLM Option Presets
+
+Open `LLM options`, then select `Apply preset` to apply a provider-aware preset
+without editing every parameter manually. Claude Any currently includes:
+
+- Balanced Claude Code: stable 4K-output default for normal Claude Code use.
+- Coding deterministic: lower randomness for edits, scripts, and code review.
+- Fast short tasks: shorter output and timeout for quick background jobs.
+- Long context 65K: 65K context target with a 4K output reserve.
+- Large output/report: 8K output for summaries and reports.
+- Reasoning model: longer timeout and reasoning-friendly sampling.
+
+The recommended preset is chosen from the current provider and model name. For
+example, `coder` models prefer the coding preset, `r1`/`thinking` models prefer
+the reasoning preset, and vLLM/NIM models configured for 65K context prefer the
+long-context preset. For vLLM native mode, the server must still be launched
+with a matching `--max-model-len`; Claude Any cannot raise the server-side
+context limit from the client.
+
+## Provider Setup
+
+### Anthropic
+
+Anthropic uses native Claude Code behavior. You can either log in through
+Claude Code or use an Anthropic API key.
+
+- Claude Code docs: https://docs.anthropic.com/en/docs/claude-code
+- Claude Console API keys: https://console.anthropic.com/settings/keys
+
+### Ollama
+
+Local Ollama normally does not need an API key. Use a local base URL such as:
+
+```text
+http://127.0.0.1:11434
+```
+
+Ollama also provides Anthropic Messages API compatibility for tools such as
+Claude Code. If you use `:cloud` models through a local Ollama host, sign in on
+that Ollama host:
+
+```sh
+ollama signin
+```
+
+Links:
+
+- Ollama Anthropic compatibility: https://docs.ollama.com/api/anthropic-compatibility
+- Ollama authentication: https://docs.ollama.com/api/authentication
+
+### Ollama Cloud
+
+Ollama Cloud is for direct calls to `https://ollama.com/api`. It requires an
+Ollama API key. Cloud model names must end in `:cloud`.
+
+Links:
+
+- Ollama Cloud: https://ollama.com/cloud
+- Ollama API keys: https://ollama.com/settings/keys
+- Ollama sign in: https://ollama.com/signin
+
+### vLLM
+
+Use a vLLM server that exposes the Anthropic Messages API used by Claude Code.
+The base URL should be the server root, for example:
+
+```text
+http://127.0.0.1:8000
+```
+
+Claude Any and Claude Code will call `/v1/messages` under that base URL. Use an
+API key only if your vLLM server is configured to require one.
+
+For Claude Code, vLLM tool calling must be started with a parser that matches
+the model family. A server can answer text requests and still fail Claude Code
+if `--tool-call-parser` is wrong. For Qwen3-Coder, use `qwen3_xml`:
+
+```sh
+vllm serve Qwen/Qwen3-Coder-30B-A3B-Instruct \
+  --host 0.0.0.0 \
+  --port 8000 \
+  --served-model-name qwen3-coder-30b \
+  --max-model-len 65536 \
+  --enable-auto-tool-choice \
+  --tool-call-parser qwen3_xml
+```
+
+Hermes-style models and some older Qwen tool templates may use `hermes`
+instead, but do not assume `hermes` is correct for every Qwen model. Run
+`claude-any test` after changing the parser; the test now checks text,
+`tool_use`, and `tool_result`.
+
+Links:
+
+- vLLM Claude Code integration: https://docs.vllm.ai/en/latest/serving/integrations/claude_code/
+- vLLM tool calling: https://docs.vllm.ai/en/stable/features/tool_calling/
+- vLLM GitHub: https://github.com/vllm-project/vllm
+
+### NVIDIA Hosted NIM
+
+NVIDIA hosted models are available through NVIDIA API Catalog. Claude Any uses a
+compatibility route for hosted models and requires an NVIDIA API key.
+
+Links:
+
+- NVIDIA API Catalog: https://build.nvidia.com/
+- API Catalog quickstart: https://docs.api.nvidia.com/nim/docs/api-quickstart
+
+### Self-Hosted NVIDIA NIM
+
+Self-hosted NIM for LLMs can expose an Anthropic-compatible `/v1/messages`
+endpoint. Use the NIM host base URL, not the OpenAI chat-completions URL.
+
+Links:
+
+- Claude Code with NIM: https://docs.nvidia.com/nim/large-language-models/latest/ai-assistant-integrations/claude-code.html
+- NIM for LLMs getting started: https://docs.nvidia.com/nim/large-language-models/1.14.0/getting-started.html
+- NGC personal keys: https://org.ngc.nvidia.com/setup/personal-keys
+
+## Headless Usage
+
+Claude Any options use the `--ca-*` prefix so they do not collide with Claude
+Code flags. All other arguments pass through to Claude Code.
+
+Headless mode is for launching Claude Code directly without opening the
+pre-launch menu. It is useful for SSH sessions, scripts, scheduled jobs,
+CI-like automation, and remote servers. Any `--ca-*` option updates Claude
+Any's saved configuration first, skips the menu, starts the required
+router/proxy services, then immediately executes Claude Code with the remaining
+arguments.
+
+Basic pattern:
+
+```sh
+claude-any --ca-provider PROVIDER --ca-model MODEL [claude-code args...]
+```
+
+Direct Claude Code launch examples:
+
+```sh
+# Open an interactive Claude Code session immediately with the saved model.
+claude-any --ca-provider ollama-cloud --ca-model glm-5.1
+
+# Run one non-interactive Claude Code prompt and print text output.
+claude-any \
+  --ca-provider ollama-cloud \
+  --ca-model glm-5.1 \
+  --ca-api-key-env OLLAMA_API_KEY \
+  --ca-no-update-check \
+  -p "Reply with OK only." \
+  --output-format text
+
+# Use the current saved Claude Any provider/model and pass args straight to Claude Code.
+claude-any --ca-no-update-check -p "Summarize the current project." --output-format text
+```
+
+In these examples, `claude-any` is not just configuring settings. It starts
+Claude Code in the same command. The `--ca-*` flags are consumed by Claude Any;
+the prompt flags such as `-p` and `--output-format` are passed through to
+Claude Code.
+
+Provider setup examples:
+
+```sh
+# Local Ollama
+claude-any \
+  --ca-provider ollama \
+  --ca-base-url http://127.0.0.1:11434 \
+  --ca-model qwen3-coder \
+  --ca-no-update-check \
+  -p "Reply with OK only." --output-format text
+
+# Ollama Cloud, reading the key from an environment variable
+export OLLAMA_API_KEY="..."
+claude-any \
+  --ca-provider ollama-cloud \
+  --ca-api-key-env OLLAMA_API_KEY \
+  --ca-model glm-5.1 \
+  -p "Summarize this repository." --output-format text
+
+# vLLM Anthropic-compatible endpoint
+claude-any \
+  --ca-provider vllm \
+  --ca-base-url http://127.0.0.1:8000 \
+  --ca-model my-model \
+  --ca-context-window 65536 \
+  --ca-max-output-tokens 4096
+
+# NVIDIA hosted API Catalog through the local compatibility proxy
+export NVIDIA_API_KEY="..."
+claude-any \
+  --ca-provider nvidia-hosted \
+  --ca-api-key-env NVIDIA_API_KEY \
+  --ca-model moonshotai/kimi-k2.6 \
+  --ca-request-timeout-ms 1800000
+
+# Self-hosted NIM Anthropic-compatible endpoint
+claude-any \
+  --ca-provider self-hosted-nim \
+  --ca-base-url http://127.0.0.1:8000 \
+  --ca-model model \
+  --ca-api-key not-used
+```
+
+Passing Claude Code arguments:
+
+```sh
+# Everything not recognized as --ca-* is passed through to Claude Code.
+claude-any --ca-provider ollama-cloud -p "Write a short status report." --output-format text
+
+# Use -- when you want to visually separate Claude Any setup from Claude args.
+claude-any --ca-provider ollama-cloud --ca-model glm-5.1 -- -p "Reply OK" --output-format text
+```
+
+Compatibility tests without the menu:
+
+```sh
+# Auto mode: fast default. NVIDIA hosted uses a text-only quick test.
+claude-any test 60 auto
+
+# Smoke mode: text response plus required tool_use.
+claude-any test 120 smoke
+
+# Full mode: text, tool_use, and tool_result round trip.
+claude-any test 180 full
+```
+
+Service cleanup and status:
+
+```sh
+claude-any status
+claude-any stop
+```
+
+Common Claude Any setup flags:
+
+| Flag | Purpose |
+| --- | --- |
+| `--ca-provider PROVIDER` | Set provider and skip the menu for this launch. |
+| `--ca-model MODEL` | Set the current provider model. |
+| `--ca-base-url URL` | Set the current provider base URL. |
+| `--ca-api-key KEY` | Store the current provider API key directly. Prefer env vars for scripts. |
+| `--ca-api-key-env ENVVAR` | Store the current provider API key from an environment variable. |
+| `--ca-set-api-key PROVIDER KEY` | Store a key for a specific provider. |
+| `--ca-set-api-key-env PROVIDER ENVVAR` | Store a provider key from an environment variable. |
+| `--ca-max-output-tokens VALUE` | Set provider output-token cap. |
+| `--ca-context-window VALUE` | Set provider/router context-window cap where supported. |
+| `--ca-request-timeout-ms VALUE` | Set upstream request timeout in milliseconds. |
+| `--ca-ollama-num-ctx VALUE` | Set Ollama `num_ctx`. |
+| `--ca-ollama-ctx-range MIN MAX` | Set Ollama auto context range. |
+| `--ca-ollama-option KEY=VALUE` | Set an Ollama option such as `temperature=0.3`. |
+| `--ca-web-search` / `--ca-no-web-search` | Force-enable or disable web-search MCP for this launch. |
+| `--ca-disable-skills` / `--ca-enable-skills` | Control Claude Code skills for this launch. |
+| `--ca-no-update-check` | Skip the Claude Code update check. |
+| `--ca-status` | Print status and exit. |
+| `--ca-stop` | Stop managed router/proxy services and exit. |
+
+Notes for automation:
+
+- `--ca-api-key-env` avoids putting secrets directly in shell history.
+- `claude-any stop` is safe to run before scripted tests to remove stale
+  router/proxy processes.
+- Use `claude-any test 60 auto` for a quick readiness check and reserve
+  `claude-any test 180 full` for deeper provider validation.
+- Headless flags persist in `~/.config/claude-any/config.json`, so the next
+  interactive launch starts from the same provider/model settings.
+
+## Recommended Uses
+
+Claude Any is a good fit for slower background work where steady throughput
+matters more than instant interaction:
+
+- Docker host maintenance and cleanup.
+- Windows, Linux, and remote server administration.
+- Finding unused files and turning cleanup into repeatable scripts.
+- Periodic security checklists and configuration review.
+- Log review for failed sign-in attempts, exposed services, suspicious access,
+  and other intrusion indicators.
+- Noisy Windows Event Log review, including possible virus, ransomware,
+  brute-force, and remote-access intrusion attempts.
+- Drafting operational reports from command output and logs.
+- Turning requests like "install PostgreSQL in a Docker container" or "analyze
+  today's Docker logs and email me a report" into commands, scripts, scheduled
+  jobs, and summaries.
+
+### Tiered Supervision Pattern
+
+A practical operating pattern is to combine models by cost and capability:
+
+- Small or cheaper models watch logs, detect possible issues, and prepare first
+  summaries.
+- A larger model reviews the findings, writes policy, decides priority, and
+  plans the response.
+- Small models then execute routine commands, cleanup, reporting, or scheduled
+  checks under the larger model's supervision.
+
+It is not a replacement for dedicated monitoring, EDR, SIEM, or security
+products. It is useful as an operator assistant that can inspect logs, propose
+scripts, summarize findings, and produce readable reports while preserving
+premium Claude/Codex tokens for harder work.
+Used this way, Claude Any can become a free or low-cost system security watcher
+for routine checks and summaries.
+
+## Web Search
+
+Non-native providers may not have Claude Code's remote web-search capability.
+Claude Any can wire separate MCP tools for DuckDuckGo search and URL fetch so
+agents can still perform web research through explicit tools.
+
+## Service Lifecycle
+
+Claude Any starts provider helpers on demand rather than keeping every helper
+alive permanently.
+
+- `claude-any stop` stops managed Claude Any router and NVIDIA proxy processes.
+- When launching Claude Code, Claude Any starts only the services required by
+  the selected provider.
+- Ollama and Ollama Cloud router mode use the Claude Any router on
+  `127.0.0.1:8799`.
+- NVIDIA hosted router mode uses the Claude Any router on `127.0.0.1:8799` and
+  starts `nvd-claude-proxy` on `127.0.0.1:8788` only when that provider needs it.
+- For clean provider-switch testing, run `claude-any stop`, select the provider,
+  then launch or test. This avoids stale port ownership from old sessions.
+
+## Development Story
+
+Claude Any started because long Claude Code sessions can run out of premium
+tokens even on a high plan. The intent is to keep work moving while waiting for
+the next token window: slower but usable providers can handle summaries,
+research, journals, simple code, and delegated background tasks.
+
+During development, Anthropic-compatible Messages endpoints proved to be the
+cleanest integration path for Claude Code. Ollama, vLLM, and NIM can expose
+those routes. Generic OpenAI-compatible chat endpoints were not selected as the
+primary route because tool-call translation was less stable around parameters,
+tool results, repeated calls, retries, and model selection.
+
+The vLLM work also showed that a successful text response is not enough for
+Claude Code. The selected model and server need compatible tool-call formatting.
+In particular, Qwen3-Coder should use vLLM's `qwen3_xml` tool parser. Claude Any
+therefore expanded its compatibility test to cover text, `tool_use`, and
+`tool_result` phases.
+
+Local Qwen 3.6 27B Q4 runs were tested through Ollama and vLLM on RTX 5090 and
+MSI GB10-class hardware. They worked, but the speed belongs in a different
+category from native Claude Code or Codex. For this hybrid workflow, some
+hosted/cloud models from NVIDIA NIM and Ollama Cloud were more practical than
+expected.
+
+## Demo Assets
+
+Demo images, GIF, and MP4 are generated from a script:
+
+```sh
+python scripts/make_demo_assets.py
+```
+
+Generated files live in `docs/assets/`.
+
+## Troubleshooting
+
+- If the first request says a model does not exist, re-open the menu and select
+  a model that the current provider actually serves.
+- If Ollama Cloud returns authentication errors, check `OLLAMA_API_KEY` or use
+  the API key menu.
+- If local Ollama cloud models fail, run `ollama signin` on the Ollama host.
+- If vLLM or NIM returns model `404`, map Claude Code's model aliases to the
+  served model name or select the custom model entry.
+- If vLLM tool calls fail, verify both model support and the vLLM
+  `--tool-call-parser`/chat-template combination. Qwen3-Coder should start with
+  `--enable-auto-tool-choice --tool-call-parser qwen3_xml`.
+- If Claude Code update checks fail due to disk space, clean local caches or
+  skip the check with `--ca-no-update-check`.
+
+## Security Checklist
+
+- Do not commit `~/.config/claude-any/`.
+- Do not commit API keys, tokens, screenshots containing secrets, or router logs.
+- Prefer environment variables for keys in automation.
+- Revoke and rotate any key that was pasted into chat, logs, or issue reports.

package/install.ps1

@@ -0,0 +1,24 @@
+$ErrorActionPreference = "Stop"
+
+$prefix = if ($env:PREFIX) { $env:PREFIX } else { Join-Path $HOME ".local" }
+$shareDir = if ($env:CLAUDE_ANY_HOME) { $env:CLAUDE_ANY_HOME } else { Join-Path $prefix "share\claude-any" }
+$binDir = Join-Path $prefix "bin"
+
+New-Item -ItemType Directory -Force -Path $shareDir, $binDir | Out-Null
+
+Copy-Item -Force "claude_any.py" (Join-Path $shareDir "claude_any.py")
+Copy-Item -Force "claude-any-menu.py" (Join-Path $binDir "claude-any-menu.py")
+Copy-Item -Force "claude-any-tool-guard.py" (Join-Path $binDir "claude-any-tool-guard.py")
+Copy-Item -Force "claude-any" (Join-Path $binDir "claude-any")
+Copy-Item -Force "claude-any.cmd" (Join-Path $binDir "claude-any.cmd")
+Copy-Item -Force "claude-any.ps1" (Join-Path $binDir "claude-any.ps1")
+Copy-Item -Force "claude-anyctl" (Join-Path $binDir "claude-anyctl")
+Copy-Item -Force "claude-anyctl.cmd" (Join-Path $binDir "claude-anyctl.cmd")
+Copy-Item -Force "claude-anyctl.ps1" (Join-Path $binDir "claude-anyctl.ps1")
+Copy-Item -Force "claude-any-stop" (Join-Path $binDir "claude-any-stop")
+Copy-Item -Force "claude-any-stop.cmd" (Join-Path $binDir "claude-any-stop.cmd")
+Copy-Item -Force "claude-any-stop.ps1" (Join-Path $binDir "claude-any-stop.ps1")
+
+Write-Host "Installed Claude Any to $shareDir"
+Write-Host "Add $binDir to PATH if claude-any is not found."
+

package/install.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env sh
+set -eu
+
+PREFIX="${PREFIX:-"$HOME/.local"}"
+SHARE_DIR="${CLAUDE_ANY_HOME:-"$PREFIX/share/claude-any"}"
+BIN_DIR="$PREFIX/bin"
+
+mkdir -p "$SHARE_DIR" "$BIN_DIR"
+
+install -m 755 claude_any.py "$SHARE_DIR/claude_any.py"
+install -m 755 claude-any-menu.py "$BIN_DIR/claude-any-menu"
+install -m 755 claude-any-tool-guard.py "$BIN_DIR/claude-any-tool-guard"
+install -m 755 claude-any "$BIN_DIR/claude-any"
+install -m 755 claude-anyctl "$BIN_DIR/claude-anyctl"
+install -m 755 claude-any-stop "$BIN_DIR/claude-any-stop"
+
+printf 'Installed Claude Any to %s\n' "$SHARE_DIR"
+printf 'Launch with: %s/claude-any\n' "$BIN_DIR"
+

package/npm-bin/claude-any-stop.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+"use strict";
+
+process.env.CLAUDE_ANY_NPM_MODE = "cli";
+process.argv.push("stop");
+require("./run-claude-any");

package/npm-bin/claude-any.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+
+process.env.CLAUDE_ANY_NPM_MODE = "cli";
+require("./run-claude-any");

package/npm-bin/claude-anyctl.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+
+process.env.CLAUDE_ANY_NPM_MODE = "";
+require("./run-claude-any");

package/npm-bin/run-claude-any.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+const root = path.resolve(__dirname, "..");
+const script = path.join(root, "claude_any.py");
+const extra = process.argv.slice(2);
+const mode = Object.prototype.hasOwnProperty.call(process.env, "CLAUDE_ANY_NPM_MODE")
+  ? process.env.CLAUDE_ANY_NPM_MODE
+  : "cli";
+
+function candidates() {
+  if (process.env.CLAUDE_ANY_PYTHON) {
+    return [[process.env.CLAUDE_ANY_PYTHON, []]];
+  }
+  if (process.platform === "win32") {
+    return [
+      ["py", ["-3"]],
+      ["python", []],
+      ["python3", []],
+    ];
+  }
+  return [
+    ["python3", []],
+    ["python", []],
+  ];
+}
+
+let lastError = null;
+for (const [command, prefix] of candidates()) {
+  const scriptArgs = mode ? [mode, ...extra] : extra;
+  const args = [...prefix, script, ...scriptArgs];
+  const result = spawnSync(command, args, { stdio: "inherit" });
+  if (result.error && result.error.code === "ENOENT") {
+    lastError = result.error;
+    continue;
+  }
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  process.exit(result.status ?? 0);
+}
+
+console.error("Claude Any requires Python 3.10+.");
+if (lastError) {
+  console.error(lastError.message);
+}
+process.exit(1);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@oneciel-ai/claude-any",
+  "version": "0.1.24",
+  "description": "Claude Code provider selector for Anthropic, Ollama, Ollama Cloud, vLLM, NVIDIA hosted, and self-hosted NIM.",
+  "license": "MIT",
+  "author": "One Ciel LLC",
+  "homepage": "https://github.com/OneCielAI/claude-any#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneCielAI/claude-any.git"
+  },
+  "bugs": {
+    "url": "https://github.com/OneCielAI/claude-any/issues"
+  },
+  "type": "commonjs",
+  "bin": {
+    "claude-any": "npm-bin/claude-any.js",
+    "claude-anyctl": "npm-bin/claude-anyctl.js",
+    "claude-any-stop": "npm-bin/claude-any-stop.js"
+  },
+  "files": [
+    "claude_any.py",
+    "claude-any-menu.py",
+    "claude-any-tool-guard.py",
+    "npm-bin/",
+    "install.sh",
+    "install.ps1",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "docs/"
+  ],
+  "scripts": {
+    "test": "python -m py_compile claude_any.py claude-any-menu.py claude-any-tool-guard.py scripts/make_demo_assets.py",
+    "lint": "python -m ruff check .",
+    "demo:assets": "python scripts/make_demo_assets.py"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}