@umec/core 0.1.0-alpha.11 → 0.1.0-alpha.12

package/dist/cli.js

@@ -14,8 +14,8 @@ import {
 } from "./chunk-T2PO3YLZ.js";
 
 // src/cli/index.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join7 } from "path";
 
 // src/cli/doctor.ts
 import { existsSync } from "fs";
@@ -582,10 +582,839 @@ function coreVersionFromPackage(root = findPackageRoot()) {
   return pkg.version;
 }
 
+// src/cli/registry.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join5, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+
+// src/cli/template-doctor.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "fs";
+import { isAbsolute, join as join4, relative, resolve, sep } from "path";
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".astro",
+  ".wrangler",
+  "coverage",
+  ".output",
+  ".cache",
+  ".pnpm-store"
+]);
+function isZone(value) {
+  return value === "managed" || value === "brand" || value === "generated";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isHttpsUrl(value) {
+  return /^https:\/\//i.test(value);
+}
+function isSafeRelPath(posixPath) {
+  if (!posixPath || posixPath.startsWith("/") || posixPath.includes("\\") || posixPath.includes("\0")) {
+    return false;
+  }
+  const parts = posixPath.split("/");
+  return parts.every((part) => part !== "" && part !== "." && part !== "..");
+}
+function resolveInstancePath(cwd, posixPath) {
+  if (!isSafeRelPath(posixPath)) return null;
+  const resolved = resolve(cwd, ...posixPath.split("/"));
+  const rel = relative(resolve(cwd), resolved);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) return null;
+  return resolved;
+}
+function parseTemplateManifest(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error("manifest \u306E JSON \u304C\u4E0D\u6B63\u3067\u3059\u3002");
+  }
+  if (!isRecord(parsed)) throw new Error("manifest \u306E JSON \u304C\u4E0D\u6B63\u3067\u3059\u3002");
+  if (parsed.schemaVersion !== 1) {
+    throw new Error(`manifest schemaVersion ${String(parsed.schemaVersion)} \u306B\u306F\u672A\u5BFE\u5FDC\u3067\u3059\uFF08\u5BFE\u5FDC: 1\uFF09\u3002`);
+  }
+  if (typeof parsed.templateVersion !== "string" || parsed.templateVersion.length === 0) {
+    throw new Error("manifest.templateVersion \u304C\u5FC5\u8981\u3067\u3059\u3002");
+  }
+  if (typeof parsed.generatedAt !== "string" || parsed.generatedAt.length === 0) {
+    throw new Error("manifest.generatedAt \u304C\u5FC5\u8981\u3067\u3059\u3002");
+  }
+  if (!Array.isArray(parsed.files)) {
+    throw new Error("manifest.files \u304C\u5FC5\u8981\u3067\u3059\u3002");
+  }
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of parsed.files) {
+    if (!isRecord(entry)) throw new Error("manifest.files \u306E\u8981\u7D20\u304C\u4E0D\u6B63\u3067\u3059\u3002");
+    if (typeof entry.path !== "string" || !isSafeRelPath(entry.path)) {
+      throw new Error(`manifest \u306E path \u304C\u4E0D\u6B63\u3067\u3059: ${String(entry.path)}`);
+    }
+    if (seen.has(entry.path)) {
+      throw new Error(`manifest \u306E path \u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059: ${entry.path}`);
+    }
+    if (typeof entry.sha256 !== "string" || !SHA256_HEX.test(entry.sha256.toLowerCase())) {
+      throw new Error(`manifest \u306E sha256 \u304C\u4E0D\u6B63\u3067\u3059: ${entry.path}`);
+    }
+    if (!isZone(entry.zone)) {
+      throw new Error(`manifest \u306E zone \u304C\u4E0D\u6B63\u3067\u3059: ${entry.path} (${String(entry.zone)})`);
+    }
+    seen.add(entry.path);
+    files.push({
+      path: entry.path,
+      sha256: entry.sha256.toLowerCase(),
+      zone: entry.zone
+    });
+  }
+  return {
+    schemaVersion: 1,
+    templateVersion: parsed.templateVersion,
+    generatedAt: parsed.generatedAt,
+    files
+  };
+}
+async function loadManifestText(source, cwd, fetchImpl = globalThis.fetch) {
+  if (isHttpsUrl(source)) {
+    const response = await fetchImpl(source, { signal: AbortSignal.timeout(15e3) });
+    if (!response.ok) {
+      throw new Error(`manifest \u3092\u53D6\u5F97\u3067\u304D\u307E\u305B\u3093 (${response.status}): ${source}`);
+    }
+    return { text: await response.text(), origin: source };
+  }
+  if (/^https?:\/\//i.test(source)) {
+    throw new Error("manifest URL \u306F https:// \u306E\u307F\u53D7\u3051\u4ED8\u3051\u307E\u3059\u3002");
+  }
+  const path = isAbsolute(source) ? source : resolve(cwd, source);
+  if (!existsSync3(path) || !statSync(path).isFile()) {
+    throw new Error(`manifest \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${source}`);
+  }
+  return { text: readFileSync4(path, "utf8"), origin: path };
+}
+function toPosix(rel) {
+  return rel.split(sep).join("/");
+}
+function listInstanceFiles(cwd) {
+  const root = resolve(cwd);
+  const out = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (entry.name === ".DS_Store") continue;
+      const full = join4(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) continue;
+        walk(full);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      out.push(toPosix(relative(root, full)));
+    }
+  };
+  walk(root);
+  out.sort();
+  return out;
+}
+function classifyTemplate(input) {
+  const files = [];
+  const tracked = new Set(input.manifest.files.map((file) => file.path));
+  for (const entry of input.manifest.files) {
+    if (entry.zone === "generated") continue;
+    const resolved = resolveInstancePath(input.cwd, entry.path);
+    if (!resolved || !existsSync3(resolved) || !statSync(resolved).isFile()) {
+      files.push({ path: entry.path, status: "missing", zone: entry.zone, expected: entry.sha256 });
+      continue;
+    }
+    const actual = sha256File(resolved);
+    if (actual === entry.sha256) {
+      files.push({ path: entry.path, status: "match", zone: entry.zone, actual });
+    } else {
+      files.push({
+        path: entry.path,
+        status: "modified",
+        zone: entry.zone,
+        expected: entry.sha256,
+        actual
+      });
+    }
+  }
+  for (const path of listInstanceFiles(input.cwd)) {
+    if (tracked.has(path)) continue;
+    files.push({ path, status: "untracked" });
+  }
+  const counts = {
+    match: files.filter((file) => file.status === "match").length,
+    modified: files.filter((file) => file.status === "modified").length,
+    missing: files.filter((file) => file.status === "missing").length,
+    untracked: files.filter((file) => file.status === "untracked").length
+  };
+  const ok = !files.some(
+    (file) => file.zone === "managed" && (file.status === "modified" || file.status === "missing")
+  );
+  return {
+    schemaVersion: 1,
+    templateVersion: input.manifest.templateVersion,
+    generatedAt: input.manifest.generatedAt,
+    manifest: input.origin,
+    ok,
+    counts,
+    files
+  };
+}
+function formatTemplateReport(report) {
+  const lines = [
+    `template version: ${report.templateVersion}`,
+    `generated at: ${report.generatedAt}`,
+    `match: ${report.counts.match}`,
+    `modified: ${report.counts.modified}`,
+    `missing: ${report.counts.missing}`,
+    `untracked: ${report.counts.untracked}`
+  ];
+  for (const file of report.files) {
+    if (file.status === "match") continue;
+    if (file.status === "untracked") {
+      lines.push(`untracked: ${file.path}`);
+      continue;
+    }
+    if (file.zone === "managed" && (file.status === "modified" || file.status === "missing")) {
+      lines.push(`error: ${file.status} managed ${file.path}`);
+      continue;
+    }
+    lines.push(`${file.status} ${file.zone} ${file.path}`);
+  }
+  return lines;
+}
+async function runTemplateDoctor(options) {
+  const print = options.print ?? (() => {
+  });
+  const lines = [];
+  const say = (line) => {
+    lines.push(line);
+    print(line);
+  };
+  try {
+    const loaded = await loadManifestText(options.manifest, options.cwd, options.fetch);
+    const manifest = parseTemplateManifest(loaded.text);
+    const report = classifyTemplate({
+      cwd: options.cwd,
+      manifest,
+      origin: loaded.origin
+    });
+    if (options.json) {
+      say(JSON.stringify(report, null, 2));
+    } else {
+      for (const line of formatTemplateReport(report)) say(line);
+    }
+    return { exitCode: report.ok ? 0 : 1, lines, report };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { exitCode: 1, lines, error: message };
+  }
+}
+
+// src/cli/registry.ts
+var INSTALLED_RECORD_REL = ".umec/installed-registry-items.json";
+var ITEM_ID = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+var SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRisk(value) {
+  return value === "low" || value === "medium" || value === "high";
+}
+function isRegistryItemId(value) {
+  return ITEM_ID.test(value);
+}
+function defaultRegistryRoot(root = findPackageRoot()) {
+  return join5(root, "registry");
+}
+function toPosix2(rel) {
+  return rel.split(sep2).join("/");
+}
+function stripInlineComment(line) {
+  let quote = null;
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if (quote) {
+      if (char === quote && line[i - 1] !== "\\") quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "#") return line.slice(0, i).trimEnd();
+  }
+  return line;
+}
+function splitTopLevel(input, sep3) {
+  const parts = [];
+  let buf = "";
+  let depthBrace = 0;
+  let depthBracket = 0;
+  let quote = null;
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i] ?? "";
+    if (quote) {
+      buf += char;
+      if (char === quote && input[i - 1] !== "\\") quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      buf += char;
+      continue;
+    }
+    if (char === "{") depthBrace += 1;
+    if (char === "}") depthBrace -= 1;
+    if (char === "[") depthBracket += 1;
+    if (char === "]") depthBracket -= 1;
+    if (char === sep3 && depthBrace === 0 && depthBracket === 0) {
+      if (buf.trim()) parts.push(buf.trim());
+      buf = "";
+      continue;
+    }
+    buf += char;
+  }
+  if (buf.trim()) parts.push(buf.trim());
+  return parts;
+}
+function splitKeyValue(input) {
+  let quote = null;
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i];
+    if (quote) {
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === ":") return [input.slice(0, i).trim(), input.slice(i + 1).trim()];
+  }
+  return null;
+}
+function unquote(input) {
+  if (input.startsWith('"') && input.endsWith('"') && input.length >= 2 || input.startsWith("'") && input.endsWith("'") && input.length >= 2) {
+    return input.slice(1, -1);
+  }
+  return input;
+}
+function parseYamlValue(raw) {
+  const value = raw.trim();
+  if (value === "") return "";
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (value.startsWith("{") && value.endsWith("}")) {
+    const entries = splitTopLevel(value.slice(1, -1), ",");
+    const record = {};
+    for (const entry of entries) {
+      const kv = splitKeyValue(entry);
+      if (!kv) throw new Error(`frontmatter \u306E object \u304C\u4E0D\u6B63\u3067\u3059: ${entry}`);
+      record[unquote(kv[0])] = parseYamlValue(kv[1]);
+    }
+    return record;
+  }
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return splitTopLevel(value.slice(1, -1), ",").map((entry) => parseYamlValue(entry));
+  }
+  return unquote(value);
+}
+function parseFrontmatter(text) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+  if (!match) throw new Error("manifest.md \u306B YAML frontmatter \u304C\u3042\u308A\u307E\u305B\u3093\u3002");
+  const data = {};
+  for (const rawLine of match[1].split(/\r?\n/)) {
+    const line = stripInlineComment(rawLine).trim();
+    if (!line) continue;
+    const kv = splitKeyValue(line);
+    if (!kv || !kv[0]) throw new Error(`frontmatter \u306E\u884C\u304C\u4E0D\u6B63\u3067\u3059: ${rawLine}`);
+    data[kv[0]] = parseYamlValue(kv[1]);
+  }
+  return { data, body: match[2] };
+}
+function parseStringArray(value, field) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.length === 0)) {
+    throw new Error(`${field} \u306F\u6587\u5B57\u5217\u306E\u914D\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002`);
+  }
+  return value;
+}
+function parseRequires(value) {
+  if (value === void 0) return {};
+  if (!isRecord2(value)) throw new Error("requires \u306F object \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002");
+  const requires = {};
+  for (const key of Object.keys(value)) {
+    if (key !== "core" && key !== "admin" && key !== "items") {
+      throw new Error(`requires.${key} \u306B\u306F\u672A\u5BFE\u5FDC\u3067\u3059\uFF08\u5BFE\u5FDC: core, admin, items\uFF09\u3002`);
+    }
+  }
+  if (value.core !== void 0) {
+    if (typeof value.core !== "string" || value.core.length === 0) {
+      throw new Error("requires.core \u306F\u30D0\u30FC\u30B8\u30E7\u30F3\u7BC4\u56F2\u306E\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002");
+    }
+    requires.core = value.core;
+  }
+  if (value.admin !== void 0) {
+    if (typeof value.admin !== "string" || value.admin.length === 0) {
+      throw new Error("requires.admin \u306F\u30D0\u30FC\u30B8\u30E7\u30F3\u7BC4\u56F2\u306E\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002");
+    }
+    requires.admin = value.admin;
+  }
+  if (value.items !== void 0) {
+    requires.items = parseStringArray(value.items, "requires.items");
+    for (const id of requires.items) {
+      if (!isRegistryItemId(id)) throw new Error(`requires.items \u306E id \u304C\u4E0D\u6B63\u3067\u3059: ${id}`);
+    }
+  }
+  return requires;
+}
+function parseSemVer(input) {
+  const match = SEMVER.exec(input.trim());
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function compareIdentifier(a, b) {
+  const aNum = /^\d+$/.test(a);
+  const bNum = /^\d+$/.test(b);
+  if (aNum && bNum) return Number(a) - Number(b);
+  if (aNum !== bNum) return aNum ? -1 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareSemVer(a, b) {
+  if (a.major !== b.major) return a.major - b.major;
+  if (a.minor !== b.minor) return a.minor - b.minor;
+  if (a.patch !== b.patch) return a.patch - b.patch;
+  if (a.prerelease.length === 0 && b.prerelease.length === 0) return 0;
+  if (a.prerelease.length === 0) return 1;
+  if (b.prerelease.length === 0) return -1;
+  const n = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let i = 0; i < n; i += 1) {
+    const left = a.prerelease[i];
+    const right = b.prerelease[i];
+    if (left === void 0) return -1;
+    if (right === void 0) return 1;
+    const cmp = compareIdentifier(left, right);
+    if (cmp !== 0) return cmp;
+  }
+  return 0;
+}
+function satisfiesVersionRange(version, range) {
+  const parsed = parseSemVer(version);
+  if (!parsed) throw new Error(`\u30D0\u30FC\u30B8\u30E7\u30F3\u304C\u4E0D\u6B63\u3067\u3059: ${version}`);
+  const trimmed = range.trim();
+  const operators = [">=", "<=", ">", "<", "="];
+  const operator = operators.find((item) => trimmed.startsWith(item));
+  const spec = operator ? trimmed.slice(operator.length).trim() : trimmed;
+  const target = parseSemVer(spec);
+  if (!target) throw new Error(`\u30D0\u30FC\u30B8\u30E7\u30F3\u7BC4\u56F2\u304C\u4E0D\u6B63\u3067\u3059: ${range}`);
+  const cmp = compareSemVer(parsed, target);
+  if (operator === ">=") return cmp >= 0;
+  if (operator === ">") return cmp > 0;
+  if (operator === "<=") return cmp <= 0;
+  if (operator === "<") return cmp < 0;
+  return cmp === 0;
+}
+function titleFromBody(body, fallback) {
+  const heading = /^#\s+(.+)$/m.exec(body);
+  const title = heading?.[1]?.trim();
+  return title && title.length > 0 ? title : fallback;
+}
+function listFilesRecursive(root) {
+  const out = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+      if (entry.name === ".DS_Store" || entry.name.startsWith(".")) continue;
+      const full = join5(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const rel = toPosix2(relative2(root, full));
+      if (!isSafeRelPath(rel)) throw new Error(`registry \u306E path \u304C\u4E0D\u6B63\u3067\u3059: ${rel}`);
+      out.push(rel);
+    }
+  };
+  walk(root);
+  out.sort();
+  return out;
+}
+function loadItemFiles(itemDir) {
+  const filesRoot = join5(itemDir, "files");
+  if (!existsSync4(filesRoot) || !statSync2(filesRoot).isDirectory()) {
+    throw new Error("files/ \u304C\u3042\u308A\u307E\u305B\u3093\u3002");
+  }
+  const paths = listFilesRecursive(filesRoot);
+  if (paths.length === 0) throw new Error("files/ \u304C\u7A7A\u3067\u3059\u3002");
+  return paths.map((path) => {
+    const sourcePath = join5(filesRoot, ...path.split("/"));
+    return { path, sourcePath, sha256: sha256File(sourcePath) };
+  });
+}
+function parseRegistryManifest(text) {
+  const { data, body } = parseFrontmatter(text);
+  if (typeof data.id !== "string" || !isRegistryItemId(data.id)) {
+    throw new Error(`manifest.md \u306E id \u304C\u4E0D\u6B63\u3067\u3059: ${String(data.id)}`);
+  }
+  if (typeof data.version !== "string" || !parseSemVer(data.version)) {
+    throw new Error(`manifest.md \u306E version \u304C\u4E0D\u6B63\u3067\u3059: ${String(data.version)}`);
+  }
+  if (!isRisk(data.risk)) {
+    throw new Error(`manifest.md \u306E risk \u304C\u4E0D\u6B63\u3067\u3059: ${String(data.risk)}`);
+  }
+  return {
+    id: data.id,
+    version: data.version,
+    title: titleFromBody(body, data.id),
+    risk: data.risk,
+    requires: parseRequires(data.requires),
+    touches: parseStringArray(data.touches, "touches")
+  };
+}
+function loadRegistryItem(registryRoot, itemId) {
+  if (!isRegistryItemId(itemId)) {
+    throw new Error(`registry item id \u304C\u4E0D\u6B63\u3067\u3059: ${itemId}`);
+  }
+  const dir = resolve2(registryRoot, itemId);
+  const rel = relative2(resolve2(registryRoot), dir);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel) || rel.includes(sep2)) {
+    throw new Error(`registry item id \u304C\u4E0D\u6B63\u3067\u3059: ${itemId}`);
+  }
+  const manifestPath = join5(dir, "manifest.md");
+  if (!existsSync4(dir) || !statSync2(dir).isDirectory() || !existsSync4(manifestPath) || !statSync2(manifestPath).isFile()) {
+    throw new Error(`registry item \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${itemId}`);
+  }
+  const parsed = parseRegistryManifest(readFileSync5(manifestPath, "utf8"));
+  if (parsed.id !== itemId) {
+    throw new Error(`manifest.md \u306E id (${parsed.id}) \u304C\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u540D (${itemId}) \u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002`);
+  }
+  return {
+    ...parsed,
+    files: loadItemFiles(dir),
+    dir,
+    manifestPath
+  };
+}
+function listRegistryItems(registryRoot) {
+  if (!existsSync4(registryRoot)) return [];
+  if (!statSync2(registryRoot).isDirectory()) {
+    throw new Error(`registry \u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u304C\u4E0D\u6B63\u3067\u3059: ${registryRoot}`);
+  }
+  const ids = readdirSync3(registryRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".") && existsSync4(join5(registryRoot, entry.name, "manifest.md"))).map((entry) => entry.name).sort();
+  return ids.map((id) => loadRegistryItem(registryRoot, id));
+}
+function catalogEntry(item) {
+  return {
+    id: item.id,
+    version: item.version,
+    title: item.title,
+    risk: item.risk,
+    requires: item.requires,
+    touches: item.touches
+  };
+}
+function formatRequires(requires) {
+  const parts = [];
+  if (requires.core) parts.push(`core ${requires.core}`);
+  if (requires.admin) parts.push(`admin ${requires.admin}`);
+  if (requires.items?.length) parts.push(`items ${requires.items.join(", ")}`);
+  return parts.length > 0 ? parts.join("; ") : "(none)";
+}
+function sayResult(print, lines, line) {
+  lines.push(line);
+  print(line);
+}
+function finishJson(print, lines, payload, exitCode) {
+  sayResult(print, lines, JSON.stringify(payload, null, 2));
+  return { exitCode, lines };
+}
+function finishError(options, error, extra = {}) {
+  if (options.json) return finishJson(options.print, options.lines, { ok: false, error, ...extra }, 1);
+  return { exitCode: 1, lines: options.lines, error };
+}
+function readCustomerPackageVersion(cwd, packageName) {
+  const path = join5(cwd, "node_modules", ...packageName.split("/"), "package.json");
+  if (!existsSync4(path) || !statSync2(path).isFile()) return null;
+  try {
+    const pkg = JSON.parse(readFileSync5(path, "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function readInstalledRecord(cwd) {
+  const path = resolveInstancePath(cwd, INSTALLED_RECORD_REL);
+  if (!path || !existsSync4(path) || !statSync2(path).isFile()) {
+    return { schemaVersion: 1, items: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync5(path, "utf8"));
+  } catch {
+    throw new Error(`${INSTALLED_RECORD_REL} \u306E JSON \u304C\u4E0D\u6B63\u3067\u3059\u3002`);
+  }
+  if (!isRecord2(parsed) || parsed.schemaVersion !== 1 || !Array.isArray(parsed.items)) {
+    throw new Error(`${INSTALLED_RECORD_REL} \u306E schemaVersion \u306F 1 \u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\u3002`);
+  }
+  const items = [];
+  for (const entry of parsed.items) {
+    if (!isRecord2(entry)) throw new Error(`${INSTALLED_RECORD_REL} \u306E items \u304C\u4E0D\u6B63\u3067\u3059\u3002`);
+    if (typeof entry.id !== "string" || !isRegistryItemId(entry.id)) {
+      throw new Error(`${INSTALLED_RECORD_REL} \u306E id \u304C\u4E0D\u6B63\u3067\u3059: ${String(entry.id)}`);
+    }
+    if (typeof entry.version !== "string" || !parseSemVer(entry.version)) {
+      throw new Error(`${INSTALLED_RECORD_REL} \u306E version \u304C\u4E0D\u6B63\u3067\u3059: ${entry.id}`);
+    }
+    if (typeof entry.appliedAt !== "string" || entry.appliedAt.length === 0) {
+      throw new Error(`${INSTALLED_RECORD_REL} \u306E appliedAt \u304C\u4E0D\u6B63\u3067\u3059: ${entry.id}`);
+    }
+    items.push({ id: entry.id, version: entry.version, appliedAt: entry.appliedAt });
+  }
+  return { schemaVersion: 1, items };
+}
+function writeInstalledRecord(cwd, record) {
+  const path = resolveInstancePath(cwd, INSTALLED_RECORD_REL);
+  if (!path) throw new Error(`${INSTALLED_RECORD_REL} \u3092\u66F8\u304D\u8FBC\u3081\u307E\u305B\u3093\u3002`);
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(record, null, 2)}
+`);
+  return INSTALLED_RECORD_REL;
+}
+function upsertInstalledItem(record, item) {
+  const items = record.items.slice();
+  const index = items.findIndex((entry) => entry.id === item.id);
+  if (index >= 0) items[index] = item;
+  else items.push(item);
+  return { schemaVersion: 1, items };
+}
+function classifyRegistryFiles(cwd, files) {
+  return files.map((file) => {
+    const resolved = resolveInstancePath(cwd, file.path);
+    if (!resolved || !existsSync4(resolved) || !statSync2(resolved).isFile()) {
+      return { path: file.path, status: "missing", expected: file.sha256 };
+    }
+    const actual = sha256File(resolved);
+    if (actual === file.sha256) return { path: file.path, status: "match", actual };
+    return { path: file.path, status: "modified", expected: file.sha256, actual };
+  });
+}
+function unmetRequires(input) {
+  const messages = [];
+  const { item } = input;
+  if (item.requires.core) {
+    try {
+      if (!satisfiesVersionRange(input.coreVersion, item.requires.core)) {
+        messages.push(
+          `@umec/core ${item.requires.core} \u304C\u5FC5\u8981\u3067\u3059\uFF08\u73FE\u5728 ${input.coreVersion}\uFF09\u3002pnpm update @umec/core \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+        );
+      }
+    } catch (error) {
+      messages.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  if (item.requires.admin) {
+    if (!input.adminVersion) {
+      messages.push(
+        `@umec/admin ${item.requires.admin} \u304C\u5FC5\u8981\u3067\u3059\u3002\u5148\u306B @umec/admin \u3092\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+      );
+    } else {
+      try {
+        if (!satisfiesVersionRange(input.adminVersion, item.requires.admin)) {
+          messages.push(
+            `@umec/admin ${item.requires.admin} \u304C\u5FC5\u8981\u3067\u3059\uFF08\u73FE\u5728 ${input.adminVersion}\uFF09\u3002`
+          );
+        }
+      } catch (error) {
+        messages.push(error instanceof Error ? error.message : String(error));
+      }
+    }
+  }
+  for (const requiredId of item.requires.items ?? []) {
+    if (!input.installed.items.some((entry) => entry.id === requiredId)) {
+      messages.push(`\u5148\u306B umec add ${requiredId} \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+    }
+  }
+  return messages;
+}
+async function runRegistryList(options) {
+  const print = options.print ?? (() => {
+  });
+  const lines = [];
+  try {
+    const registryRoot = options.registryRoot ?? defaultRegistryRoot();
+    const items = listRegistryItems(registryRoot).map(catalogEntry);
+    if (options.json) {
+      return finishJson(print, lines, { schemaVersion: 1, items }, 0);
+    }
+    if (items.length === 0) {
+      sayResult(print, lines, "(no registry items)");
+      return { exitCode: 0, lines };
+    }
+    for (const item of items) {
+      sayResult(print, lines, `${item.id}  ${item.version}  ${item.risk}`);
+      sayResult(print, lines, `  ${item.title}`);
+      sayResult(print, lines, `  requires: ${formatRequires(item.requires)}`);
+    }
+    return { exitCode: 0, lines };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return finishError({ json: options.json, print, lines }, message);
+  }
+}
+async function runRegistryAdd(options) {
+  const print = options.print ?? (() => {
+  });
+  const lines = [];
+  const itemId = options.itemId;
+  if (!itemId) {
+    return finishError({ json: options.json, print, lines }, "umec add \u306B\u306F <item-id> \u307E\u305F\u306F --list \u304C\u5FC5\u8981\u3067\u3059\u3002");
+  }
+  try {
+    const registryRoot = options.registryRoot ?? defaultRegistryRoot();
+    const item = loadRegistryItem(registryRoot, itemId);
+    const installed = readInstalledRecord(options.cwd);
+    const coreVersion = options.coreVersion ?? coreVersionFromPackage();
+    const adminVersion = options.adminVersion !== void 0 ? options.adminVersion : readCustomerPackageVersion(options.cwd, "@umec/admin");
+    const unmet = unmetRequires({ item, coreVersion, adminVersion, installed });
+    if (unmet.length > 0) {
+      return finishError(
+        { json: options.json, print, lines },
+        unmet.join("\n"),
+        { id: item.id, version: item.version, unmet }
+      );
+    }
+    const findings = classifyRegistryFiles(options.cwd, item.files);
+    const modified = findings.filter((file) => file.status === "modified");
+    if (modified.length > 0 && options.force !== true) {
+      const error = `\u6539\u5909\u6E08\u307F\u306E\u30D5\u30A1\u30A4\u30EB\u304C\u3042\u308B\u305F\u3081 ${item.id} \u3092\u66F8\u304D\u8FBC\u307F\u307E\u305B\u3093\u3002umec diff ${item.id} \u3067\u5DEE\u5206\u3092\u78BA\u8A8D\u3057\u3001\u4E0A\u66F8\u304D\u3059\u308B\u5834\u5408\u306F umec add ${item.id} --force \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002`;
+      if (options.json) {
+        return finishJson(
+          print,
+          lines,
+          { ok: false, id: item.id, version: item.version, error, files: findings },
+          1
+        );
+      }
+      for (const file of modified) sayResult(print, lines, `modified: ${file.path}`);
+      return { exitCode: 1, lines, error };
+    }
+    const written = [];
+    const unchanged = [];
+    for (const file of item.files) {
+      const dest = resolveInstancePath(options.cwd, file.path);
+      if (!dest) throw new Error(`\u66F8\u304D\u8FBC\u307F\u5148\u304C\u4E0D\u6B63\u3067\u3059: ${file.path}`);
+      if (existsSync4(dest) && !statSync2(dest).isFile()) {
+        throw new Error(`${file.path} \u306F\u30D5\u30A1\u30A4\u30EB\u3067\u306F\u306A\u3044\u305F\u3081\u66F8\u304D\u8FBC\u3081\u307E\u305B\u3093\u3002`);
+      }
+      const finding = findings.find((entry) => entry.path === file.path);
+      if (finding?.status === "match") {
+        unchanged.push(file.path);
+        continue;
+      }
+      mkdirSync2(dirname2(dest), { recursive: true });
+      writeFileSync2(dest, readFileSync5(file.sourcePath));
+      written.push(file.path);
+    }
+    const appliedAt = new Date(options.now ?? Date.now()).toISOString();
+    const record = upsertInstalledItem(installed, { id: item.id, version: item.version, appliedAt });
+    writeInstalledRecord(options.cwd, record);
+    if (options.json) {
+      return finishJson(
+        print,
+        lines,
+        {
+          ok: true,
+          id: item.id,
+          version: item.version,
+          written,
+          unchanged,
+          record: INSTALLED_RECORD_REL,
+          appliedAt
+        },
+        0
+      );
+    }
+    sayResult(print, lines, `applied ${item.id}@${item.version}`);
+    for (const path of written) sayResult(print, lines, `wrote ${path}`);
+    for (const path of unchanged) sayResult(print, lines, `unchanged ${path}`);
+    sayResult(print, lines, `recorded ${INSTALLED_RECORD_REL}`);
+    return { exitCode: 0, lines };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return finishError({ json: options.json, print, lines }, message, itemId ? { id: itemId } : {});
+  }
+}
+function formatDiffReport(item, files) {
+  const counts = {
+    match: files.filter((file) => file.status === "match").length,
+    modified: files.filter((file) => file.status === "modified").length,
+    missing: files.filter((file) => file.status === "missing").length
+  };
+  const lines = [
+    `registry item: ${item.id} ${item.version}`,
+    `match: ${counts.match}`,
+    `modified: ${counts.modified}`,
+    `missing: ${counts.missing}`
+  ];
+  for (const file of files) {
+    if (file.status === "match") continue;
+    lines.push(`${file.status}: ${file.path}`);
+  }
+  return lines;
+}
+async function runRegistryDiff(options) {
+  const print = options.print ?? (() => {
+  });
+  const lines = [];
+  const itemId = options.itemId;
+  if (!itemId) {
+    return finishError({ json: options.json, print, lines }, "umec diff \u306B\u306F <item-id> \u304C\u5FC5\u8981\u3067\u3059\u3002");
+  }
+  try {
+    const registryRoot = options.registryRoot ?? defaultRegistryRoot();
+    const item = loadRegistryItem(registryRoot, itemId);
+    const files = classifyRegistryFiles(options.cwd, item.files);
+    const ok = files.every((file) => file.status === "match");
+    const counts = {
+      match: files.filter((file) => file.status === "match").length,
+      modified: files.filter((file) => file.status === "modified").length,
+      missing: files.filter((file) => file.status === "missing").length
+    };
+    if (options.json) {
+      return finishJson(
+        print,
+        lines,
+        {
+          schemaVersion: 1,
+          ok,
+          id: item.id,
+          version: item.version,
+          title: item.title,
+          counts,
+          files
+        },
+        ok ? 0 : 1
+      );
+    }
+    for (const line of formatDiffReport(item, files)) sayResult(print, lines, line);
+    return { exitCode: ok ? 0 : 1, lines };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return finishError({ json: options.json, print, lines }, message, { id: itemId });
+  }
+}
+
 // src/cli/wrangler.ts
 import { spawn } from "child_process";
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
 
 // src/cli/executor.ts
 function sqlLiteral(value) {
@@ -605,7 +1434,7 @@ function bindSql(sql, params = []) {
 
 // src/cli/wrangler.ts
 function defaultRunCommand(command, args, cwd) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn(command, args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -617,7 +1446,7 @@ function defaultRunCommand(command, args, cwd) {
     });
     child.on("error", reject);
     child.on("close", (code) => {
-      resolve({ code: code ?? 1, stdout, stderr });
+      resolve3({ code: code ?? 1, stdout, stderr });
     });
   });
 }
@@ -627,9 +1456,9 @@ function parseJsonc(text) {
 }
 function readD1DatabaseName(cwd, override) {
   if (override) return override;
-  const path = join4(cwd, "wrangler.jsonc");
+  const path = join6(cwd, "wrangler.jsonc");
   try {
-    const parsed = parseJsonc(readFileSync4(path, "utf8"));
+    const parsed = parseJsonc(readFileSync6(path, "utf8"));
     return parsed.d1_databases?.[0]?.database_name ?? null;
   } catch {
     return null;
@@ -655,7 +1484,7 @@ function createWranglerExecutor(options) {
   const execute = async (sql) => {
     const result = await runCommand(
       "wrangler",
-      ["d1", "execute", options.database, location, "--json", "--command", sql],
+      ["d1", "execute", options.database, location, "--json", `--command=${sql}`],
       options.cwd
     );
     if (result.code !== 0) {
@@ -703,8 +1532,21 @@ function createWranglerExecutor(options) {
 }
 
 // src/cli/index.ts
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "dry-run",
+  "adopt",
+  "repair",
+  "remote",
+  "local",
+  "template",
+  "json",
+  "help",
+  "force",
+  "list"
+]);
 function parseArgs(argv) {
   const flags = {};
+  const positionals = [];
   let command = null;
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
@@ -717,7 +1559,7 @@ function parseArgs(argv) {
       }
       const name = arg.slice(2);
       const next = argv[i + 1];
-      if (next && !next.startsWith("--") && name !== "dry-run" && name !== "adopt" && name !== "repair" && name !== "remote" && name !== "local") {
+      if (next && !next.startsWith("--") && !BOOLEAN_FLAGS.has(name)) {
         flags[name] = next;
         i += 1;
       } else {
@@ -726,24 +1568,83 @@ function parseArgs(argv) {
       continue;
     }
     if (!command) command = arg;
+    else positionals.push(arg);
   }
-  return { command, flags };
+  return { command, flags, positionals };
 }
 function usage() {
   return `Usage:
   umec migrate [--dry-run] [--local|--remote] [--adopt] [--repair] [--database NAME]
   umec doctor [--local|--remote] [--database NAME]
+  umec doctor --template --manifest <path-or-url> [--json]
+  umec add --list [--json]
+  umec add <item-id> [--force] [--json]
+  umec diff <item-id> [--json]
   umec extend [--key NAME] [--type boolean|string|number]`;
 }
 async function runCli(argv, io = {}) {
   const cwd = io.cwd ?? process.cwd();
   const stdout = io.stdout ?? ((message) => console.log(message));
   const stderr = io.stderr ?? ((message) => console.error(message));
-  const { command, flags } = parseArgs(argv);
+  const { command, flags, positionals } = parseArgs(argv);
   if (!command || command === "help" || flags.help) {
     stdout(usage());
     return command ? 0 : 1;
   }
+  if (command === "add" || command === "diff") {
+    if (command === "add" && flags.list === true) {
+      if (positionals.length > 0) {
+        stderr("umec add --list \u306F item-id \u3092\u53D6\u308A\u307E\u305B\u3093\u3002");
+        return 1;
+      }
+      const listed = await runRegistryList({
+        cwd,
+        json: flags.json === true,
+        print: stdout,
+        registryRoot: io.registryRoot
+      });
+      if (listed.error) stderr(listed.error);
+      return listed.exitCode;
+    }
+    if (positionals.length > 1) {
+      stderr(`umec ${command} \u306F item-id \u30921\u3064\u3060\u3051\u53D7\u3051\u53D6\u308A\u307E\u3059\u3002`);
+      return 1;
+    }
+    const result = command === "add" ? await runRegistryAdd({
+      cwd,
+      itemId: positionals[0],
+      force: flags.force === true,
+      json: flags.json === true,
+      print: stdout,
+      registryRoot: io.registryRoot,
+      coreVersion: io.coreVersion,
+      adminVersion: io.adminVersion,
+      now: io.now
+    }) : await runRegistryDiff({
+      cwd,
+      itemId: positionals[0],
+      json: flags.json === true,
+      print: stdout,
+      registryRoot: io.registryRoot
+    });
+    if (result.error) stderr(result.error);
+    return result.exitCode;
+  }
+  if (command === "doctor" && flags.template === true) {
+    const manifest = flags.manifest;
+    if (typeof manifest !== "string" || manifest.length === 0) {
+      stderr("umec doctor --template \u306B\u306F --manifest <path-or-url> \u304C\u5FC5\u8981\u3067\u3059\u3002");
+      return 1;
+    }
+    const result = await runTemplateDoctor({
+      cwd,
+      manifest,
+      json: flags.json === true,
+      print: stdout
+    });
+    if (result.error) stderr(result.error);
+    return result.exitCode;
+  }
   const snapshot = loadSnapshotJson();
   const remote = flags.remote === true;
   const database = typeof flags.database === "string" ? flags.database : readD1DatabaseName(cwd);
@@ -801,10 +1702,10 @@ async function runCli(argv, io = {}) {
 function isDirectRun() {
   const invoked = process.argv[1];
   if (!invoked) return false;
-  return /(?:^|[\\/])cli(?:\.js)?$/.test(invoked) || invoked.includes(`${join5("dist", "cli")}`);
+  return /(?:^|[\\/])cli(?:\.js)?$/.test(invoked) || invoked.includes(`${join7("dist", "cli")}`);
 }
 if (isDirectRun()) {
-  const pkg = JSON.parse(readFileSync5(join5(findPackageRoot(), "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync7(join7(findPackageRoot(), "package.json"), "utf8"));
   if (process.argv.includes("--version") || process.argv.includes("-V")) {
     console.log(pkg.version);
     process.exit(0);