glm-mcp-claude 1.0.0

package/hooks/glm_subagent_router.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+// glm_subagent_router.mjs
+// PreToolUse hook for the Task (subagent) tool. Fires ONLY when a subagent is
+// about to be spawned -> zero token cost the rest of the time.
+//
+// It infers the task profile from the Task description/prompt, runs the shared
+// GLM-vs-Opus router logic, and injects a concise verdict as additionalContext
+// so the orchestrator can route cheap work to the `glm` subagent automatically.
+//
+// It NEVER blocks: on any error or unsupported field it simply exits 0.
+
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { readFileSync } from "node:fs";
+
+// Portable: resolve the router relative to this hook's own location.
+// Layout: <claude>/hooks/glm_subagent_router.mjs  +  <claude>/glm-mcp/src/router.js
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROUTER = resolve(HERE, "..", "glm-mcp", "src", "router.js");
+
+// Pull the most recent genuine human message from the transcript (skipping
+// tool_result turns), so we can detect when the user explicitly picked an agent.
+function lastUserText(transcriptPath) {
+  if (!transcriptPath) return "";
+  try {
+    const lines = readFileSync(transcriptPath, "utf8").trim().split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      let o;
+      try { o = JSON.parse(lines[i]); } catch { continue; }
+      const m = o.message || o;
+      if (o.type === "user" || m.role === "user") {
+        const c = m.content;
+        if (typeof c === "string") return c;
+        if (Array.isArray(c)) {
+          const texts = c.filter((b) => b && b.type === "text").map((b) => b.text);
+          if (texts.length) return texts.join("\n"); // else it's a tool_result turn -> keep scanning
+        }
+      }
+    }
+  } catch {}
+  return "";
+}
+
+// Did the user explicitly name an agent/model to use? Then honor it -- no nudge.
+function explicitAgentRequested(text) {
+  const t = (text || "").toLowerCase();
+  return (
+    /\b(use|using|with|via|run (?:this|it) (?:on|with)|delegate (?:this |it )?to|hand (?:this|it) to|switch to)\b[^.\n]*\b(glm|opus|sonnet|haiku|general[- ]purpose|explore|plan)\b/.test(t) ||
+    /\b(glm|opus|sonnet|haiku|general[- ]purpose)\b\s+(agent|sub-?agent|model)\b/.test(t)
+  );
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let d = "";
+    process.stdin.on("data", (c) => (d += c));
+    process.stdin.on("end", () => resolve(d));
+    // safety: if no stdin arrives, don't hang
+    setTimeout(() => resolve(d), 2000);
+  });
+}
+
+function inferProfile(text) {
+  const t = (text || "").toLowerCase();
+  const has = (...ks) => ks.some((k) => t.includes(k));
+  const extra = {};
+
+  // Cross-cutting condition flags (can co-exist with a task type).
+  if (has("screenshot", "image", "diagram", "this photo", "the picture", "gui ", "computer use")) extra.vision = true;
+  if (has("中文", "chinese", "mandarin", "bilingual", "translate to chinese")) extra.chinese = true;
+  if (has("undocumented", "internal api", "proprietary api", "niche", "obscure api", "post-cutoff", "brand-new api", "newly released")) extra.unfamiliarApi = true;
+  if (has("parallel", "concurrent", "fan out", "fan-out", "at the same time", "multiple agents")) extra.needsParallel = true;
+  if (has("entire repo", "whole codebase", "across the codebase", "many files", "multi-hour", "long-running", "fully autonomous")) { extra.longHorizon = true; }
+  // tool-use shape: heavy/dependent agentic loop -> Opus; one-shot/short -> GLM
+  if (has("agent loop", "agentic", "many tool calls", "multi-step tool", "orchestrate tools", "chain of tool", "dependent tool", "tool-heavy", "long tool")) extra.toolPattern = "heavy";
+  else if (has("single tool call", "one tool call", "structured extraction", "function call", "json schema", "extract fields")) extra.toolPattern = "single";
+
+  // Hard-sensitive short-circuit.
+  if (has("secret", "password", "credential", "api key", "private key", " auth", "authentication", "oauth", "crypto", "encrypt", "vulnerab", "proprietary", "security review"))
+    return { taskType: "security", sensitive: true, ...extra };
+
+  // Task type (first match wins; order = specificity).
+  let taskType = "general";
+  if (extra.toolPattern === "heavy") taskType = "toolcall_heavy";
+  else if (has("migration", "migrate the database", "schema migration", "alembic", "flyway")) taskType = "migration";
+  else if (has("code review", "review this diff", "review the pr", "review my code")) taskType = "code_review";
+  else if (has("terraform", "kubernetes", "k8s", "helm", "dockerfile", "infrastructure as code", "cloudformation")) taskType = "iac";
+  else if (has("github actions", "ci/cd", "ci pipeline", "gitlab ci", "jenkins", "workflow yaml")) taskType = "cicd";
+  else if (has("sql", "query the", "select ", "join ", "optimize the query")) taskType = "sql";
+  else if (has("regex", "regular expression")) taskType = "regex";
+  else if (has("etl", "data pipeline", "ingest", "transform the data")) taskType = "etl";
+  else if (has("integration test", "e2e", "end-to-end test")) taskType = "integration_test";
+  else if (has("unit test", "write tests", "test coverage", "pytest", "jest", "vitest")) taskType = "unit_test";
+  else if (has("type error", "typescript error", "lint", "eslint", "mypy", "type fix")) taskType = "type_lint";
+  else if (has("upgrade", "bump version", "migrate to v", "dependency", "deprecat")) taskType = "dependency_upgrade";
+  else if (has("performance", "optimize the", "speed up", "bottleneck", "profil")) taskType = "perf";
+  else if (has("integrate with", "third-party api", "external api", "sdk for", "api integration")) taskType = "api_integration";
+  else if (has("rust", "golang", " go ", "c++", "concurrency", "mutex", "memory safety", "data race")) taskType = "systems";
+  else if (has("translate", "i18n", "localization", "localize")) taskType = "i18n";
+  else if (has("notebook", "jupyter", "exploratory", "eda", "pandas analysis")) taskType = "notebook";
+  else if (has("train a model", "training loop", "ml model", "fine-tune", "neural network")) taskType = "ml_training";
+  else if (has("cli", "shell script", "bash script", "automation script")) taskType = "cli";
+  else if (has("frontend", "react", "component", "css", "tailwind", " ui", "button", "styling", "html", "landing page", "dashboard")) taskType = "frontend";
+  else if (has("boilerplate", "scaffold", "template", "stub", "starter")) taskType = "boilerplate";
+  else if (has("config file", "yaml config", "set up config", ".env", "settings file")) taskType = "config";
+  else if (has("prototype", "proof of concept", "poc", "quick demo", "mvp")) taskType = "prototype";
+  else if (has("crud", "endpoint", "rest api", "data model")) taskType = "crud";
+  else if (has("refactor")) taskType = has("large", "entire", "whole", "across the", "codebase-wide", "many files") ? "refactor_large" : "refactor_local";
+  else if (has("debug", "why is", "not working", "stack trace", "root cause", "fix the bug", "intermittent")) taskType = "debugging";
+  else if (has("architect", "system design", "high-level design", "trade-off", "tradeoff", "design the system")) taskType = "architecture";
+  else if (has("document", "readme", "docstring", "changelog", "comment the")) taskType = "docs";
+  else if (has("summar", "research", "find out", "look up", "investigate", "gather")) taskType = "research";
+  else if (has("algorithm", "leetcode", "competitive programming", "time complexity", "dynamic programming")) taskType = "algorithm";
+  else if (extra.toolPattern === "single") taskType = "toolcall_single";
+
+  if (has("large", "entire", "whole codebase", "complex", "subtle", "tricky")) extra.complexity = "high";
+
+  return { taskType, ...extra };
+}
+
+(async () => {
+  try {
+    const raw = await readStdin();
+    const payload = JSON.parse(raw || "{}");
+    const ti = payload.tool_input || {};
+    const subagent = ti.subagent_type || "";
+
+    // Already routing to the GLM delegate -> nothing to advise.
+    if (subagent === "glm") process.exit(0);
+
+    // User explicitly chose an agent/model ("use opus", "use the sonnet agent", ...)
+    // -> honor their choice, do not inject a recommendation.
+    if (explicitAgentRequested(lastUserText(payload.transcript_path))) process.exit(0);
+
+    const text = [ti.description, ti.prompt].filter(Boolean).join("\n");
+    const profile = inferProfile(text);
+    const cwd = payload.cwd || "<the project root absolute path>";
+    // Is this hands-on repo work (edit/create/run files) vs pure text generation?
+    const pureText = ["research", "summarization"].includes(profile.taskType) ||
+      /\b(explain|summari[sz]e|what is|describe|brainstorm|outline|draft an? (email|message|note))\b/.test(text.toLowerCase());
+    const repoTask = !pureText;
+
+    let verdict, peakNote = "";
+    try {
+      const { recommend, isPeak } = await import(pathToFileURL(ROUTER).href);
+      const rec = recommend(profile);
+      const peak = isPeak();
+      peakNote = peak
+        ? `Currently CHINA PEAK (14:00-18:00 UTC+8): GLM-5.2 costs ~3x now, so the router routes LESS to GLM during peak (only stronger-fit tasks go to GLM).`
+        : `Currently OFF-PEAK in China: "auto" uses GLM-5.2 (best capability, cheapest now).`;
+      if (rec.engine !== "glm") {
+        verdict = `KEEP ON OPUS (inferred: ${profile.taskType}, confidence ${rec.confidence}). Why: ${rec.reasons[0] || ""}`;
+      } else if (repoTask) {
+        // Hands-on repo task -> point at glm_agent directly (skip the subagent middle layer).
+        verdict =
+          `GLM-SUITABLE repo task (inferred: ${profile.taskType}, confidence ${rec.confidence}). ` +
+          `Best path: instead of spawning ${ti.subagent_type || "a subagent"}, call mcp__glm__glm_agent directly ` +
+          `with workdir="${cwd}" so GLM (model ${rec.model}, ~10x cheaper) reads/edits the files and runs tests itself. ` +
+          `For oversight, pass dry_run:true first to review GLM's proposed diff, then call again to apply. ` +
+          `Why: ${rec.reasons[rec.reasons.length - 1] || rec.reasons[0] || ""}`;
+      } else {
+        // Pure generation -> draft via glm_delegate / the glm subagent.
+        verdict =
+          `GLM-SUITABLE generation (inferred: ${profile.taskType}, confidence ${rec.confidence}). ` +
+          `Use mcp__glm__glm_delegate (or the "glm" subagent) to draft this (model ${rec.model}, ~10x cheaper); ` +
+          `then place/verify the result yourself. Why: ${rec.reasons[rec.reasons.length - 1] || rec.reasons[0] || ""}`;
+      }
+    } catch {
+      verdict = `Could not load router; GLM delegate is still available (mcp__glm__glm_agent for repo tasks, mcp__glm__glm_delegate for drafts, mcp__glm__glm_recommend to decide).`;
+    }
+
+    // Detailed rules -- only injected when a subagent is actually spawned, so the
+    // extra tokens are pay-per-use, not charged on every command.
+    const RULES = [
+      "PHILOSOPHY: GLM is ~10x cheaper than Opus (still ~3-4x cheaper even at peak), so GLM is the",
+      "DEFAULT for safe-to-be-wrong work; Opus is the exception you 'pay up' for only when quality or",
+      "risk justifies it. Cheaper-but-wrong is expensive on hard tasks (rework + Opus tokens to fix),",
+      "so the cost bias applies to easy/neutral work, not to the hard-task overrides below.",
+      "ROUTING RULES (GLM = Zhipu/Z.ai delegate, ~10x cheaper than Opus):",
+      "- Lean GLM: frontend/UI, boilerplate, scaffolding, CRUD, single-file/local refactors,",
+      "  docs, summarization, research drafts, tool-calling/MCP work, algorithmic codegen.",
+      "  GLM shines on well-specified, single-purpose work where being wrong is cheap.",
+      "- Lean OPUS: subtle or long debugging, open-ended architecture, large multi-step",
+      "  refactors, security review, systems languages (Rust/Go/C), vision, GUI/computer control.",
+      "- HARD OVERRIDES -> always Opus regardless of cost: (1) sensitive/proprietary/secret code",
+      "  (GLM routes through servers in China), (2) needs parallel agents (GLM ~1-concurrency cap),",
+      "  (3) long-horizon AND high complexity (GLM drifts off-plan), (4) latency-critical loops.",
+      "- Complexity adjusts: low -> nudge GLM, high -> nudge Opus.",
+      "HOW TO ACT: if GLM-suitable, spawn the \"glm\" subagent (it gathers context and pastes it in,",
+      "since GLM cannot read files or use Claude's tools). Unsure -> call mcp__glm__glm_recommend (free,",
+      "local). After GLM returns, verify the output; if it's weak or wrong, retry once with a sharper",
+      "prompt, then escalate to Opus. Never let cost-saving degrade correctness on work that matters.",
+    ].join("\n");
+
+    const out = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        additionalContext: `[GLM router] Verdict: ${verdict}\n${peakNote}\n\n${RULES}`,
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch {
+    // never block a subagent spawn on hook failure
+  }
+  process.exit(0);
+})();

package/install.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+// install.mjs -- one-shot installer for the GLM hybrid setup.
+// Installs GLM as a cheap, full-capability subagent for Claude Code, with auto-routing.
+//
+// Usage:
+//   node install.mjs                       # install for the current user (global)
+//   node install.mjs --key YOUR_ZAI_KEY    # also write the API key into .env
+//   node install.mjs --claude-dir PATH     # target a custom .claude dir (default ~/.claude)
+//   node install.mjs --no-register         # skip `claude mcp add` (do it manually)
+//   node install.mjs --skip-npm            # skip `npm install` (deps already present)
+//
+// It is idempotent: re-running updates files without duplicating hook/policy entries.
+
+import { cpSync, mkdirSync, existsSync, readFileSync, writeFileSync, copyFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const SELF = dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const getFlag = (n) => args.includes(n);
+const getOpt = (n) => { const i = args.indexOf(n); return i >= 0 ? args[i + 1] : undefined; };
+
+const CLAUDE = getOpt("--claude-dir") || join(homedir(), ".claude");
+const KEY = getOpt("--key") || process.env.GLM_API_KEY || "";
+const NO_REGISTER = getFlag("--no-register");
+const SKIP_NPM = getFlag("--skip-npm");
+
+const log = (s) => console.log(s);
+const step = (s) => console.log(`\n→ ${s}`);
+
+log(`GLM hybrid installer`);
+log(`  source : ${SELF}`);
+log(`  target : ${CLAUDE}`);
+
+// 1. Copy the MCP server (skip node_modules and any stray .env).
+step("Installing MCP server -> " + join(CLAUDE, "glm-mcp"));
+mkdirSync(CLAUDE, { recursive: true });
+cpSync(join(SELF, "glm-mcp"), join(CLAUDE, "glm-mcp"), {
+  recursive: true,
+  filter: (src) => {
+    const base = src.split(/[\\/]/).pop();
+    return base !== "node_modules" && base !== ".env";
+  },
+});
+
+// 2. .env
+step("Setting up .env");
+const envPath = join(CLAUDE, "glm-mcp", ".env");
+if (!existsSync(envPath)) {
+  copyFileSync(join(CLAUDE, "glm-mcp", ".env.example"), envPath);
+  log("  created .env from .env.example");
+}
+if (KEY) {
+  let env = readFileSync(envPath, "utf8");
+  env = /^GLM_API_KEY=/m.test(env)
+    ? env.replace(/^GLM_API_KEY=.*$/m, `GLM_API_KEY=${KEY}`)
+    : `GLM_API_KEY=${KEY}\n` + env;
+  writeFileSync(envPath, env);
+  log("  wrote GLM_API_KEY into .env");
+} else if (!/^GLM_API_KEY=\S+/m.test(readFileSync(envPath, "utf8"))) {
+  log("  ⚠ No API key set yet. Edit " + envPath + " and set GLM_API_KEY=... before use.");
+}
+
+// 3. npm install
+if (!SKIP_NPM) {
+  step("Installing dependencies (npm install)");
+  execSync("npm install --no-audit --no-fund", { cwd: join(CLAUDE, "glm-mcp"), stdio: "inherit" });
+}
+
+// 4. Subagent + hook
+step("Installing subagent and auto-delegation hook");
+mkdirSync(join(CLAUDE, "agents"), { recursive: true });
+mkdirSync(join(CLAUDE, "hooks"), { recursive: true });
+copyFileSync(join(SELF, "agents", "glm.md"), join(CLAUDE, "agents", "glm.md"));
+copyFileSync(join(SELF, "hooks", "glm_subagent_router.mjs"), join(CLAUDE, "hooks", "glm_subagent_router.mjs"));
+log("  agents/glm.md, hooks/glm_subagent_router.mjs");
+
+// 5. Merge the PreToolUse hook into settings.json (idempotent, with backup).
+step("Wiring the hook into settings.json");
+const settingsPath = join(CLAUDE, "settings.json");
+let settings = {};
+if (existsSync(settingsPath)) {
+  try { settings = JSON.parse(readFileSync(settingsPath, "utf8")); } catch { settings = {}; }
+  writeFileSync(settingsPath + ".bak-" + Date.now(), readFileSync(settingsPath));
+}
+const hookCmd = `node "${join(CLAUDE, "hooks", "glm_subagent_router.mjs").replace(/\\/g, "/")}"`;
+settings.hooks ||= {};
+settings.hooks.PreToolUse ||= [];
+const already = settings.hooks.PreToolUse.some((e) =>
+  (e.hooks || []).some((h) => typeof h.command === "string" && h.command.includes("glm_subagent_router"))
+);
+if (!already) {
+  settings.hooks.PreToolUse.push({ matcher: "Task", hooks: [{ type: "command", command: hookCmd }] });
+  log("  added PreToolUse(Task) -> glm_subagent_router");
+} else {
+  log("  hook already present (left as-is)");
+}
+writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+
+// 6. Append the global delegation policy (idempotent).
+step("Adding global delegation policy to CLAUDE.md");
+const claudeMd = join(CLAUDE, "CLAUDE.md");
+const policy = `\n# Delegation (GLM hybrid)\n\nPrefer offloading well-specified, self-contained subtasks. When you spawn a subagent (the\n\`Task\` tool), a PreToolUse hook injects a \`[GLM router]\` line advising whether to route it to\nthe cheaper \`glm\` subagent / \`mcp__glm__glm_agent\` or keep it on Opus -- follow that advice.\nIf the user explicitly named an agent, honor it. Full rules: \`~/.claude/glm-mcp/README.md\`.\n`;
+const existing = existsSync(claudeMd) ? readFileSync(claudeMd, "utf8") : "";
+if (!existing.includes("[GLM router]")) {
+  writeFileSync(claudeMd, existing + policy);
+  log("  policy appended");
+} else {
+  log("  policy already present");
+}
+
+// 7. Register the MCP server (user scope) via the claude CLI.
+if (!NO_REGISTER) {
+  step("Registering MCP server with Claude Code (user scope)");
+  const idx = join(CLAUDE, "glm-mcp", "src", "index.js").replace(/\\/g, "/");
+  try {
+    try { execSync("claude mcp remove glm -s user", { stdio: "ignore" }); } catch {}
+    execSync(`claude mcp add glm -s user -- node "${idx}"`, { stdio: "inherit" });
+    log("  registered (key is read from .env).");
+  } catch (e) {
+    log("  ⚠ Could not run `claude mcp add` (" + e.message + ").");
+    log("  Register manually:");
+    log(`    claude mcp add glm -s user -- node "${idx}"`);
+  }
+}
+
+log("\n✅ Done. Next steps:");
+log("  1. Ensure GLM_API_KEY is set in " + envPath);
+log("  2. RESTART Claude Code, then run `glm_status` to verify (api_key_loaded: true).");
+log("  3. Your main agent stays on whatever model Claude Code uses; GLM handles delegated subtasks.");

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "glm-mcp-claude",
+  "version": "1.0.0",
+  "description": "GLM (Zhipu/Z.ai) as a cheap, full-capability subagent for Claude Code — auto-routing between Opus and GLM, a file-editing agent with diff/dry-run/git-revert oversight, and a one-command installer.",
+  "type": "module",
+  "bin": {
+    "glm-mcp-claude": "install.mjs"
+  },
+  "files": [
+    "glm-mcp/",
+    "agents/",
+    "hooks/",
+    "docs/",
+    "assets/",
+    "install.mjs",
+    "uninstall.mjs",
+    ".mcp.json.example",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude-code",
+    "mcp",
+    "model-context-protocol",
+    "glm",
+    "zhipu",
+    "z.ai",
+    "subagent",
+    "ai-agents",
+    "anthropic",
+    "llm",
+    "cost-optimization"
+  ],
+  "author": "djerok",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/djerok/glm_mcp_claude.git"
+  },
+  "bugs": {
+    "url": "https://github.com/djerok/glm_mcp_claude/issues"
+  },
+  "homepage": "https://github.com/djerok/glm_mcp_claude#readme"
+}

package/uninstall.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// uninstall.mjs -- removes what install.mjs added.
+//   node uninstall.mjs                 # remove from ~/.claude
+//   node uninstall.mjs --claude-dir P  # custom dir
+//   node uninstall.mjs --purge         # also delete the glm-mcp server folder (and your .env!)
+
+import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const args = process.argv.slice(2);
+const getOpt = (n) => { const i = args.indexOf(n); return i >= 0 ? args[i + 1] : undefined; };
+const CLAUDE = getOpt("--claude-dir") || join(homedir(), ".claude");
+const PURGE = args.includes("--purge");
+
+console.log("Uninstalling GLM hybrid from " + CLAUDE);
+
+try { execSync("claude mcp remove glm -s user", { stdio: "inherit" }); } catch { console.log("  (claude mcp remove skipped/failed)"); }
+
+const settingsPath = join(CLAUDE, "settings.json");
+if (existsSync(settingsPath)) {
+  try {
+    const s = JSON.parse(readFileSync(settingsPath, "utf8"));
+    if (s.hooks?.PreToolUse) {
+      s.hooks.PreToolUse = s.hooks.PreToolUse.filter(
+        (e) => !(e.hooks || []).some((h) => typeof h.command === "string" && h.command.includes("glm_subagent_router"))
+      );
+      if (!s.hooks.PreToolUse.length) delete s.hooks.PreToolUse;
+      writeFileSync(settingsPath, JSON.stringify(s, null, 2) + "\n");
+      console.log("  removed hook from settings.json");
+    }
+  } catch (e) { console.log("  settings.json edit failed: " + e.message); }
+}
+
+for (const f of [join(CLAUDE, "agents", "glm.md"), join(CLAUDE, "hooks", "glm_subagent_router.mjs")]) {
+  if (existsSync(f)) { rmSync(f); console.log("  removed " + f); }
+}
+
+if (PURGE && existsSync(join(CLAUDE, "glm-mcp"))) {
+  rmSync(join(CLAUDE, "glm-mcp"), { recursive: true, force: true });
+  console.log("  purged glm-mcp/ (including .env)");
+}
+
+console.log("\nNote: the '# Delegation (GLM hybrid)' block in CLAUDE.md was left in place -- remove it by hand if you want.");
+console.log("Done. Restart Claude Code.");