cloding 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,102 @@
+# ⚡ cloding
+
+**Claude Code with any model via OpenRouter.**
+
+Claude Code costs $5/$25 per Mtok. Qwen 3 Coder costs $0.07/$0.30. That's 71x cheaper on input, 83x cheaper on output. You'd be an idiot not to use it at scale.
+
+Cloding lets you run Claude Code — tools, file editing, terminal access, the whole thing — with any OpenRouter model. Same experience, fraction of the cost. Zero dependencies, zero overhead. It sets 4 env vars and spawns `claude`. That's it.
+
+```
+npm install -g cloding
+```
+
+## Quick Start
+
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-your-key-here
+cloding
+```
+
+You're now running Claude Code with Qwen 3 Coder at **$0.07/Mtok input** instead of $5/Mtok.
+
+## Usage
+
+```bash
+cloding                              # Interactive session with Qwen (default)
+cloding -m haiku                     # Use Claude Haiku 4.5
+cloding -m sonnet                    # Use Claude Sonnet 4
+cloding -m opus                      # Use Claude Opus 4.6
+cloding -m deepseek                  # Use DeepSeek Coder V3
+cloding -p "fix the login bug"       # Non-interactive, single prompt
+cloding --list-models                # Show all models with pricing
+cloding -m meta-llama/llama-4-scout  # Any OpenRouter model ID works
+```
+
+All Claude Code flags pass through:
+```bash
+cloding --allowedTools Read,Write,Bash
+```
+
+## Models & Cost
+
+| Shortcut | Model | Input $/Mtok | Output $/Mtok | vs Claude Code |
+|----------|-------|-------------|---------------|----------------|
+| `qwen` | Qwen 3 Coder | $0.07 | $0.30 | **71x cheaper** |
+| `deepseek` | DeepSeek Coder V3 | $0.14 | $0.28 | **36x cheaper** |
+| `haiku` | Claude Haiku 4.5 | $0.80 | $4.00 | 6x cheaper |
+| `gemini` | Gemini 2.5 Pro | $1.25 | $10.00 | 4x cheaper |
+| `sonnet` | Claude Sonnet 4 | $3.00 | $15.00 | 1.7x cheaper |
+| `opus` | Claude Opus 4.6 | $15.00 | $75.00 | 3x more expensive |
+
+> A 30-minute coding session that costs ~$5 with Claude Code costs ~$0.07 with Qwen. Same tools, same workflow.
+
+## Docker Mode
+
+When you run Claude Code, it has full access to your machine — your files, your terminal, your `.env`, your SSH keys, everything. It's an LLM agent with root-level power and nothing about that is secure. Nobody seems to care that these models are looking at all your stuff and running wild.
+
+Docker mode puts it in a box. The model can only touch the workspace you mount and nothing else. It can't read your secrets, wreck your system, or do anything outside the container. Non-root user, no access to your host filesystem, network isolated.
+
+```bash
+cloding docker build                    # Build image (one-time)
+cloding docker shell                    # Interactive session
+cloding docker run "fix the bug"        # Run a prompt
+cloding docker run -m haiku "prompt"    # Specific model
+cloding docker run -w ./myproject       # Mount workspace
+cloding docker run --memory 4g --cpus 2 # Resource limits
+cloding docker status                   # Show running containers
+cloding docker stop                     # Stop all containers
+cloding docker clean                    # Remove stopped containers
+```
+
+Your workspace gets mounted read-write at `/workspace` inside the container. That's the only thing the model can touch.
+
+## Pipeline Mode
+
+Multi-stage coding pipeline: Plan → Explore → Code → Review, with parallel fan-out. Assign different models to different stages — Opus for planning, Qwen for coding.
+
+```bash
+cd pipeline && pip install -e .    # Requires Python 3.11+
+cloding pipeline "Add auth" --workspace ./myapp --no-docker
+cloding pipeline -c configs/qwen-fanout.yaml "Refactor the DB layer"
+```
+
+8 pipeline configs included: default, quick, fan-out, opus-plan+qwen-code, human-in-the-loop, and more.
+
+## Configuration
+
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-your-key-here   # Required
+export CLODING_DEFAULT_MODEL=qwen                    # Optional (default: qwen)
+```
+
+Add custom model shortcuts by editing `models.json`.
+
+## Prerequisites
+
+- **Node.js 18+**
+- **Claude Code**: `npm install -g @anthropic-ai/claude-code`
+- **OpenRouter API key**: [openrouter.ai/keys](https://openrouter.ai/keys)
+
+## License
+
+MIT

package/bin/cloding.js

@@ -0,0 +1,871 @@
+#!/usr/bin/env node
+
+/**
+ * cloding — Claude Code with any model via OpenRouter.
+ *
+ * Sets the right env vars and spawns `claude` so you can use
+ * Qwen, Haiku, Sonnet, or any OpenRouter model at a fraction of the cost.
+ *
+ * Usage:
+ *   cloding                         # Interactive with default model (Qwen)
+ *   cloding -m haiku                # Use a different model
+ *   cloding -p "fix the bug"        # Non-interactive single prompt
+ *   cloding --list-models           # Show available models
+ *   cloding pipeline "Add auth"     # Run the full pipeline
+ *   cloding docker build            # Build Docker image
+ *   cloding docker run "prompt"     # Run in a Docker container
+ */
+
+const { spawn, execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+// ──────────────────────────────────────────────
+// .env loader (no dependencies)
+// ──────────────────────────────────────────────
+function loadEnvFile() {
+  // Search for .env in: cwd, then cloding package root
+  const candidates = [
+    path.join(process.cwd(), ".env"),
+    path.join(__dirname, "..", ".env"),
+  ];
+
+  for (const envPath of candidates) {
+    if (fs.existsSync(envPath)) {
+      const lines = fs.readFileSync(envPath, "utf8").split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        let val = trimmed.slice(eqIdx + 1).trim();
+        // Strip surrounding quotes
+        if (
+          (val.startsWith('"') && val.endsWith('"')) ||
+          (val.startsWith("'") && val.endsWith("'"))
+        ) {
+          val = val.slice(1, -1);
+        }
+        // Don't override existing env vars
+        if (!process.env[key]) {
+          process.env[key] = val;
+        }
+      }
+      return envPath;
+    }
+  }
+  return null;
+}
+
+// ──────────────────────────────────────────────
+// Model registry
+// ──────────────────────────────────────────────
+function loadModels() {
+  const modelsPath = path.join(__dirname, "..", "models.json");
+  try {
+    return JSON.parse(fs.readFileSync(modelsPath, "utf8"));
+  } catch {
+    console.error("Error: Could not load models.json");
+    process.exit(1);
+  }
+}
+
+// ──────────────────────────────────────────────
+// Arg parsing (lightweight, no dependencies)
+// ──────────────────────────────────────────────
+function parseArgs(argv) {
+  const args = {
+    model: null,
+    prompt: null,
+    listModels: false,
+    version: false,
+    help: false,
+    pipeline: false,
+    pipelineArgs: [],
+    docker: false,
+    dockerSubcommand: null,
+    dockerArgs: [],
+    claudeArgs: [], // passthrough args for claude CLI
+  };
+
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+
+    if (arg === "pipeline") {
+      args.pipeline = true;
+      args.pipelineArgs = argv.slice(i + 1);
+      break;
+    }
+
+    if (arg === "docker") {
+      args.docker = true;
+      args.dockerSubcommand = argv[i + 1] || "help";
+      args.dockerArgs = argv.slice(i + 2);
+      break;
+    }
+
+    switch (arg) {
+      case "-m":
+      case "--model":
+        if (i + 1 >= argv.length) {
+          console.error("Error: --model requires a value.\n  Usage: cloding -m <model>");
+          process.exit(1);
+        }
+        args.model = argv[++i];
+        break;
+      case "-p":
+      case "--prompt":
+        if (i + 1 >= argv.length) {
+          console.error("Error: --prompt requires a value.\n  Usage: cloding -p \"your prompt\"");
+          process.exit(1);
+        }
+        args.prompt = argv[++i];
+        break;
+      case "--list-models":
+        args.listModels = true;
+        break;
+      case "-v":
+      case "--version":
+        args.version = true;
+        break;
+      case "-h":
+      case "--help":
+        args.help = true;
+        break;
+      default:
+        args.claudeArgs.push(arg);
+        break;
+    }
+    i++;
+  }
+
+  return args;
+}
+
+// ──────────────────────────────────────────────
+// Display helpers
+// ──────────────────────────────────────────────
+function printVersion() {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8")
+  );
+  console.log(`cloding v${pkg.version}`);
+}
+
+function printHelp() {
+  console.log(`
+cloding — Claude Code with any model via OpenRouter
+
+USAGE:
+  cloding                            Interactive session (default: Qwen)
+  cloding -m haiku                   Use a specific model
+  cloding -p "fix the bug"           Non-interactive single prompt
+  cloding --list-models              Show available models and costs
+  cloding pipeline "Add auth"        Run the full pipeline (requires Python)
+  cloding docker <command>           Docker container management
+
+OPTIONS:
+  -m, --model <name|id>   Model shortcut or full OpenRouter model ID
+  -p, --prompt <text>     Run non-interactively with a single prompt
+      --list-models       Show available models with pricing
+  -v, --version           Show version
+  -h, --help              Show this help
+
+DOCKER COMMANDS:
+  cloding docker build               Build the cloding Docker image
+  cloding docker run "prompt"         Run a prompt in a container
+  cloding docker shell                Interactive claude session in a container
+  cloding docker status               Show running cloding containers
+  cloding docker stop                 Stop all cloding containers
+  cloding docker clean                Remove stopped cloding containers
+  cloding docker help                 Show Docker help
+
+MODELS (shortcuts):
+  qwen       Qwen 3 Coder        $0.07/$0.30 per Mtok  (default, ~250x cheaper)
+  haiku      Claude Haiku 4.5     $0.80/$4.00 per Mtok
+  sonnet     Claude Sonnet 4      $3.00/$15.00 per Mtok
+  opus       Claude Opus 4.6      $15.00/$75.00 per Mtok
+  deepseek   DeepSeek Coder V3    $0.14/$0.28 per Mtok
+  gemini     Gemini 2.5 Pro       $1.25/$10.00 per Mtok
+
+  Or pass any OpenRouter model ID:
+    cloding -m meta-llama/llama-4-scout
+
+ENVIRONMENT:
+  OPENROUTER_API_KEY       Required. Your OpenRouter API key.
+  CLODING_DEFAULT_MODEL    Optional. Default model shortcut (default: qwen).
+
+EXAMPLES:
+  cloding                            # Start coding with Qwen ($0.07/Mtok)
+  cloding -m haiku                   # Quick task with Haiku
+  cloding -m opus -p "Review arch"   # One-shot with Opus
+  cloding docker build               # Build Docker image first
+  cloding docker run "Fix the bug"   # Run isolated in Docker
+  cloding docker shell               # Interactive Docker session
+  cloding pipeline "Add auth" -c configs/qwen-fanout.yaml
+
+All other arguments are passed through to claude.
+`);
+}
+
+function printModels(models) {
+  console.log("\nAvailable models:\n");
+  console.log(
+    "  Shortcut    Model                    Input $/Mtok   Output $/Mtok  vs Opus"
+  );
+  console.log(
+    "  ─────────── ──────────────────────── ────────────── ────────────── ───────"
+  );
+
+  // Opus cost for comparison
+  const opusOut = models.opus ? models.opus.out : 75.0;
+
+  for (const [shortcut, m] of Object.entries(models)) {
+    const savings = opusOut / m.out;
+    const savingsStr =
+      shortcut === "opus" ? "    baseline" : `    ${savings.toFixed(0)}x cheaper`;
+    console.log(
+      `  ${shortcut.padEnd(11)} ${m.name.padEnd(24)} $${m.in.toFixed(2).padStart(6)}         $${m.out.toFixed(2).padStart(6)}${savingsStr}`
+    );
+  }
+
+  console.log(
+    "\n  Use: cloding -m <shortcut>   or   cloding -m <openrouter-model-id>\n"
+  );
+}
+
+// ──────────────────────────────────────────────
+// Resolve model to OpenRouter model ID
+// ──────────────────────────────────────────────
+function resolveModel(modelArg, models) {
+  if (!modelArg) {
+    // Use default from env, or fall back to qwen
+    const defaultModel = process.env.CLODING_DEFAULT_MODEL || "qwen";
+    return resolveModel(defaultModel, models);
+  }
+
+  // Check shortcuts first
+  if (models[modelArg.toLowerCase()]) {
+    return models[modelArg.toLowerCase()];
+  }
+
+  // Assume it's a full OpenRouter model ID (e.g. "meta-llama/llama-4-scout")
+  return {
+    id: modelArg,
+    name: modelArg,
+    in: 0,
+    out: 0,
+    description: "Custom model",
+  };
+}
+
+// ──────────────────────────────────────────────
+// Docker helpers
+// ──────────────────────────────────────────────
+const DOCKER_IMAGE = "cloding:latest";
+const DOCKER_NETWORK = "cloding-net";
+
+function dockerAvailable() {
+  try {
+    execSync("docker --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function dockerImageExists() {
+  try {
+    // Safe: no user input in this command, just a constant image name
+    const result = execSync(`docker images -q ${DOCKER_IMAGE}`, {
+      encoding: "utf8",
+    });
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function getDockerfilePath() {
+  // Check relative to package: pipeline/docker/Dockerfile
+  const bundled = path.join(__dirname, "..", "pipeline", "docker");
+  if (fs.existsSync(path.join(bundled, "Dockerfile"))) {
+    return bundled;
+  }
+  // Check cwd
+  const cwdDocker = path.join(process.cwd(), "pipeline", "docker");
+  if (fs.existsSync(path.join(cwdDocker, "Dockerfile"))) {
+    return cwdDocker;
+  }
+  return null;
+}
+
+function ensureNetwork() {
+  try {
+    // Safe: constant network name, no user input. Uses spawnSync for safety.
+    const result = require("child_process").spawnSync(
+      "docker", ["network", "create", DOCKER_NETWORK],
+      { stdio: "ignore" }
+    );
+    // Ignore errors — network may already exist
+  } catch {
+    // Network already exists, that's fine
+  }
+}
+
+function printDockerHelp() {
+  console.log(`
+cloding docker — Run Claude Code in isolated Docker containers
+
+COMMANDS:
+  cloding docker build                         Build the cloding Docker image
+  cloding docker run "your prompt here"        Run a prompt in a fresh container
+  cloding docker run -m haiku "prompt"         Run with a specific model
+  cloding docker shell                         Interactive claude session in Docker
+  cloding docker shell -m sonnet               Interactive with specific model
+  cloding docker status                        Show running cloding containers
+  cloding docker stop                          Stop all running cloding containers
+  cloding docker clean                         Remove all stopped cloding containers
+  cloding docker help                          Show this help
+
+OPTIONS (for run/shell):
+  -m, --model <name>       Model shortcut or OpenRouter ID (default: qwen)
+  -w, --workspace <path>   Mount a local directory as /workspace (default: cwd)
+  --memory <limit>         Container memory limit (default: 2g)
+  --cpus <limit>           Container CPU limit (default: 1.0)
+  --name <name>            Custom container name
+  --no-rm                  Don't auto-remove container on exit
+
+EXAMPLES:
+  cloding docker build
+  cloding docker run "Add error handling to src/api.js"
+  cloding docker run -m haiku -w ./myproject "Fix the tests"
+  cloding docker shell -w /home/user/code
+  cloding docker status
+  cloding docker stop
+
+NOTES:
+  - Each container gets its own isolated environment
+  - Workspace is mounted at /workspace inside the container
+  - Containers auto-remove on exit (use --no-rm to keep them)
+  - Containers run as non-root user 'coder' for security
+  - Resource limits: 2GB RAM, 1 CPU core (configurable)
+`);
+}
+
+function dockerBuild() {
+  const dockerDir = getDockerfilePath();
+  if (!dockerDir) {
+    console.error(
+      "Error: Dockerfile not found.\n\n" +
+        "Expected at: pipeline/docker/Dockerfile\n" +
+        "Make sure you have the full cloding package with Docker support.\n"
+    );
+    process.exit(1);
+  }
+
+  console.log(`\x1b[36m⚡ cloding\x1b[0m Building Docker image: ${DOCKER_IMAGE}`);
+  console.log(`  Dockerfile: ${path.join(dockerDir, "Dockerfile")}\n`);
+
+  const child = spawn("docker", ["build", "-t", DOCKER_IMAGE, dockerDir], {
+    stdio: "inherit",
+  });
+
+  child.on("exit", (code) => {
+    if (code === 0) {
+      console.log(
+        `\n\x1b[32m✓ Image ${DOCKER_IMAGE} built successfully!\x1b[0m`
+      );
+      console.log("  Run: cloding docker shell");
+      console.log('  Run: cloding docker run "your prompt here"\n');
+    } else {
+      console.error(`\n\x1b[31m✗ Build failed (exit code ${code})\x1b[0m`);
+    }
+    process.exit(code ?? 0);
+  });
+
+  child.on("error", (err) => {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+function dockerRun(dockerArgs, models, interactive) {
+  // Parse docker run/shell args
+  let modelArg = null;
+  let workspace = process.cwd();
+  let memory = "2g";
+  let cpus = "1.0";
+  let containerName = null;
+  let autoRemove = true;
+  let prompt = null;
+  const extraClaudeArgs = [];
+
+  let i = 0;
+  while (i < dockerArgs.length) {
+    const arg = dockerArgs[i];
+    switch (arg) {
+      case "-m":
+      case "--model":
+        if (i + 1 >= dockerArgs.length) { console.error("Error: --model requires a value."); process.exit(1); }
+        modelArg = dockerArgs[++i];
+        break;
+      case "-w":
+      case "--workspace":
+        if (i + 1 >= dockerArgs.length) { console.error("Error: --workspace requires a path."); process.exit(1); }
+        workspace = path.resolve(dockerArgs[++i]);
+        break;
+      case "--memory":
+        if (i + 1 >= dockerArgs.length) { console.error("Error: --memory requires a value (e.g. 2g)."); process.exit(1); }
+        memory = dockerArgs[++i];
+        break;
+      case "--cpus":
+        if (i + 1 >= dockerArgs.length) { console.error("Error: --cpus requires a value (e.g. 1.0)."); process.exit(1); }
+        cpus = dockerArgs[++i];
+        break;
+      case "--name":
+        if (i + 1 >= dockerArgs.length) { console.error("Error: --name requires a value."); process.exit(1); }
+        containerName = dockerArgs[++i];
+        break;
+      case "--no-rm":
+        autoRemove = false;
+        break;
+      default:
+        // First unrecognized non-flag arg is the prompt (for 'run' mode)
+        if (!interactive && !prompt && !arg.startsWith("-")) {
+          prompt = arg;
+        } else {
+          extraClaudeArgs.push(arg);
+        }
+        break;
+    }
+    i++;
+  }
+
+  // Validate
+  if (!interactive && !prompt) {
+    console.error(
+      'Error: No prompt provided.\n\n' +
+        '  Usage: cloding docker run "your prompt here"\n'
+    );
+    process.exit(1);
+  }
+
+  if (!dockerImageExists()) {
+    console.error(
+      `Error: Docker image '${DOCKER_IMAGE}' not found.\n\n` +
+        "  Build it first: cloding docker build\n"
+    );
+    process.exit(1);
+  }
+
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    console.error(
+      "Error: OPENROUTER_API_KEY not set.\n\n" +
+        "Get your key at https://openrouter.ai/keys\n" +
+        "Then: export OPENROUTER_API_KEY=sk-or-v1-...\n"
+    );
+    process.exit(1);
+  }
+
+  // Resolve model
+  const model = resolveModel(modelArg, models);
+
+  // Validate workspace exists
+  if (!fs.existsSync(workspace)) {
+    console.error(`Error: Workspace directory not found: ${workspace}`);
+    process.exit(1);
+  }
+
+  // Ensure network exists
+  ensureNetwork();
+
+  // Generate container name if not provided
+  if (!containerName) {
+    const suffix = Date.now().toString(36);
+    containerName = `cloding-${interactive ? "shell" : "run"}-${suffix}`;
+  }
+
+  // Build docker command — uses spawn with argument array (safe, no shell injection)
+  const cmd = ["docker", "run"];
+
+  if (interactive) {
+    cmd.push("-it");
+  }
+
+  if (autoRemove) {
+    cmd.push("--rm");
+  }
+
+  cmd.push(
+    "--name", containerName,
+    "--network", DOCKER_NETWORK,
+    "--memory", memory,
+    "--cpus", cpus,
+    "-v", `${workspace}:/workspace`,
+    "-e", `ANTHROPIC_BASE_URL=https://openrouter.ai/api`,
+    "-e", `ANTHROPIC_AUTH_TOKEN=${apiKey}`,
+    "-e", `ANTHROPIC_API_KEY=`,
+    "-e", `ANTHROPIC_MODEL=${model.id}`,
+    "-e", `CLAUDECODE=`,
+    DOCKER_IMAGE
+  );
+
+  // Add claude args
+  if (!interactive && prompt) {
+    cmd.push("-p", prompt);
+  }
+  cmd.push(...extraClaudeArgs);
+
+  // Print banner
+  const costInfo =
+    model.in > 0 ? ` ($${model.in}/$${model.out} per Mtok)` : "";
+  console.log(
+    `\x1b[36m⚡ cloding docker\x1b[0m → ${model.name}${costInfo}`
+  );
+  console.log(`  Container: ${containerName}`);
+  console.log(`  Workspace: ${workspace} → /workspace`);
+  console.log(`  Resources: ${memory} RAM, ${cpus} CPUs`);
+
+  if (model.in > 0 && models.opus) {
+    const savings = (models.opus.out / model.out).toFixed(0);
+    if (savings > 1) {
+      console.log(`  \x1b[32m${savings}x cheaper than Opus\x1b[0m`);
+    }
+  }
+  console.log("");
+
+  // Spawn docker — uses argument array (no shell interpretation)
+  const child = spawn(cmd[0], cmd.slice(1), {
+    stdio: "inherit",
+  });
+
+  child.on("exit", (code) => process.exit(code ?? 0));
+  child.on("error", (err) => {
+    console.error(`Error launching Docker: ${err.message}`);
+    console.error("Make sure Docker is installed and running.");
+    process.exit(1);
+  });
+}
+
+function dockerStatus() {
+  console.log("\x1b[36m⚡ cloding\x1b[0m Running containers:\n");
+
+  try {
+    // Safe: uses spawnSync with argument array, no shell injection possible
+    const result = require("child_process").spawnSync(
+      "docker",
+      ["ps", "--filter", "name=cloding", "--format", "table {{.Names}}\t{{.Status}}\t{{.Image}}\t{{.Ports}}"],
+      { encoding: "utf8" }
+    );
+
+    if (result.stdout && result.stdout.trim()) {
+      console.log(result.stdout);
+    } else {
+      console.log("  No running cloding containers.\n");
+      console.log("  Start one with:");
+      console.log('    cloding docker run "your prompt"');
+      console.log("    cloding docker shell\n");
+    }
+  } catch {
+    console.error(
+      "Error: Could not list containers. Is Docker running?"
+    );
+    process.exit(1);
+  }
+}
+
+function dockerStop() {
+  console.log("\x1b[36m⚡ cloding\x1b[0m Stopping all cloding containers...\n");
+
+  try {
+    // Safe: uses spawnSync with argument array
+    const result = require("child_process").spawnSync(
+      "docker",
+      ["ps", "-q", "--filter", "name=cloding"],
+      { encoding: "utf8" }
+    );
+
+    const ids = (result.stdout || "")
+      .trim()
+      .split("\n")
+      .filter((id) => id);
+
+    if (ids.length === 0) {
+      console.log("  No running cloding containers to stop.\n");
+      return;
+    }
+
+    for (const id of ids) {
+      try {
+        const inspect = require("child_process").spawnSync(
+          "docker", ["inspect", "--format", "{{.Name}}", id],
+          { encoding: "utf8" }
+        );
+        const name = (inspect.stdout || id).trim().replace(/^\//, "");
+
+        require("child_process").spawnSync(
+          "docker", ["stop", "-t", "5", id],
+          { stdio: "ignore" }
+        );
+        console.log(`  \x1b[32m✓\x1b[0m Stopped: ${name}`);
+      } catch {
+        console.log(`  \x1b[31m✗\x1b[0m Failed to stop: ${id}`);
+      }
+    }
+    console.log(`\n  Stopped ${ids.length} container(s).\n`);
+  } catch {
+    console.error("Error: Could not stop containers. Is Docker running?");
+    process.exit(1);
+  }
+}
+
+function dockerClean() {
+  console.log(
+    "\x1b[36m⚡ cloding\x1b[0m Cleaning up stopped cloding containers...\n"
+  );
+
+  try {
+    // Safe: uses spawnSync with argument array
+    const result = require("child_process").spawnSync(
+      "docker",
+      ["ps", "-aq", "--filter", "name=cloding", "--filter", "status=exited"],
+      { encoding: "utf8" }
+    );
+
+    const ids = (result.stdout || "")
+      .trim()
+      .split("\n")
+      .filter((id) => id);
+
+    if (ids.length === 0) {
+      console.log("  No stopped cloding containers to clean.\n");
+      return;
+    }
+
+    for (const id of ids) {
+      try {
+        const inspect = require("child_process").spawnSync(
+          "docker", ["inspect", "--format", "{{.Name}}", id],
+          { encoding: "utf8" }
+        );
+        const name = (inspect.stdout || id).trim().replace(/^\//, "");
+
+        require("child_process").spawnSync(
+          "docker", ["rm", id],
+          { stdio: "ignore" }
+        );
+        console.log(`  \x1b[32m✓\x1b[0m Removed: ${name}`);
+      } catch {
+        console.log(`  \x1b[31m✗\x1b[0m Failed to remove: ${id}`);
+      }
+    }
+    console.log(`\n  Cleaned ${ids.length} container(s).\n`);
+  } catch {
+    console.error(
+      "Error: Could not clean containers. Is Docker running?"
+    );
+    process.exit(1);
+  }
+}
+
+// ──────────────────────────────────────────────
+// Docker dispatcher
+// ──────────────────────────────────────────────
+function handleDocker(args) {
+  if (!dockerAvailable()) {
+    console.error(
+      "Error: Docker not found.\n\n" +
+        "Install Docker Desktop:\n" +
+        "  https://docs.docker.com/get-docker/\n"
+    );
+    process.exit(1);
+  }
+
+  const models = loadModels();
+
+  switch (args.dockerSubcommand) {
+    case "build":
+      dockerBuild();
+      break;
+    case "run":
+      dockerRun(args.dockerArgs, models, false);
+      break;
+    case "shell":
+      dockerRun(args.dockerArgs, models, true);
+      break;
+    case "status":
+    case "ps":
+      dockerStatus();
+      break;
+    case "stop":
+      dockerStop();
+      break;
+    case "clean":
+    case "cleanup":
+    case "prune":
+      dockerClean();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      printDockerHelp();
+      break;
+    default:
+      console.error(
+        `Unknown docker command: ${args.dockerSubcommand}\n`
+      );
+      printDockerHelp();
+      process.exit(1);
+  }
+}
+
+// ──────────────────────────────────────────────
+// Main
+// ──────────────────────────────────────────────
+function main() {
+  // Load .env
+  loadEnvFile();
+
+  // Parse args (skip node and script path)
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.version) {
+    printVersion();
+    process.exit(0);
+  }
+
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const models = loadModels();
+
+  if (args.listModels) {
+    printModels(models);
+    process.exit(0);
+  }
+
+  // ── Docker mode ──
+  if (args.docker) {
+    handleDocker(args);
+    return;
+  }
+
+  // Validate API key
+  const apiKey = process.env.OPENROUTER_API_KEY;
+  if (!apiKey) {
+    console.error(
+      "Error: OPENROUTER_API_KEY not set.\n\n" +
+        "Get your key at https://openrouter.ai/keys\n" +
+        "Then either:\n" +
+        "  1. Create a .env file:  OPENROUTER_API_KEY=sk-or-v1-...\n" +
+        "  2. Set it:  export OPENROUTER_API_KEY=sk-or-v1-...\n"
+    );
+    process.exit(1);
+  }
+
+  // ── Pipeline mode ──
+  if (args.pipeline) {
+    const pipelineDir = path.join(__dirname, "..", "pipeline");
+    if (!fs.existsSync(pipelineDir)) {
+      console.error(
+        "Error: Pipeline not found. Install the full cloding package with Python support."
+      );
+      process.exit(1);
+    }
+
+    const pythonArgs = ["-m", "osq", ...args.pipelineArgs];
+    console.log(`Running pipeline: python ${pythonArgs.join(" ")}`);
+
+    const child = spawn("python", pythonArgs, {
+      cwd: pipelineDir,
+      stdio: "inherit",
+      env: { ...process.env },
+    });
+
+    child.on("exit", (code) => process.exit(code ?? 0));
+    child.on("error", (err) => {
+      console.error(`Error launching pipeline: ${err.message}`);
+      console.error("Make sure Python 3.11+ is installed.");
+      process.exit(1);
+    });
+    return;
+  }
+
+  // ── Simple mode: launch claude with OpenRouter ──
+  const model = resolveModel(args.model, models);
+
+  // Build env for claude
+  const claudeEnv = { ...process.env };
+  claudeEnv.ANTHROPIC_BASE_URL = "https://openrouter.ai/api";
+  claudeEnv.ANTHROPIC_AUTH_TOKEN = apiKey;
+  claudeEnv.ANTHROPIC_API_KEY = "";
+  claudeEnv.ANTHROPIC_MODEL = model.id;
+
+  // Don't inherit CLAUDECODE — prevents "cannot launch inside another session" error
+  delete claudeEnv.CLAUDECODE;
+
+  // Build claude args
+  const claudeArgs = [...args.claudeArgs];
+  if (args.prompt) {
+    claudeArgs.push("-p", args.prompt);
+  }
+
+  // Print banner
+  const shortcut = args.model || process.env.CLODING_DEFAULT_MODEL || "qwen";
+  const costInfo =
+    model.in > 0
+      ? ` ($${model.in}/$${model.out} per Mtok)`
+      : "";
+  console.log(`\x1b[36m⚡ cloding\x1b[0m → ${model.name}${costInfo}`);
+
+  if (model.in > 0 && models.opus) {
+    const savings = (models.opus.out / model.out).toFixed(0);
+    if (savings > 1) {
+      console.log(`\x1b[32m   ${savings}x cheaper than Opus\x1b[0m`);
+    }
+  }
+  console.log("");
+
+  // Launch claude
+  // On Windows, npm globals are .cmd shims that need shell resolution.
+  // We use spawn with shell:true but pass empty args array to avoid the
+  // DEP0190 deprecation — instead the args are baked into the command string.
+  const isWin = process.platform === "win32";
+  let child;
+  if (isWin) {
+    // Build full command string for shell execution
+    const parts = ["claude", ...claudeArgs.map((a) => `"${a}"`)];
+    child = spawn(parts.join(" "), {
+      stdio: "inherit",
+      env: claudeEnv,
+      shell: true,
+    });
+  } else {
+    child = spawn("claude", claudeArgs, {
+      stdio: "inherit",
+      env: claudeEnv,
+    });
+  }
+
+  child.on("exit", (code) => process.exit(code ?? 0));
+  child.on("error", (err) => {
+    if (err.code === "ENOENT") {
+      console.error(
+        "Error: 'claude' command not found.\n\n" +
+          "Install Claude Code first:\n" +
+          "  npm install -g @anthropic-ai/claude-code\n"
+      );
+    } else {
+      console.error(`Error launching claude: ${err.message}`);
+    }
+    process.exit(1);
+  });
+}
+
+main();

package/models.json

@@ -0,0 +1,44 @@
+{
+  "qwen": {
+    "id": "qwen/qwen3-coder-next",
+    "name": "Qwen 3 Coder",
+    "in": 0.07,
+    "out": 0.30,
+    "description": "Best value. Handles all Claude Code tools perfectly."
+  },
+  "haiku": {
+    "id": "anthropic/claude-haiku-4.5",
+    "name": "Claude Haiku 4.5",
+    "in": 0.80,
+    "out": 4.00,
+    "description": "Fast and capable. Good for exploration tasks."
+  },
+  "sonnet": {
+    "id": "anthropic/claude-sonnet-4",
+    "name": "Claude Sonnet 4",
+    "in": 3.00,
+    "out": 15.00,
+    "description": "Strong all-rounder. Good for complex coding."
+  },
+  "opus": {
+    "id": "anthropic/claude-opus-4.6",
+    "name": "Claude Opus 4.6",
+    "in": 15.00,
+    "out": 75.00,
+    "description": "Most capable. Use for architecture and planning."
+  },
+  "deepseek": {
+    "id": "deepseek/deepseek-coder-v3",
+    "name": "DeepSeek Coder V3",
+    "in": 0.14,
+    "out": 0.28,
+    "description": "Ultra-cheap alternative. Good for simple tasks."
+  },
+  "gemini": {
+    "id": "google/gemini-2.5-pro",
+    "name": "Gemini 2.5 Pro",
+    "in": 1.25,
+    "out": 10.00,
+    "description": "Google's flagship. Large context window."
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "cloding",
+  "version": "0.1.0",
+  "description": "Claude Code with any model via OpenRouter. Use Qwen, Haiku, Sonnet, or Opus at a fraction of the cost.",
+  "bin": {
+    "cloding": "./bin/cloding.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "openrouter",
+    "qwen",
+    "ai",
+    "coding",
+    "llm",
+    "cheap",
+    "cost-effective"
+  ],
+  "author": "Carlos",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/claudlos/cloding"
+  },
+  "homepage": "https://github.com/claudlos/cloding#readme",
+  "bugs": {
+    "url": "https://github.com/claudlos/cloding/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "models.json",
+    "README.md",
+    "LICENSE"
+  ]
+}