@takuhon/cli 0.13.0 → 0.15.0

package/dist/index.js

@@ -2,10 +2,10 @@
 import {
   ADMIN_DIST_DIRNAME,
   resolveAdminBundleDir
-} from "./chunk-TNTKQL7R.js";
+} from "./chunk-DKOAVXLZ.js";
 
 // src/index.ts
-import { readFileSync as readFileSync15, realpathSync } from "fs";
+import { readFileSync as readFileSync16, realpathSync } from "fs";
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
 import { fileURLToPath } from "url";
@@ -1693,7 +1693,13 @@ Run \`takuhon admin --help\` for usage.
 // src/build-command.ts
 import { mkdirSync as mkdirSync3, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname5, join as join6 } from "path";
-import { applyPublicPrivacyFilter as applyPublicPrivacyFilter2, normalize as normalize2, validate as validate2 } from "@takuhon/core";
+import {
+  DARK_PALETTE,
+  applyPublicPrivacyFilter as applyPublicPrivacyFilter2,
+  normalize as normalize2,
+  renderActivitySvg as renderActivitySvg2,
+  validate as validate2
+} from "@takuhon/core";
 var DEFAULT_PATH4 = "takuhon.json";
 var DEFAULT_OUTPUT = "dist";
 var USAGE3 = `Usage: takuhon build [path] [--output <dir>] [--base-url <url>] [--cv]
@@ -1715,6 +1721,10 @@ The public privacy filter is applied (meta.privacy is honoured). Asset URLs are
 referenced as-is and are not copied. The output directory is written into, not
 cleaned \u2014 use a dedicated/empty directory so stale pages do not linger.
 
+When settings.activity.enabled is true and an activity.json sits beside the
+profile, the activity card is also written as activity.svg and
+activity-dark.svg for embedding as a GitHub README badge.
+
 Exit codes: 0 = built, 1 = source is not a valid profile,
 2 = bad arguments / file missing / unreadable / not JSON / write failed.
 `;
@@ -1829,6 +1839,7 @@ ${lines.join("\n")}
   const filtered = applyPublicPrivacyFilter2(normalize2(result.data));
   const activitySnapshot = filtered.settings.activity?.enabled === true ? readActivitySnapshotSync(path) : null;
   const written = [];
+  const assets = [];
   try {
     for (const page of generateSite(filtered, { baseUrl, activitySnapshot, cv })) {
       const outFile = join6(output, page.file);
@@ -1836,15 +1847,29 @@ ${lines.join("\n")}
       writeFileAtomic(outFile, page.html);
       written.push(outFile);
     }
+    if (activitySnapshot) {
+      const variants = [
+        ["activity.svg", renderActivitySvg2(activitySnapshot)],
+        ["activity-dark.svg", renderActivitySvg2(activitySnapshot, { palette: DARK_PALETTE })]
+      ];
+      for (const [file, svg] of variants) {
+        if (svg === "") continue;
+        const outFile = join6(output, file);
+        mkdirSync3(dirname5(outFile), { recursive: true });
+        writeFileAtomic(outFile, svg);
+        assets.push(outFile);
+      }
+    }
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     return { code: 2, stdout: "", stderr: `takuhon: failed to write the site: ${detail}
 ` };
   }
-  const summary = written.map((w) => `  ${w}`).join("\n");
+  const summary = [...written, ...assets].map((w) => `  ${w}`).join("\n");
+  const assetNote = assets.length > 0 ? ` and ${assets.length} asset${assets.length === 1 ? "" : "s"}` : "";
   return {
     code: 0,
-    stdout: `built ${written.length} page${written.length === 1 ? "" : "s"} from ${path}:
+    stdout: `built ${written.length} page${written.length === 1 ? "" : "s"}${assetNote} from ${path}:
 ${summary}
 `,
     stderr: ""
@@ -2147,18 +2172,144 @@ function isNotFound5(error) {
   return typeof error === "object" && error !== null && error.code === "ENOENT";
 }
 
-// src/migrate-command.ts
+// src/mcp-command.ts
 import { readFileSync as readFileSync10 } from "fs";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { validate as validate4 } from "@takuhon/core";
+import { createTakuhonMcpServer } from "@takuhon/mcp";
+var DEFAULT_PATH7 = "takuhon.json";
+var SERVER_NAME = "takuhon";
+var USAGE6 = `Usage: takuhon mcp [path]
+
+Serve a takuhon.json over the Model Context Protocol on stdio, so an MCP client
+(e.g. Claude Desktop) can read the profile read-only. With no path, serves
+./takuhon.json. The file is re-read on every request, so edits are reflected
+without restarting.
+
+Exposes (read-only, the same surface as the public API, privacy filter applied):
+  tools:     get_profile, get_section, get_jsonld, list_locales
+  resources: takuhon://profile, takuhon://schema
+
+stdin/stdout carry the protocol stream; diagnostics go to stderr. The server
+runs until the client disconnects or you press Ctrl-C.
+
+Example Claude Desktop config (claude_desktop_config.json):
+  {
+    "mcpServers": {
+      "my-profile": { "command": "takuhon", "args": ["mcp", "/path/to/takuhon.json"] }
+    }
+  }
+
+Exit codes: 0 = served then stopped, 2 = bad arguments / file missing /
+unreadable / invalid.
+`;
+var VERSION = readCliVersion();
+function loadMcpProfile(path) {
+  let raw;
+  try {
+    raw = readFileSync10(path, "utf8");
+  } catch {
+    throw new Error(`cannot read '${path}'.`);
+  }
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`'${path}' is not valid JSON: ${detail}`, { cause: error });
+  }
+  const result = validate4(data);
+  if (!result.ok) {
+    const lines = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
+    throw new Error(`'${path}' is not a valid takuhon profile:
+${lines.join("\n")}`);
+  }
+  return result.data;
+}
+async function runMcp(args = [], deps = {}) {
+  const err = deps.stderr ?? ((text) => void process.stderr.write(text));
+  if (args[0] === "--help" || args[0] === "-h") {
+    const out = deps.stdout ?? ((text) => void process.stdout.write(text));
+    out(USAGE6);
+    return 0;
+  }
+  const parsed = parseArgs6(args);
+  if ("error" in parsed) {
+    err(`${parsed.error}
+Run \`takuhon mcp --help\` for usage.
+`);
+    return 2;
+  }
+  try {
+    loadMcpProfile(parsed.path);
+  } catch (error) {
+    err(`takuhon: ${error instanceof Error ? error.message : String(error)}
+`);
+    return 2;
+  }
+  const server = createTakuhonMcpServer({
+    // Re-read per request so edits are reflected; if the file later becomes
+    // invalid, the load failure surfaces to the client as a tool error result.
+    loadProfile: () => loadMcpProfile(parsed.path),
+    name: SERVER_NAME,
+    version: VERSION
+  });
+  const transport = (deps.createTransport ?? (() => new StdioServerTransport()))();
+  await server.connect(transport);
+  err(`takuhon mcp: serving ${parsed.path} (read-only) on stdio
+`);
+  return await new Promise((resolve7) => {
+    let done = false;
+    function finish() {
+      if (done) return;
+      done = true;
+      process.removeListener("SIGINT", shutdown);
+      process.removeListener("SIGTERM", shutdown);
+      resolve7(0);
+    }
+    function shutdown() {
+      void server.close();
+      finish();
+    }
+    server.server.onclose = finish;
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+  });
+}
+function parseArgs6(args) {
+  let path;
+  for (const arg of args) {
+    if (arg.startsWith("-")) {
+      return { error: `takuhon: unknown option \`${arg}\` for \`mcp\`.` };
+    }
+    if (path !== void 0) {
+      return { error: "takuhon: `mcp` takes at most one path argument." };
+    }
+    path = arg;
+  }
+  return { path: path ?? DEFAULT_PATH7 };
+}
+function readCliVersion() {
+  try {
+    const pkg2 = JSON.parse(readFileSync10(new URL("../package.json", import.meta.url), "utf8"));
+    return pkg2.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// src/migrate-command.ts
+import { readFileSync as readFileSync11 } from "fs";
 import { resolve as resolve5 } from "path";
 import {
   MigrationError as MigrationError2,
   SCHEMA_VERSION as SCHEMA_VERSION2,
   SUPPORTED_SCHEMA_VERSIONS,
   migrateTakuhon as migrateTakuhon2,
-  validate as validate4
+  validate as validate5
 } from "@takuhon/core";
-var DEFAULT_PATH7 = "takuhon.json";
-var USAGE6 = `Usage: takuhon migrate [path] [--to <version>] [--out <file>] [--dry-run]
+var DEFAULT_PATH8 = "takuhon.json";
+var USAGE7 = `Usage: takuhon migrate [path] [--to <version>] [--out <file>] [--dry-run]
 
 Forward-migrate a takuhon.json to a newer schema version. The source version
 is read from the file's own schemaVersion. With no path, migrates
@@ -2180,9 +2331,9 @@ Exit codes: 0 = migrated / already current / dry-run, 1 = cannot migrate,
 `;
 function runMigrate(args = [], deps = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE6, stderr: "" };
+    return { code: 0, stdout: USAGE7, stderr: "" };
   }
-  const parsed = parseArgs6(args);
+  const parsed = parseArgs7(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -2195,7 +2346,7 @@ Run \`takuhon migrate --help\` for usage.
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   return migrateFile(parsed, now);
 }
-function parseArgs6(args) {
+function parseArgs7(args) {
   let path;
   let to;
   let out;
@@ -2238,13 +2389,13 @@ function parseArgs6(args) {
       error: `takuhon: unsupported --to version "${target}". Supported: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}.`
     };
   }
-  return { path: path ?? DEFAULT_PATH7, to: target, out, dryRun };
+  return { path: path ?? DEFAULT_PATH8, to: target, out, dryRun };
 }
 function migrateFile(parsed, now) {
   const { path, to: target, out, dryRun } = parsed;
   let raw;
   try {
-    raw = readFileSync10(path, "utf8");
+    raw = readFileSync11(path, "utf8");
   } catch {
     return {
       code: 2,
@@ -2295,7 +2446,7 @@ Migrations are forward-only; to move to an older schema, restore from a backup w
     }
     throw error;
   }
-  const revalidated = validate4(migrated);
+  const revalidated = validate5(migrated);
   if (!revalidated.ok) {
     const lines2 = revalidated.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
     return {
@@ -2358,11 +2509,11 @@ ${lines2.join("\n")}
 }
 
 // src/refresh-admin-command.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { cp, mkdtemp, readdir, rename, rm, stat } from "fs/promises";
 import { join as join7, resolve as resolve6 } from "path";
 var PROFILE_FILENAME = "takuhon.json";
-var USAGE7 = `Usage: takuhon admin update [path]
+var USAGE8 = `Usage: takuhon admin update [path]
 
 Refresh a project's ${ADMIN_DIST_DIRNAME}/ with the admin form-UI bundle shipped in
 this @takuhon/cli. Use it after upgrading @takuhon/cli to pick up a newer admin
@@ -2375,7 +2526,7 @@ no ${ADMIN_DIST_DIRNAME}/ to refresh / copy failed.
 `;
 async function runRefreshAdmin(args = [], opts = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE7, stderr: "" };
+    return { code: 0, stdout: USAGE8, stderr: "" };
   }
   const unknownFlag = args.find((arg) => arg.startsWith("-"));
   if (unknownFlag !== void 0) {
@@ -2458,7 +2609,7 @@ Run \`takuhon admin update --help\` for usage.
   };
 }
 function readVersion() {
-  const pkg2 = JSON.parse(readFileSync11(new URL("../package.json", import.meta.url), "utf8"));
+  const pkg2 = JSON.parse(readFileSync12(new URL("../package.json", import.meta.url), "utf8"));
   return pkg2.version;
 }
 function isNodeErrnoException(err) {
@@ -2466,10 +2617,10 @@ function isNodeErrnoException(err) {
 }
 
 // src/restore-command.ts
-import { readFileSync as readFileSync12 } from "fs";
-import { validate as validate5 } from "@takuhon/core";
-var DEFAULT_PATH8 = "takuhon.json";
-var USAGE8 = `Usage: takuhon restore --from <backup> [path] [--yes]
+import { readFileSync as readFileSync13 } from "fs";
+import { validate as validate6 } from "@takuhon/core";
+var DEFAULT_PATH9 = "takuhon.json";
+var USAGE9 = `Usage: takuhon restore --from <backup> [path] [--yes]
 
 Overwrite a profile with a previously saved backup. With no path, restores
 ./takuhon.json in the current working directory.
@@ -2486,9 +2637,9 @@ Exit codes: 0 = restored / aborted, 1 = backup failed validation,
 `;
 async function runRestore(args = [], deps = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE8, stderr: "" };
+    return { code: 0, stdout: USAGE9, stderr: "" };
   }
-  const parsed = parseArgs7(args);
+  const parsed = parseArgs8(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -2501,7 +2652,7 @@ Run \`takuhon restore --help\` for usage.
   const now = deps.now ?? (() => /* @__PURE__ */ new Date());
   return restoreFile(parsed, now, deps.confirm);
 }
-function parseArgs7(args) {
+function parseArgs8(args) {
   let from;
   let path;
   let yes = false;
@@ -2535,13 +2686,13 @@ function parseArgs7(args) {
   if (from === void 0 || from.length === 0) {
     return { error: "takuhon: `restore` requires `--from <backup>`." };
   }
-  return { from, path: path ?? DEFAULT_PATH8, yes };
+  return { from, path: path ?? DEFAULT_PATH9, yes };
 }
 async function restoreFile(parsed, now, confirm) {
   const { from, path, yes } = parsed;
   let backupRaw;
   try {
-    backupRaw = readFileSync12(from, "utf8");
+    backupRaw = readFileSync13(from, "utf8");
   } catch {
     return { code: 2, stdout: "", stderr: `takuhon: cannot read backup '${from}'.
 ` };
@@ -2558,7 +2709,7 @@ async function restoreFile(parsed, now, confirm) {
 `
     };
   }
-  const result = validate5(backupData);
+  const result = validate6(backupData);
   if (!result.ok) {
     const lines2 = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
     return {
@@ -2571,7 +2722,7 @@ ${lines2.join("\n")}
   }
   let currentRaw;
   try {
-    currentRaw = readFileSync12(path, "utf8");
+    currentRaw = readFileSync13(path, "utf8");
   } catch (error) {
     if (!isNotFound6(error)) {
       return { code: 2, stdout: "", stderr: `takuhon: cannot read current profile '${path}'.
@@ -2641,12 +2792,12 @@ function isNotFound6(error) {
 }
 
 // src/sync-command.ts
-import { readFileSync as readFileSync13 } from "fs";
-import { validate as validate6 } from "@takuhon/core";
-var DEFAULT_PATH9 = "takuhon.json";
+import { readFileSync as readFileSync14 } from "fs";
+import { validate as validate7 } from "@takuhon/core";
+var DEFAULT_PATH10 = "takuhon.json";
 var ADMIN_PROFILE_PATH = "/api/admin/profile";
 var TOKEN_ENV = "TAKUHON_ADMIN_TOKEN";
-var USAGE9 = `Usage: takuhon sync [path] --url <base-url> [--if-match <etag>] [--dry-run]
+var USAGE10 = `Usage: takuhon sync [path] --url <base-url> [--if-match <etag>] [--dry-run]
 
 Push a local takuhon.json to a deployed takuhon instance by calling its admin
 write endpoint (PUT <base-url>/api/admin/profile). With no path, syncs
@@ -2672,9 +2823,9 @@ unset / auth failure / network error / other non-success response.
 `;
 async function runSync(args = [], deps = {}) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE9, stderr: "" };
+    return { code: 0, stdout: USAGE10, stderr: "" };
   }
-  const parsed = parseArgs8(args);
+  const parsed = parseArgs9(args);
   if ("error" in parsed) {
     return {
       code: 2,
@@ -2686,7 +2837,7 @@ Run \`takuhon sync --help\` for usage.
   }
   return syncProfile(parsed, deps);
 }
-function parseArgs8(args) {
+function parseArgs9(args) {
   let path;
   let url;
   let ifMatch;
@@ -2732,7 +2883,7 @@ function parseArgs8(args) {
   }
   const base = parseOrigin(url);
   if ("error" in base) return base;
-  return { path: path ?? DEFAULT_PATH9, url: base.origin, ifMatch, dryRun };
+  return { path: path ?? DEFAULT_PATH10, url: base.origin, ifMatch, dryRun };
 }
 function parseOrigin(value) {
   let parsed;
@@ -2765,7 +2916,7 @@ async function syncProfile(parsed, deps) {
   const { path, url, ifMatch, dryRun } = parsed;
   let raw;
   try {
-    raw = readFileSync13(path, "utf8");
+    raw = readFileSync14(path, "utf8");
   } catch {
     return { code: 2, stdout: "", stderr: `takuhon: cannot read '${path}'.
 ` };
@@ -2778,7 +2929,7 @@ async function syncProfile(parsed, deps) {
     return { code: 2, stdout: "", stderr: `takuhon: '${path}' is not valid JSON: ${detail}
 ` };
   }
-  const result = validate6(data);
+  const result = validate7(data);
   if (!result.ok) {
     const lines = result.errors.map((e) => `  ${e.pointer || "/"}: ${e.message}`);
     return {
@@ -2902,10 +3053,10 @@ async function readProblem(res) {
 }
 
 // src/validate-command.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { validate as validate7 } from "@takuhon/core";
-var DEFAULT_PATH10 = "takuhon.json";
-var USAGE10 = `Usage: takuhon validate [path]
+import { readFileSync as readFileSync15 } from "fs";
+import { validate as validate8 } from "@takuhon/core";
+var DEFAULT_PATH11 = "takuhon.json";
+var USAGE11 = `Usage: takuhon validate [path]
 
 Validate a takuhon.json against the takuhon schema. With no path, validates
 ./takuhon.json in the current working directory.
@@ -2914,7 +3065,7 @@ Exit codes: 0 = valid, 1 = invalid, 2 = file missing / unreadable / not JSON.
 `;
 function runValidate(args = []) {
   if (args[0] === "--help" || args[0] === "-h") {
-    return { code: 0, stdout: USAGE10, stderr: "" };
+    return { code: 0, stdout: USAGE11, stderr: "" };
   }
   if (args.length > 1) {
     return {
@@ -2926,10 +3077,10 @@ function runValidate(args = []) {
   return validateFile(args[0]);
 }
 function validateFile(pathArg) {
-  const target = pathArg ?? DEFAULT_PATH10;
+  const target = pathArg ?? DEFAULT_PATH11;
   let raw;
   try {
-    raw = readFileSync14(target, "utf8");
+    raw = readFileSync15(target, "utf8");
   } catch {
     return {
       code: 2,
@@ -2950,7 +3101,7 @@ function validateFile(pathArg) {
 `
     };
   }
-  const result = validate7(data);
+  const result = validate8(data);
   if (result.ok) {
     return {
       code: 0,
@@ -2971,9 +3122,9 @@ ${lines.join("\n")}
 }
 
 // src/index.ts
-var pkg = JSON.parse(readFileSync15(new URL("../package.json", import.meta.url), "utf8"));
-var VERSION = pkg.version;
-var HELP = `takuhon ${VERSION}
+var pkg = JSON.parse(readFileSync16(new URL("../package.json", import.meta.url), "utf8"));
+var VERSION2 = pkg.version;
+var HELP = `takuhon ${VERSION2}
 
 Takuhon \u2014 open-source portable profile API server.
 
@@ -3004,6 +3155,9 @@ Commands:
   takuhon admin update [path]          Refresh a project's admin-dist/ with the admin form UI
                                        bundled in this @takuhon/cli (use after upgrading the
                                        CLI). Updates an existing admin-dist/ only.
+  takuhon mcp [path]                   Serve a takuhon.json over the Model Context Protocol on
+                                       stdio (read-only), so an MCP client such as Claude Desktop
+                                       can read the profile. Re-reads the file per request.
   takuhon sync [path] --url <url>      Push a takuhon.json to a deployment's admin API
                                        (PUT <url>/api/admin/profile). Reads the admin token
                                        from TAKUHON_ADMIN_TOKEN. --if-match <etag> opts into
@@ -3021,7 +3175,7 @@ Scaffolding a new profile project:
 async function main(argv) {
   const first = argv[0];
   if (first === "--version" || first === "-v") {
-    process.stdout.write(`${VERSION}
+    process.stdout.write(`${VERSION2}
 `);
     return 0;
   }
@@ -3050,6 +3204,9 @@ async function main(argv) {
     }
     return runAdmin(argv.slice(1));
   }
+  if (first === "mcp") {
+    return runMcp(argv.slice(1));
+  }
   if (first === "import") {
     return emit(runImport(argv.slice(1)));
   }