jui-tools-mcp-server 2.16.0 → 2.18.0

package/dist/tools/infra/infra_validate.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { ContractError, FIRST, failure, need, problems, runDocJson, text } from "./infra_common.js";
+/**
+ * `jsonui-doc validate infra <project> --json`: the room's model (docs/infra/*.json, or jui.config.json's infra.dir)
+ * read as jui viz reads it — each file against the schema and the shapes of secrets, then merged, and its flows
+ * walked. Exit 0: no error (warnings alone are 0); 1: errors; 2: nothing could be read (reason).
+ *
+ * Migration plans (jsonui-cli 2.3.20+, docs/infra/migrations/<name>/changes.json + removals.json): the CLI checks every
+ * plan with the model, or one with `--migration <name>`, and lists them under "migrations". A plan's error makes the
+ * exit 1 while the model's own problems are empty, so a room that has plans gets their summary here — without it the
+ * exit would name an error the answer does not show. A room with none answers exactly as before.
+ */
+function migrationSummary(m) {
+    need(m, ["name", "dir", "ok", "problems", "steps", "counts"], "validate infra migration");
+    return {
+        name: m.name,
+        dir: m.dir,
+        ok: m.ok,
+        counts: m.counts,
+        problems: problems(m.problems, "validate infra migration"),
+        steps: m.steps.length,
+        firstSteps: m.steps.slice(0, FIRST).map((s) => {
+            need(s, ["index", "kind", "node"], "validate infra migration step");
+            return { index: s.index, kind: s.kind, node: s.node,
+                ...(s.edgesRemoved?.length ? { edgesRemoved: s.edgesRemoved } : {}),
+                ...(s.edgesAdded?.length ? { edgesAdded: s.edgesAdded } : {}) };
+        }),
+    };
+}
+function migrations(data, plan) {
+    if (plan)
+        need(data, ["migrations"], "validate infra --migration");
+    const list = data.migrations;
+    if (list === undefined)
+        return {}; // a room with no plan: the CLI prints no key, and nor does this
+    if (!Array.isArray(list))
+        throw new ContractError('validate infra: "migrations" is not a list');
+    return { migrations: list.map(migrationSummary) };
+}
+export function register(server, config) {
+    server.tool("infra_validate", "Validate the server room's infra model (docs/infra/*.json: environments, groups, nodes, edges, flows) with `jsonui-doc validate infra --json`. Returns whether it could be read (and why not), the files used, the counts, and the problems by severity and code with the first 20 (file, path, code, message). Flow problems (flow.*) name the rule a step most likely missed. When the room has migration plans (docs/infra/migrations/<name>/changes.json + removals.json), each plan's check too: its problems (migration.remove_missing / duplicate / both / order_unknown / edge_end, and the infra checks on the merged new model), its counts (added, replaced, removed, edges added / removed) and its steps in order; `plan` checks that one plan only. Needs jsonui-cli 2.3.15+ (plans: 2.3.20+).", {
+        project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+        plan: z.string().optional().describe("One migration plan's name (its folder under docs/infra/migrations); default: every plan"),
+    }, async ({ project_dir, plan }) => {
+        try {
+            const projectDir = config.resolveProjectDir(project_dir);
+            const args = ["validate", "infra", projectDir, "--json"];
+            if (plan)
+                args.push("--migration", plan);
+            const { exitCode, data } = await runDocJson(args, projectDir);
+            need(data, ["ok"], "validate infra");
+            if (!data.ok && data.reason !== "invalid") {
+                need(data, ["reason", "message"], "validate infra");
+                return text({ ok: false, exit: exitCode, readable: false, reason: data.reason, message: data.message });
+            }
+            need(data, ["dir", "files", "problems"], "validate infra");
+            return text({
+                ok: exitCode === 0,
+                exit: exitCode,
+                readable: data.ok,
+                dir: data.dir,
+                files: data.files,
+                environments: (data.environments ?? []).map((e) => e.id),
+                counts: data.counts ?? null,
+                flows: Array.isArray(data.flows) ? data.flows.length : null,
+                problems: problems(data.problems, "validate infra"),
+                ...migrations(data, plan),
+            });
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jui-tools-mcp-server",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "description": "MCP server for JsonUI project management - wraps jui and jsonui-doc CLIs plus component spec lookup",
   "main": "dist/index.js",
   "scripts": {

package/scripts/record-infra-fixtures.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+# Record what the jsonui-doc infra commands print with --json, as the infra tools' test fixtures
+# (tests/fixtures/infra/*.json). The tools summarise those outputs, so the fixtures are the CLI's contract: when the
+# CLI's JSON changes, record again and the tools' tests say what no longer holds.
+#
+#   scripts/record-infra-fixtures.sh <jsonui-cli checkout>     # e.g. a worktree of integrate/2.3.15
+#
+# Rooms: jsonui-cli's own document_tools/tests/fixtures/infra (aws-three-tier: a model, two load scenarios, a price
+# file; compose-and-cloud: what seed reads), copied to a temp folder; one copy is broken on purpose (a load file that
+# is not JSON, a model file with a schema error) so the error shapes are recorded too. The fetched-price cache is kept
+# out (JUI_VIZ_HOME points nowhere), so the bundled table prices them.
+set -euo pipefail
+CLI_ROOT="$(cd "${1:?usage: $0 <jsonui-cli checkout>}" && pwd)"
+HERE="$(cd "$(dirname "$0")/.." && pwd)"
+OUT="${HERE}/tests/fixtures/infra"
+FIX="${CLI_ROOT}/document_tools/tests/fixtures/infra"
+WORK="$(mktemp -d)"
+trap 'rm -rf "${WORK}"' EXIT
+
+export PYTHONPATH="${CLI_ROOT}/document_tools:${CLI_ROOT}/jui_tools:${CLI_ROOT}/test_tools"
+export JUI_VIZ_HOME=/nonexistent
+doc() { (cd "$1" && shift && python3 -m jsonui_doc_cli.cli "$@") || true; }
+
+cp -R "${FIX}/aws-three-tier" "${WORK}/room"
+cp -R "${FIX}/aws-three-tier" "${WORK}/broken"
+printf '{' > "${WORK}/broken/docs/infra/load/broken.json"
+printf '{"version": 0, "nodes": [{"id": "x", "category": "nope"}]}' > "${WORK}/broken/docs/infra/bad.json"
+mkdir -p "${WORK}/seed/app"
+cat > "${WORK}/seed/docker-compose.yml" <<'EOF'
+services:
+  web:
+    image: example/web
+    depends_on: [db, cache]
+  db:
+    image: postgres:16
+  cache:
+    image: redis:7
+EOF
+cat > "${WORK}/seed/main.tf" <<'EOF'
+provider "aws" { region = "ap-northeast-1" }
+resource "aws_db_instance" "main" { engine = "postgres" }
+resource "aws_lb" "web" { load_balancer_type = "application" }
+resource "aws_s3_bucket" "assets" {}
+resource "aws_glue_job" "etl" {}
+EOF
+printf 'import boto3\nimport stripe\nQUEUE_URL = "SQS_QUEUE_URL"\n' > "${WORK}/seed/app/main.py"
+cat > "${WORK}/room/jui.config.json" <<'EOF'
+{"checks": [{"name": "infra-load", "type": "builtin:infra-load"}, {"name": "infra-code", "type": "builtin:infra-code"}]}
+EOF
+
+mkdir -p "${OUT}" "${WORK}/empty"
+doc "${WORK}/empty" validate infra --json > "${OUT}/validate-infra.unreadable.json"
+doc "${WORK}/empty" validate infra-load --json > "${OUT}/validate-infra-load.unreadable.json"
+doc "${WORK}/room" validate infra --json > "${OUT}/validate-infra.ok.json"
+doc "${WORK}/broken" validate infra --json > "${OUT}/validate-infra.errors.json"
+doc "${WORK}/room" validate infra-load --json > "${OUT}/validate-infra-load.ok.json"
+doc "${WORK}/broken" validate infra-load --json > "${OUT}/validate-infra-load.errors.json"
+doc "${WORK}/room" validate infra-prices --json > "${OUT}/validate-infra-prices.ok.json"
+doc "${WORK}/seed" seed infra -o "${WORK}/seed-out" > /dev/null
+cp "${WORK}/seed-out/draft.json" "${OUT}/seed-infra.draft.json"
+cp "${WORK}/seed-out/seed-report.json" "${OUT}/seed-infra.report.json"
+doc "${WORK}/room" cost infra --json > "${OUT}/cost-infra.month.json"
+doc "${WORK}/room" cost infra --by node --scenario sale --json > "${OUT}/cost-infra.month-by-node.json"
+doc "${WORK}/room" cost infra --date 2026-11-03 --json > "${OUT}/cost-infra.day.json"
+doc "${WORK}/room" cost infra --scenario nope --json > "${OUT}/cost-infra.refused.json"
+doc "${WORK}/room" check infra --json 2>/dev/null > "${OUT}/check-infra.json"
+
+# Migration plans (jsonui-cli 2.3.20+), in a copy of their own so the room above stays a room without plans: one plan
+# that holds (replace db-prod, add worker-prod and its edge, remove api-stg with its edges, in a written order), and one
+# plan per migration.* code with exactly that error.
+plan() {  # plan <room> <name> <changes json> <removals json>
+  mkdir -p "$1/docs/infra/migrations/$2"
+  printf '%s' "$3" > "$1/docs/infra/migrations/$2/changes.json"
+  printf '%s' "$4" > "$1/docs/infra/migrations/$2/removals.json"
+}
+cp -R "${FIX}/aws-three-tier" "${WORK}/plans"
+DB='{"id": "db-prod", "category": "database.relational", "service": "rds.postgres", "group": "private-prod", "ha": "multi-az", "environments": ["production"], "spec": [{"key": "instance_class", "value": "db.r6g.large"}, {"key": "storage_gb", "value": "200"}]}'
+WORKER='{"id": "worker-prod", "category": "compute.container", "service": "ecs.fargate", "group": "private-prod", "count": 1, "environments": ["production"], "spec": [{"key": "cpu", "value": "512"}, {"key": "memory", "value": "1024"}, {"key": "tasks", "value": "1"}]}'
+NONE='{"version": 0, "nodes": [], "groups": [], "edges": []}'
+plan "${WORK}/plans" move "{\"version\": 0, \"order\": [\"db-prod\", \"worker-prod\", \"api-stg\"], \"nodes\": [${DB}, ${WORKER}], \"edges\": [{\"from\": \"api-prod\", \"to\": \"worker-prod\", \"protocol\": \"https\", \"port\": 443}]}" \
+  '{"version": 0, "nodes": ["api-stg"], "groups": [], "edges": []}'
+# the account's month needs a load in two environments: staging gets one here (only in this copy)
+python3 - "${WORK}/plans/docs/infra/load" <<'EOF'
+import json, sys
+d = json.load(open(f"{sys.argv[1]}/ordinary.json", encoding="utf-8"))
+d.update(id="staging", label="staging", environment="staging",
+         loads=[{"node": "alb-stg", "quantities": {"lcu": 1}}, {"node": "api-stg", "quantities": {"vcpu": 0.25, "memory_gb": 0.5}},
+                {"node": "db-stg", "sku": "db.t4g.medium", "quantities": {"storage_gb": 20}}], edges=[])
+json.dump(d, open(f"{sys.argv[1]}/staging.json", "w", encoding="utf-8"), ensure_ascii=False)
+EOF
+cp -R "${FIX}/aws-three-tier" "${WORK}/badplans"
+plan "${WORK}/badplans" remove-missing "{\"version\": 0, \"nodes\": [${WORKER}]}" '{"version": 0, "nodes": ["nope"], "groups": [], "edges": []}'
+plan "${WORK}/badplans" duplicate "{\"version\": 0, \"nodes\": [${WORKER}, ${WORKER}]}" "${NONE}"
+plan "${WORK}/badplans" both "{\"version\": 0, \"nodes\": [${DB}]}" '{"version": 0, "nodes": ["db-prod"], "groups": [], "edges": []}'
+plan "${WORK}/badplans" order-unknown "{\"version\": 0, \"order\": [\"ghost\"], \"nodes\": [${WORKER}]}" "${NONE}"
+plan "${WORK}/badplans" edge-end "{\"version\": 0, \"nodes\": [${WORKER}], \"edges\": [{\"from\": \"worker-prod\", \"to\": \"ghost\", \"protocol\": \"https\", \"port\": 443}]}" "${NONE}"
+doc "${WORK}/plans" validate infra --json > "${OUT}/validate-infra.plans.json"
+doc "${WORK}/plans" validate infra --migration move --json > "${OUT}/validate-infra.plan-move.json"
+doc "${WORK}/plans" validate infra --migration nope --json > "${OUT}/validate-infra.plan-none.json"
+for code in remove-missing duplicate both order-unknown edge-end; do
+  doc "${WORK}/badplans" validate infra --migration "${code}" --json > "${OUT}/validate-infra.plan-${code}.json"
+done
+doc "${WORK}/plans" cost infra --migration move --json > "${OUT}/cost-infra.plan-move.json"
+doc "${WORK}/plans" cost infra --migration move --account --scenario sale --json > "${OUT}/cost-infra.plan-move-account.json"
+doc "${WORK}/badplans" cost infra --migration both --json > "${OUT}/cost-infra.plan-bad.json"
+doc "${WORK}/plans" cost infra --migration nope --json > "${OUT}/cost-infra.plan-none.json"
+
+# A plan whose biggest change is a fall, and an unchanged node that moves with it: batch-prod (a node of this copy
+# only) comes after api-prod and shares the account's 100 GB internet egress with it (the free amount goes to the
+# first nodes); the plan shrinks the database and removes api-prod, so batch-prod takes more of the free amount.
+cp -R "${FIX}/aws-three-tier" "${WORK}/shrink"
+python3 - "${WORK}/shrink/docs/infra" <<'EOF'
+import json, sys
+infra = sys.argv[1]
+m = json.load(open(f"{infra}/main.json", encoding="utf-8"))
+m["nodes"].append({"id": "batch-prod", "category": "compute.container", "service": "ecs.fargate", "group": "private-prod", "count": 1,
+                   "environments": ["production"], "spec": [{"key": "cpu", "value": "256"}, {"key": "memory", "value": "512"}, {"key": "tasks", "value": "1"}]})
+json.dump(m, open(f"{infra}/main.json", "w", encoding="utf-8"), ensure_ascii=False)
+d = json.load(open(f"{infra}/load/ordinary.json", encoding="utf-8"))
+for row in d["loads"]:
+    if row.get("node") == "api-prod":
+        row["quantities"]["egress_gb"] = {"amount": 2.7, "per": "day"}
+d["loads"].append({"node": "batch-prod", "quantities": {"vcpu": 0.25, "memory_gb": 0.5, "egress_gb": {"amount": 2.7, "per": "day"}}})
+json.dump(d, open(f"{infra}/load/ordinary.json", "w", encoding="utf-8"), ensure_ascii=False)
+EOF
+SMALL='{"id": "db-prod", "category": "database.relational", "service": "rds.mysql", "group": "private-prod", "environments": ["production"], "spec": [{"key": "instance_class", "value": "db.t4g.medium"}, {"key": "storage_gb", "value": "200"}]}'
+plan "${WORK}/shrink" shrink "{\"version\": 0, \"nodes\": [${SMALL}]}" '{"version": 0, "nodes": ["api-prod"], "groups": [], "edges": []}'
+doc "${WORK}/shrink" cost infra --migration shrink --json > "${OUT}/cost-infra.plan-shrink.json"
+# a plan folder with nothing in it yet: listed, not ok, its read problem said (an empty migrations folder lists none)
+mkdir -p "${WORK}/badplans/docs/infra/migrations/half"
+doc "${WORK}/badplans" validate infra --migration half --json > "${OUT}/validate-infra.plan-half.json"
+
+# The temp folder's path is not part of the contract
+for f in "${OUT}"/*.json; do
+  python3 - "$f" "${WORK}" <<'EOF'
+import sys
+p, work = sys.argv[1:]
+s = open(p, encoding="utf-8").read().replace(work, "<ROOT>")
+open(p, "w", encoding="utf-8").write(s)
+EOF
+done
+git -C "${CLI_ROOT}" log -1 --format='%h %s' > "${OUT}/RECORDED_FROM"
+ls -1 "${OUT}"

package/src/index.ts

@@ -59,6 +59,12 @@ import { register as registerVizDoctor } from "./tools/viz/viz_doctor.js";
 import { register as registerVizStart } from "./tools/viz/viz_start.js";
 import { register as registerVizStop } from "./tools/viz/viz_stop.js";
 import { register as registerVizOpen } from "./tools/viz/viz_open.js";
+import { register as registerInfraValidate } from "./tools/infra/infra_validate.js";
+import { register as registerInfraLoadValidate } from "./tools/infra/infra_load_validate.js";
+import { register as registerInfraPricesValidate } from "./tools/infra/infra_prices_validate.js";
+import { register as registerInfraSeed } from "./tools/infra/infra_seed.js";
+import { register as registerInfraCheck } from "./tools/infra/infra_check.js";
+import { register as registerInfraCost } from "./tools/infra/infra_cost.js";
 
 // --- Group F: jsonui-test CLI ---
 import { register as registerTestValidate } from "./tools/test/test_validate.js";
@@ -174,7 +180,17 @@ registerVizStart(server);
 registerVizStop(server);
 registerVizOpen(server);
 
-log(`Registered 51 tools (9 spec + 7 context + 8 jui + 9 doc + 3 api + 10 test + 5 viz)`);
+// Register Group H: the server room's infra (6 tools) — jsonui-doc's validate / seed / check / cost infra, each
+// summarised from its --json (jsonui-cli 2.3.15+). `jui viz cloud-prices fetch` stays with the CLI (it goes to the
+// network and writes the viz home).
+registerInfraValidate(server, config);
+registerInfraLoadValidate(server, config);
+registerInfraPricesValidate(server, config);
+registerInfraSeed(server, config);
+registerInfraCheck(server, config);
+registerInfraCost(server, config);
+
+log(`Registered 57 tools (9 spec + 7 context + 8 jui + 9 doc + 3 api + 10 test + 5 viz + 6 infra)`);
 
 async function main() {
   const transport = new StdioServerTransport();

package/src/tools/infra/infra_check.ts

@@ -0,0 +1,49 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { FIRST, failure, need, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc check infra -p <project> --json`: the declared infra checks (jui.config.json → checks:
+ * builtin:infra-iac, builtin:infra-code, builtin:infra-load) — the model against the IaC, the code, and the load
+ * definitions. This is the one jsonui-doc command that runs project-declared checks; the infra ones read files only.
+ * Exit 0: clean (warnings alone are 0); 1: a mismatch (a finding of a check declared with gate: true); 2: an
+ * execution error, or no infra check is declared.
+ */
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_check",
+    "Run the project's declared infra checks with `jsonui-doc check infra --json` (jui.config.json → checks: builtin:infra-iac = the model against Terraform/Compose/CloudFormation/k8s/wrangler, builtin:infra-code = against the code's evidence, SDK imports and env names, builtin:infra-load = against the load definitions). Returns each check's status (ok / mismatch / error), counts, the first 20 results that are not ok (target, status, expected, actual, message), warnings, and its report file. Findings are warnings unless the check sets gate: true. Needs jsonui-cli 2.3.15+.",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+    },
+    async ({ project_dir }) => {
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const { exitCode, data, stderr } = await runDocJson(["check", "infra", "-p", projectDir, "--json"], projectDir, 180_000);
+        need(data, ["ok", "exit", "checks"], "check infra");
+        if (!data.checks.length) {
+          return text({ ok: false, exit: exitCode, checks: [],
+            message: stderr.trim() || "no builtin:infra-* check is declared in jui.config.json → checks",
+            declared: data.declared ?? [] });
+        }
+        return text({
+          ok: data.ok,
+          exit: exitCode,
+          checks: data.checks.map((c: any) => {
+            need(c, ["name", "type", "status"], "check infra check");
+            if (c.status === "error") return { name: c.name, type: c.type, status: "error", error: c.error };
+            need(c, ["summary", "results", "warnings", "report"], "check infra check");
+            return {
+              name: c.name, type: c.type, status: c.status, summary: c.summary,
+              results: c.results.slice(0, FIRST), resultCount: c.results.length,
+              warnings: c.warnings.slice(0, FIRST), report: c.report,
+            };
+          }),
+        });
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}

package/src/tools/infra/infra_common.ts

@@ -0,0 +1,69 @@
+import { runCli } from "../../cli_runner.js";
+
+/**
+ * Shared by the Group H tools: run a `jsonui-doc … --json` infra command and read its one JSON object.
+ *
+ * The tools summarise that object for an agent (counts, the first problems, the totals), so the keys they read are
+ * the CLI's contract. `need` names a key the object lacks instead of summarising nothing — a jsonui-doc older or
+ * newer than these tools says so rather than reading as an empty room. The tests feed the CLI's own recorded output
+ * (tests/fixtures/infra, scripts/record-infra-fixtures.sh).
+ */
+
+export interface JsonRun {
+  exitCode: number;
+  data: any;
+  stderr: string;
+}
+
+export class ContractError extends Error {}
+
+export const FIRST = 20;
+
+export async function runDocJson(args: string[], cwd: string, timeout?: number): Promise<JsonRun> {
+  const result = await runCli("jsonui-doc", args, { cwd, timeout });
+  let data: any;
+  try {
+    data = JSON.parse(result.stdout);
+  } catch {
+    throw new ContractError(
+      `jsonui-doc ${args.slice(0, 2).join(" ")} printed no JSON (exit ${result.exitCode})` +
+        (result.stderr ? `: ${result.stderr.trim().split("\n").slice(-3).join(" / ")}` : "") +
+        " — it needs jsonui-cli 2.3.15 or later for --json here"
+    );
+  }
+  return { exitCode: result.exitCode, data, stderr: result.stderr };
+}
+
+export function need(obj: any, keys: string[], what: string): void {
+  const missing = keys.filter((k) => obj == null || !(k in obj));
+  if (missing.length) {
+    throw new ContractError(
+      `${what}: the JSON has no ${missing.map((k) => `"${k}"`).join(", ")} — a jsonui-doc these tools do not know; ` +
+        "update jsonui-cli or this server"
+    );
+  }
+}
+
+/** A problem list as counts (by severity, by code) and the first FIRST, each as written. */
+export function problems(list: any[], what: string, keep: string[] = ["severity", "code", "file", "path", "message"]) {
+  if (!Array.isArray(list)) throw new ContractError(`${what}: "problems" is not a list`);
+  const bySeverity: Record<string, number> = {};
+  const byCode: Record<string, number> = {};
+  for (const p of list) {
+    need(p, ["severity", "code"], `${what} problem`);
+    bySeverity[p.severity] = (bySeverity[p.severity] ?? 0) + 1;
+    byCode[p.code] = (byCode[p.code] ?? 0) + 1;
+  }
+  const first = list.slice(0, FIRST).map((p) =>
+    Object.fromEntries(keep.filter((k) => p[k] !== undefined && p[k] !== null).map((k) => [k, p[k]]))
+  );
+  return { count: list.length, errors: bySeverity.error ?? 0, warnings: bySeverity.warning ?? 0, byCode, first };
+}
+
+export function text(value: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(value, null, 2) }] };
+}
+
+export function failure(e: any) {
+  return { content: [{ type: "text" as const, text: `Error: ${e.message}` }] };
+}

package/src/tools/infra/infra_cost.ts

@@ -0,0 +1,177 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { FIRST, failure, need, problems, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc cost infra <project> --json`: the cost simulator's month (or one day) for a load scenario, the same
+ * simulation and shapes as jui viz's コスト. The month's whole reply (every day's stack) and above all a day's (every
+ * node's 24 hours with each meter's price trace, ~300 KB) are too long for an agent; this keeps what answers "what
+ * does it cost and why": the total, the totals per stack key, the top nodes, what has no price / rule / load, the
+ * hours over capacity, the notes, the load problems and the price-book warnings — and for a day, each top node's
+ * charge by meter with the price layer it came from. Exit 0: simulated; 1: simulated, a load file has an error (left
+ * out); 2: nothing simulated (reason).
+ *
+ * With `plan` (jsonui-cli 2.3.20+, `--migration <name>`): the same engine run on the old model and on the new one (old
+ * + changes − removals), and the difference — the totals, per node (what the plan added, replaced, removed or left),
+ * per provider, after each step of the plan, and with `account` the account's month (its environments priced
+ * together). Nothing is computed here.
+ * A plan with an error is not priced: the CLI refuses it (exit 2, reason bad_plan, the plan's problems), as it does a
+ * plan name with no folder (no_plan) — both answered by the refusal path below, problems counted.
+ */
+
+function migrationSummary(data: any) {
+  need(data, ["migration", "scenario", "old", "new", "diff", "byNode", "byProvider", "steps", "account", "unpricedChanged"],
+    "cost infra --migration");
+  for (const k of ["old", "new", "diff"]) need(data[k], ["usd"], `cost infra --migration ${k}`);
+  for (const k of ["old", "new"]) need(data[k], ["noPrice", "noRule", "loadUndefined"], `cost infra --migration ${k}`);
+  for (const n of data.byNode) need(n, ["node", "change", "unpriced", "old", "new", "diff"], "cost infra --migration node");
+  for (const s of data.steps) {
+    need(s, ["index", "node", "usd", "diff", "moved"], "cost infra --migration step");
+    for (const m of s.moved) need(m, ["node", "diff"], "cost infra --migration step moved");
+  }
+  if (data.account !== null) need(data.account, ["on", "old", "new", "diff"], "cost infra --migration account");
+  const changed = data.byNode.filter((n: any) => n.change !== "same" || n.diff !== 0);
+  const byChange: Record<string, number> = {};
+  for (const n of data.byNode) byChange[n.change] = (byChange[n.change] ?? 0) + 1;
+  return {
+    migration: data.migration,
+    scenario: data.scenario,
+    usd: { old: data.old.usd, new: data.new.usd, diff: data.diff.usd },
+    // what either model cannot price (no price, no rule, no load): its part is 0 there, so not in the difference
+    oldUnpriced: { noPrice: data.old.noPrice, noRule: data.old.noRule, loadUndefined: data.old.loadUndefined },
+    newUnpriced: { noPrice: data.new.noPrice, noRule: data.new.noRule, loadUndefined: data.new.loadUndefined },
+    // the nodes the plan changes whose month is not all priced: the difference leaves their part out — not a saving
+    unpricedChanged: data.unpricedChanged,
+    nodes: byChange,
+    // the biggest movements first, whichever way
+    topChanges: [...changed].sort((a: any, b: any) => Math.abs(b.diff) - Math.abs(a.diff)).slice(0, FIRST),
+    changedCount: changed.length,
+    byProvider: data.byProvider,
+    // a step's diff is the whole month's change at that step, not its node's own: a neighbour can move with it (a
+    // shared free amount); moved names what moved, biggest first (a node, or "a>b" for a line's transfer)
+    steps: data.steps.map((s: any) => ({ index: s.index, node: s.node, usd: s.usd, diff: s.diff,
+      moved: s.moved.slice(0, FIRST), movedCount: s.moved.length })),
+    account: data.account,
+  };
+}
+
+function monthSummary(m: any) {
+  need(m, ["scenario", "month", "usd", "by", "keys", "days", "noPrice", "noRule", "loadUndefined", "overflowHours",
+    "warnings", "warningCount"], "cost infra month");
+  const totals: Record<string, number> = {};
+  for (const d of m.days) {
+    need(d, ["date", "usd", "stack"], "cost infra day of the month");
+    for (const [k, v] of Object.entries(d.stack)) totals[k] = (totals[k] ?? 0) + (v as number);
+  }
+  const label = Object.fromEntries(m.keys.map((k: any) => [k.key, k.label]));
+  return {
+    scenario: m.scenario,
+    month: m.month,
+    usd: m.usd,
+    by: m.by,
+    totals: Object.entries(totals).sort((a, b) => b[1] - a[1])
+      .map(([key, usd]) => ({ key: key === "__others__" ? "others" : key, label: label[key] ?? key, usd })),
+    days: m.days.length,
+    dearestDay: m.days.reduce((a: any, b: any) => (b.usd > a.usd ? b : a), m.days[0])?.date ?? null,
+    noPrice: m.noPrice,
+    noRule: m.noRule,
+    loadUndefined: m.loadUndefined,
+    overflowHours: m.overflowHours,
+    notes: m.warnings.slice(0, FIRST).map((w: any) => (typeof w === "string" ? w : w.message)),
+    noteCount: m.warningCount,
+  };
+}
+
+function daySummary(day: any) {
+  need(day, ["scenario", "date", "usd", "nodes", "others"], "cost infra day");
+  return {
+    scenario: day.scenario,
+    date: day.date,
+    usd: day.usd,
+    nodes: day.nodes.map((n: any) => {
+      need(n, ["node", "usd", "hours"], "cost infra day node");
+      const meters: Record<string, { usd: number; amount: number; unit: string; sku: string; layer: string | null }> = {};
+      let peak = { hour: 0, usd: -1 };
+      n.hours.forEach((h: any, i: number) => {
+        if (h.usd > peak.usd) peak = { hour: day.hours?.[i] ?? i, usd: h.usd };
+        for (const s of h.segments ?? []) {
+          const m = (meters[s.meter] ??= { usd: 0, amount: 0, unit: s.unit, sku: s.sku, layer: s.price?.layer ?? null });
+          m.usd += s.usd ?? 0;
+          m.amount += s.amount ?? 0;
+        }
+      });
+      const overflowHours = n.hours.filter((h: any) => h.load && h.load.overflow > 0).length;
+      return {
+        node: n.node, label: n.label, provider: n.provider, rule: n.rule, note: n.note || undefined, usd: n.usd,
+        peakHour: peak.usd >= 0 ? peak.hour : null, meters, overflowHours: overflowHours || undefined,
+      };
+    }),
+    others: { count: day.others.count, usd: (day.others.usd as number[]).reduce((a, b) => a + b, 0) },
+  };
+}
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_cost",
+    "Simulate the server room's cost with `jsonui-doc cost infra --json` (the model, a load scenario under docs/infra/load, prices: the room's own, then fetched, then bundled — USD, on demand). Without date: the month's total, totals by provider (or by node), the top nodes, the dearest day, what has no price / no rule / no load, hours over capacity, notes. With date (YYYY-MM-DD in the scenario's month): that day's top nodes, each with its charge by meter, the price layer, and its peak hour. Also the scenarios there are, the load problems and the price-book warnings (prices.free_dropped: a room's price row dropping a bundled free amount). With plan (a migration plan's name, docs/infra/migrations/<name>): the month's old, new and difference — per node (added / replaced / removed / same, the biggest changes first), per provider, after each step of the plan (a step's difference is the whole month's change at that step, not its node's own: moved names each node or line's transfer that moved), what is not priced in the old or the new (unpricedChanged: changed nodes whose part the difference leaves out — not a saving), and with account the account's month too (its environments priced together); date and by do not apply. Needs jsonui-cli 2.3.15+ (plan: 2.3.20+).",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+      scenario: z.string().optional().describe("Load scenario id (default: the first)"),
+      date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().describe("One day of the scenario's month (YYYY-MM-DD)"),
+      by: z.enum(["provider", "node"]).optional().describe("Group the month's totals by provider (default) or node"),
+      plan: z.string().optional().describe("A migration plan's name: the month's old / new / difference instead"),
+      account: z.boolean().optional().describe("With plan: the account's month too — its environments priced together, old / new / difference"),
+    },
+    async ({ project_dir, scenario, date, by, plan, account }) => {
+      try {
+        if (!plan && account) return failure(new Error("account applies with plan only"));
+        if (plan && (date || by)) return failure(new Error("date and by do not apply with plan: it answers by node and by provider at once, for the month"));
+        const projectDir = config.resolveProjectDir(project_dir);
+        const args = ["cost", "infra", projectDir, "--json"];
+        if (plan) args.push("--migration", plan);
+        if (account) args.push("--account");
+        if (scenario) args.push("--scenario", scenario);
+        if (date) args.push("--date", date);
+        if (by) args.push("--by", by);
+        const { exitCode, data } = await runDocJson(args, projectDir, 180_000);
+        need(data, ["ok"], "cost infra");
+        if (!data.ok) {
+          need(data, ["reason", "message"], "cost infra");
+          return text({ ok: false, exit: exitCode, reason: data.reason, message: data.message,
+            ...(data.problems ? { problems: problems(data.problems, "cost infra") } : {}) });
+        }
+        need(data, ["dir", "scenario", "scenarios", "problems", "prices"], "cost infra");
+        need(data.problems, ["count", "errors", "first"], "cost infra problems");
+        need(data.prices, ["warnings", "warningCount"], "cost infra prices");
+        if (plan) {
+          // the load problems and price warnings are the old model's reading, as without plan
+          return text({ ok: exitCode === 0, exit: exitCode, dir: data.dir, scenarios: data.scenarios,
+            ...migrationSummary(data), loadProblems: data.problems, priceWarnings: data.prices.warnings,
+            priceWarningCount: data.prices.warningCount });
+        }
+        const out: Record<string, unknown> = {
+          ok: exitCode === 0,
+          exit: exitCode,
+          dir: data.dir,
+          scenario: data.scenario,
+          scenarios: data.scenarios,
+          loadProblems: data.problems,
+          priceWarnings: data.prices.warnings,
+          priceWarningCount: data.prices.warningCount,
+        };
+        if (date) {
+          need(data, ["day"], "cost infra");
+          out.day = daySummary(data.day);
+        } else {
+          need(data, ["month", "topNodes"], "cost infra");
+          out.month = monthSummary(data.month);
+          out.topNodes = data.topNodes;
+        }
+        return text(out);
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}

package/src/tools/infra/infra_load_validate.ts

@@ -0,0 +1,46 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { failure, need, problems, runDocJson, text } from "./infra_common.js";
+
+/**
+ * `jsonui-doc validate infra-load <project> --json`: the load scenarios the cost simulator reads (<infra.dir>/load,
+ * or infra.load_dir) against their schema and against the model. Exit 0: no error; 1: errors; 2: the model or the
+ * folder cannot be read (reason).
+ */
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "infra_load_validate",
+    "Validate the server room's load scenarios (docs/infra/load/*.json) with `jsonui-doc validate infra-load --json`. Returns each scenario (id, environment, month, hours, loads, edges) and the problems by severity and code with the first 20 (file, path, code, message, node, hour, quantity). load.overlap means a node has two rows and only one counts. Needs jsonui-cli 2.3.15+.",
+    {
+      project_dir: z.string().optional().describe("Project directory with jui.config.json (overrides JUI_PROJECT_DIR env)"),
+    },
+    async ({ project_dir }) => {
+      try {
+        const projectDir = config.resolveProjectDir(project_dir);
+        const { exitCode, data } = await runDocJson(["validate", "infra-load", projectDir, "--json"], projectDir);
+        need(data, ["ok"], "validate infra-load");
+        if (!data.ok) {
+          need(data, ["reason", "message"], "validate infra-load");
+          return text({ ok: false, exit: exitCode, readable: false, reason: data.reason, message: data.message });
+        }
+        need(data, ["dir", "files", "problems", "scenarios"], "validate infra-load");
+        for (const s of data.scenarios) need(s, ["id", "environment", "month", "hours", "loads", "edges"], "validate infra-load scenario");
+        return text({
+          ok: exitCode === 0,
+          exit: exitCode,
+          readable: true,
+          dir: data.dir,
+          files: data.files,
+          scenarios: data.scenarios.map((s: any) => ({
+            id: s.id, file: s.file, environment: s.environment, month: s.month, hours: s.hours, loads: s.loads, edges: s.edges,
+          })),
+          problems: problems(data.problems, "validate infra-load",
+            ["severity", "code", "file", "path", "message", "node", "hour", "quantity"]),
+        });
+      } catch (e: any) {
+        return failure(e);
+      }
+    }
+  );
+}