@bitcobblers/wod-wiki-tools 0.53.2204 → 0.55.2206

package/dist/index.cjs

@@ -4,15 +4,20 @@ var wodWikiLang = require('@bitcobblers/wod-wiki-lang');
 var wod_wiki_engine_star = require('@bitcobblers/wod-wiki-engine');
 var fs = require('fs');
 var path = require('path');
+var wodWikiStorage = require('@bitcobblers/wod-wiki-storage');
+var agent = require('@bitcobblers/wod-wiki-engine/agent');
 var child_process = require('child_process');
 var wodWikiCore = require('@bitcobblers/wod-wiki-core');
 var wodWikiWql = require('@bitcobblers/wod-wiki-wql');
 var crypto = require('crypto');
+var zod = require('zod');
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var webStandardStreamableHttp_js = require('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js');
+var sql = require('@bitcobblers/wod-wiki-storage/sql');
 var promises = require('fs/promises');
 var stream = require('stream');
-var sql = require('@bitcobblers/wod-wiki-storage/sql');
-var wodWikiStorage = require('@bitcobblers/wod-wiki-storage');
 var http = require('http');
+var stdio_js = require('@modelcontextprotocol/sdk/server/stdio.js');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -439,7 +444,7 @@ var init_report = __esm({
 var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
-    VERSION = "0.53.2204";
+    VERSION = "0.55.2206";
   }
 });
 
@@ -705,6 +710,590 @@ var init_skills = __esm({
   }
 });
 
+// src/cli/agentCommands.ts
+var agentCommands_exports = {};
+__export(agentCommands_exports, {
+  runAgentNounVerbCommand: () => runAgentNounVerbCommand
+});
+async function openStorageSession(env) {
+  if (env.parsed.serverUrl) {
+    const trimmed = env.parsed.serverUrl.replace(/\/+$/, "");
+    const apiBase = trimmed.endsWith("/api") ? trimmed : `${trimmed}/api`;
+    const baseUrl = trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
+    const storage = new wodWikiStorage.ApiStorage(apiBase);
+    return {
+      storage,
+      feedTree: new wod_wiki_engine_star.MemoryFeedTree(),
+      baseUrl,
+      label: baseUrl,
+      close: () => storage.close()
+    };
+  }
+  const dbConfig = env.resolveDbConfig();
+  const dbHandle = await openCliDb(dbConfig);
+  const feedTree = dbConfig.kind === "sqlite" ? new NodeFsFeedTree(`${dbConfig.path}.feed`) : new wod_wiki_engine_star.MemoryFeedTree();
+  return {
+    storage: dbHandle.storage,
+    feedTree,
+    baseUrl: "",
+    label: dbHandle.path,
+    close: () => dbHandle.close()
+  };
+}
+function parseSetPairs(pairs) {
+  const out = {};
+  for (const pair of pairs) {
+    const idx = pair.indexOf("=");
+    if (idx <= 0) {
+      throw new Error(`Invalid --set "${pair}" (expected fieldId=value)`);
+    }
+    const key = pair.slice(0, idx).trim();
+    const rawVal = pair.slice(idx + 1).trim();
+    if (!key || !rawVal) {
+      throw new Error(`Invalid --set "${pair}" (expected fieldId=value)`);
+    }
+    const num = Number(rawVal);
+    out[key] = Number.isFinite(num) ? num : rawVal;
+  }
+  return out;
+}
+function toNotebookId(slugOrId) {
+  if (!slugOrId) return void 0;
+  return slugOrId.startsWith("notebook/") ? slugOrId : `notebook/${slugOrId}`;
+}
+function slugifyName(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function readContentArg(fileOrDash, inlineMarkdown, readStdin2) {
+  if (inlineMarkdown !== void 0) return inlineMarkdown;
+  if (!fileOrDash || fileOrDash === "-") {
+    return readStdin2();
+  }
+  const fs = nodeFs();
+  if (!fs.existsSync(fileOrDash)) {
+    throw new Error(`File not found: ${fileOrDash}`);
+  }
+  return fs.readFileSync(fileOrDash, "utf-8");
+}
+function emitSuccess(env, toolName, data, humanSummary) {
+  if (env.parsed.json) {
+    env.writeOut(
+      JSON.stringify(
+        {
+          ok: true,
+          tool: toolName,
+          data
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    env.writeOut(humanSummary);
+  }
+  return 0;
+}
+function emitError(env, error) {
+  if (error instanceof agent.AgentConfirmationRequiredError) {
+    const payload = {
+      ok: false,
+      code: error.code,
+      exitCode: 4,
+      action: error.action,
+      targetId: error.targetId,
+      error: error.message,
+      hint: `Re-run with --yes "${error.targetId}" to confirm.`
+    };
+    if (env.parsed.json) {
+      env.writeOut(JSON.stringify(payload, null, 2));
+    } else {
+      env.writeErr(
+        `[wod] Confirmation required (${error.action}): ${error.message} Pass --yes "${error.targetId}" to confirm.`
+      );
+    }
+    return 4;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (env.parsed.json) {
+    env.writeOut(
+      JSON.stringify(
+        {
+          ok: false,
+          code: "RUNTIME_ERROR",
+          error: message
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    env.writeErr(`[wod] Error: ${message}`);
+  }
+  return 1;
+}
+async function runAgentNounVerbCommand(env) {
+  const { parsed } = env;
+  const noun = parsed.subcommand;
+  const verb = parsed.target;
+  const arg1 = parsed.target2;
+  const arg2 = parsed.target3;
+  try {
+    if (noun === "tools") {
+      const action = verb ?? "list";
+      const manifest = agent.exportAgentCapabilitiesManifest();
+      if (action === "manifest") {
+        env.writeOut(JSON.stringify(manifest, null, 2));
+        return 0;
+      }
+      if (action === "list") {
+        if (parsed.json) {
+          return emitSuccess(env, "wod_tools_list", manifest.domainTools, "");
+        }
+        for (const t of manifest.domainTools) {
+          env.writeOut(`${t.name.padEnd(26)} [Tier ${t.tier}]  ${t.cliEquivalent}`);
+        }
+        env.writeOut(`[wod tools] ${manifest.domainTools.length} portable domain tools`);
+        return 0;
+      }
+      throw new Error(`Unknown tools action "${action}" (expected: list | manifest)`);
+    }
+    if (noun === "doctor") {
+      let backendKind = "sqlite";
+      let backendTarget = "";
+      let dbReady = false;
+      let noteCount = 0;
+      let sessionCount = 0;
+      if (parsed.serverUrl) {
+        backendKind = "api";
+        backendTarget = parsed.serverUrl;
+        const session2 = await openStorageSession(env);
+        try {
+          noteCount = (await session2.storage.readonly("notes").getAll()).length;
+          sessionCount = (await session2.storage.readonly("sessions").getAll()).length;
+          dbReady = true;
+        } finally {
+          await session2.close();
+        }
+      } else {
+        const cfg = env.resolveDbConfig();
+        backendKind = cfg.kind;
+        backendTarget = cfg.kind === "sqlite" ? cfg.path : cfg.kind;
+        try {
+          const db = await openCliDb(cfg, { initialize: false });
+          try {
+            noteCount = (await db.storage.readonly("notes").getAll()).length;
+            sessionCount = (await db.storage.readonly("sessions").getAll()).length;
+            dbReady = true;
+          } finally {
+            await db.close();
+          }
+        } catch {
+          dbReady = false;
+        }
+      }
+      const { bundledSkillsRoot: bundledSkillsRoot2, listBundledSkills: listBundledSkills2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
+      const skillsRoot = bundledSkillsRoot2();
+      const skills = skillsRoot ? listBundledSkills2(skillsRoot).map((s) => s.name) : [];
+      const report = {
+        version: VERSION,
+        backendKind,
+        backendTarget,
+        databaseInitialized: dbReady,
+        noteCount,
+        sessionCount,
+        domainToolCount: agent.DOMAIN_AGENT_TOOLS.length,
+        bundledSkills: skills
+      };
+      return emitSuccess(
+        env,
+        "wod_doctor",
+        report,
+        `[wod doctor] v${VERSION} \xB7 backend=${backendKind} (${dbReady ? "ready" : "uninitialized"}) \xB7 ${noteCount} notes \xB7 ${sessionCount} sessions \xB7 ${agent.DOMAIN_AGENT_TOOLS.length} tools \xB7 ${skills.length} skills`
+      );
+    }
+    const session = await openStorageSession(env);
+    const ctx = {
+      storage: session.storage,
+      feedTree: session.feedTree,
+      baseUrl: session.baseUrl
+    };
+    try {
+      if (noun === "note") {
+        if (verb === "list" || !verb) {
+          const out = await agent.wodNoteListTool.execute(
+            {
+              notebookId: toNotebookId(parsed.notebook),
+              tag: parsed.tag,
+              search: parsed.search,
+              limit: parsed.limit
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodNoteListTool.name,
+            out,
+            out.notes.map((n) => `${n.id}  ${(n.date ? new Date(n.date).toISOString().slice(0, 10) : "").padEnd(10)}  ${n.title}`).join("\n") || "[wod note list] 0 notes"
+          );
+        }
+        if (verb === "get") {
+          const noteId = arg1 ?? parsed.noteId;
+          if (!noteId) throw new Error("Usage: wod note get <noteId>");
+          const out = await agent.wodNoteGetTool.execute({ noteId }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodNoteGetTool.name,
+            out,
+            parsed.format === "table" ? `${out.id}  ${out.title}
+
+${out.rawContent}` : out.rawContent
+          );
+        }
+        if (verb === "create" || verb === "update" || verb === "upsert") {
+          const noteId = verb === "update" ? arg1 ?? parsed.noteId : parsed.noteId;
+          const fileArg = verb === "update" ? arg2 : arg1;
+          let content = await readContentArg(fileArg, parsed.markdown, env.readStdin);
+          if (parsed.tags.length > 0 && !content.trimStart().startsWith("---")) {
+            content = `---
+tags:
+${parsed.tags.map((t) => `  - ${t}`).join("\n")}
+---
+
+${content}`;
+          }
+          const out = await agent.wodNoteUpsertTool.execute(
+            {
+              noteId,
+              title: parsed.title,
+              content,
+              notebookId: toNotebookId(parsed.notebook),
+              journalDate: parsed.date,
+              sport: parsed.sport
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodNoteUpsertTool.name,
+            out,
+            `[wod note ${verb}] ${out.noteId}${out.created ? " (created)" : " (updated)"} \u2014 ${out.blockCount} block(s)`
+          );
+        }
+        if (verb === "clone") {
+          const sourceNoteId = arg1 ?? parsed.noteId;
+          if (!sourceNoteId) {
+            throw new Error("Usage: wod note clone <sourceNoteId> [--date YYYY-MM-DD] [--notebook <slug>]");
+          }
+          const out = await agent.wodNoteCloneTool.execute(
+            {
+              sourceNoteId,
+              title: parsed.title,
+              targetNotebookId: toNotebookId(parsed.notebook),
+              journalDate: parsed.date
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodNoteCloneTool.name,
+            out,
+            `[wod note clone] ${sourceNoteId} \u2192 ${out.noteId}`
+          );
+        }
+        if (verb === "delete") {
+          const noteId = arg1 ?? parsed.noteId;
+          if (!noteId) throw new Error("Usage: wod note delete <noteId> --yes <noteId>");
+          const out = await agent.wodNoteDeleteTool.execute({ noteId, confirmId: parsed.yes }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodNoteDeleteTool.name,
+            out,
+            `[wod note delete] deleted=${out.deleted} note=${out.noteId}`
+          );
+        }
+        throw new Error(`Unknown note verb "${verb}" (expected: list | get | create | update | clone | delete)`);
+      }
+      if (noun === "journal") {
+        if (verb === "day" || !verb) {
+          const date = arg1 ?? parsed.date ?? "today";
+          const out = await agent.wodJournalDayTool.execute({ date }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodJournalDayTool.name,
+            out,
+            `[wod journal day ${out.date}] ${out.noteCount} scheduled note(s), ${out.sessionCount} session(s)`
+          );
+        }
+        if (verb === "add") {
+          const date = arg1 ?? parsed.date ?? "today";
+          const sourceNoteId = parsed.sourceNoteId ?? parsed.noteId;
+          if (sourceNoteId && !parsed.markdown && !arg2) {
+            const cloned = await agent.wodNoteCloneTool.execute(
+              {
+                sourceNoteId,
+                title: parsed.title,
+                targetNotebookId: toNotebookId(parsed.notebook ?? "journal"),
+                journalDate: date
+              },
+              ctx
+            );
+            return emitSuccess(
+              env,
+              agent.wodNoteCloneTool.name,
+              cloned,
+              `[wod journal add] cloned ${sourceNoteId} \u2192 ${cloned.noteId} on ${date}`
+            );
+          }
+          const content = await readContentArg(arg2, parsed.markdown, env.readStdin);
+          const out = await agent.wodJournalAddTool.execute(
+            {
+              date,
+              title: parsed.title,
+              content,
+              sport: parsed.sport,
+              notebookId: toNotebookId(parsed.notebook)
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodJournalAddTool.name,
+            out,
+            `[wod journal add] scheduled note ${out.noteId} on ${out.date}`
+          );
+        }
+        throw new Error(`Unknown journal verb "${verb}" (expected: day | add)`);
+      }
+      if (noun === "notebook") {
+        if (verb === "list" || !verb) {
+          const out = await agent.wodNotebookListTool.execute({ origin: "all" }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodNotebookListTool.name,
+            out,
+            out.notebooks.map((nb) => `${nb.slug.padEnd(20)} (${nb.noteCount} notes) \u2014 ${nb.name}`).join("\n") || "[wod notebook list] 0 notebooks"
+          );
+        }
+        if (verb === "create" || verb === "save" || verb === "update") {
+          const slugOrId = arg1 ?? parsed.notebook;
+          const name = parsed.title ?? parsed.dbName ?? slugOrId;
+          if (!name) throw new Error('Usage: wod notebook save <slug> --title "<Name>"');
+          const notebookId = toNotebookId(slugOrId ?? slugifyName(name));
+          const existing = notebookId ? await session.storage.readonly("notes").get(notebookId) : void 0;
+          const action = verb === "create" || !existing ? "create" : "update";
+          const out = await agent.wodNotebookSaveTool.execute(
+            {
+              action,
+              notebookId,
+              name,
+              description: parsed.description,
+              noteId: parsed.noteId
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodNotebookSaveTool.name,
+            out,
+            `[wod notebook ${verb}] ${out.notebookId ?? slugOrId ?? name}`
+          );
+        }
+        if (verb === "promote" || verb === "detach") {
+          const slugOrId = arg1 ?? parsed.notebook;
+          const noteId = arg2 ?? parsed.noteId;
+          if (!slugOrId || !noteId) {
+            throw new Error(`Usage: wod notebook ${verb} <slug> <noteId>`);
+          }
+          const out = await agent.wodNotebookSaveTool.execute(
+            {
+              action: verb,
+              notebookId: toNotebookId(slugOrId),
+              noteId
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodNotebookSaveTool.name,
+            out,
+            `[wod notebook ${verb}] note ${out.noteId} \u2192 ${(out.notebookIds ?? []).join(", ")}`
+          );
+        }
+        if (verb === "delete") {
+          const slugOrId = arg1 ?? parsed.notebook;
+          if (!slugOrId) throw new Error("Usage: wod notebook delete <slug> --yes <notebook/slug>");
+          const notebookId = toNotebookId(slugOrId);
+          const confirmId = parsed.yes === slugOrId ? notebookId : parsed.yes;
+          const out = await agent.wodNotebookDeleteTool.execute({ notebookId, confirmId }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodNotebookDeleteTool.name,
+            out,
+            `[wod notebook delete] deleted ${out.notebookId}`
+          );
+        }
+        throw new Error(`Unknown notebook verb "${verb}" (expected: list | create | save | update | promote | detach | delete)`);
+      }
+      if (noun === "session") {
+        if (verb === "list" || !verb) {
+          const out = await agent.wodSessionListTool.execute(
+            {
+              noteId: parsed.noteId,
+              limit: parsed.limit
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodSessionListTool.name,
+            out,
+            out.sessions.map(
+              (s) => `${s.id}  ${new Date(s.startTime).toISOString().slice(0, 10)}  note=${s.noteId}  completed=${s.completed}`
+            ).join("\n") || "[wod session list] 0 sessions"
+          );
+        }
+        if (verb === "get") {
+          const sessionId = arg1;
+          if (!sessionId) throw new Error("Usage: wod session get <sessionId>");
+          const out = await agent.wodSessionGetTool.execute({ sessionId }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodSessionGetTool.name,
+            out,
+            `[wod session get] ${out.session.id} \u2014 ${out.eventCount} event(s), duration=${out.session.duration}ms`
+          );
+        }
+        if (verb === "run") {
+          const noteId = parsed.noteId ?? arg1;
+          const source = !noteId ? await readContentArg(arg1, parsed.markdown, env.readStdin) : void 0;
+          const out = await agent.wodSessionRunHeadlessTool.execute(
+            {
+              noteId,
+              blockId: parsed.blockId,
+              source,
+              title: parsed.title,
+              sport: parsed.sport,
+              journalDate: parsed.date,
+              collectibles: parsed.setPairs.length > 0 ? parseSetPairs(parsed.setPairs) : void 0
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodSessionRunHeadlessTool.name,
+            out,
+            `[wod session run] session ${out.sessionId} on note ${out.noteId} (${out.eventCount} events, ${out.summaryCount} summaries)`
+          );
+        }
+        if (verb === "delete") {
+          const sessionId = arg1;
+          if (!sessionId) throw new Error("Usage: wod session delete <sessionId> --yes <sessionId>");
+          const out = await agent.wodSessionDeleteTool.execute({ sessionId, confirmId: parsed.yes }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodSessionDeleteTool.name,
+            out,
+            `[wod session delete] deleted=${out.deleted} session=${out.sessionId}`
+          );
+        }
+        throw new Error(`Unknown session verb "${verb}" (expected: list | get | run | delete)`);
+      }
+      if (noun === "catalog" || noun === "tag") {
+        const defaultKind = noun === "tag" ? "tag" : "effort";
+        if (verb === "list" || verb === "lookup" || !verb) {
+          const kind = (noun === "tag" ? "tag" : arg1) ?? defaultKind;
+          const out = await agent.wodCatalogLookupTool.execute(
+            {
+              kind,
+              search: parsed.search ?? (noun === "tag" ? arg1 : arg2),
+              slug: parsed.slug,
+              notebookId: toNotebookId(parsed.notebook),
+              limit: parsed.limit
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodCatalogLookupTool.name,
+            out,
+            `[wod ${noun} ${verb ?? "list"}] ${out.items.length} ${out.kind} item(s)`
+          );
+        }
+        if (verb === "get") {
+          const kind = noun === "tag" ? "tag" : arg1 ?? "effort";
+          const slug = noun === "tag" ? arg1 : arg2;
+          const out = await agent.wodCatalogLookupTool.execute({ kind, slug }, ctx);
+          return emitSuccess(
+            env,
+            agent.wodCatalogLookupTool.name,
+            out,
+            JSON.stringify(out.items[0] ?? null, null, 2)
+          );
+        }
+        if (verb === "upsert" || verb === "create") {
+          const kind = noun === "tag" ? "tag" : arg1 ?? "effort";
+          const label = (noun === "tag" ? arg1 : arg2) ?? parsed.title ?? parsed.slug;
+          if (!label) {
+            throw new Error(
+              `Usage: wod ${noun} upsert ${noun === "tag" ? "<label> [--category <tagType>]" : "<effort|equipment|tag> <name>"}`
+            );
+          }
+          const slug = parsed.slug ?? slugifyName(label);
+          const out = await agent.wodCatalogUpsertTool.execute(
+            {
+              kind,
+              slug,
+              label,
+              targetNotebookId: toNotebookId(parsed.notebook),
+              markdown: parsed.markdown,
+              category: parsed.category ?? parsed.tagType,
+              aliases: parsed.aliases.length > 0 ? parsed.aliases : void 0
+            },
+            ctx
+          );
+          return emitSuccess(
+            env,
+            agent.wodCatalogUpsertTool.name,
+            out,
+            `[wod ${noun} upsert] ${out.kind} ${out.slug} (${out.ownerNoteId})`
+          );
+        }
+        throw new Error(`Unknown ${noun} verb "${verb}" (expected: list | lookup | get | upsert)`);
+      }
+      if (noun === "feed") {
+        const action = verb ?? "list";
+        const out = await agent.wodFeedManageTool.execute(
+          {
+            action,
+            notebookSlug: parsed.notebook,
+            name: parsed.title,
+            description: parsed.description
+          },
+          ctx
+        );
+        return emitSuccess(
+          env,
+          agent.wodFeedManageTool.name,
+          out,
+          `[wod feed ${action}] ok`
+        );
+      }
+      throw new Error(`Unhandled agent command group "${noun}"`);
+    } finally {
+      await session.close();
+    }
+  } catch (err) {
+    return emitError(env, err);
+  }
+}
+var init_agentCommands = __esm({
+  "src/cli/agentCommands.ts"() {
+    init_db();
+    init_nodeFeedTree();
+    init_version();
+  }
+});
+
 // src/seedbuild/contract.ts
 var contract_exports = {};
 var init_contract = __esm({
@@ -1518,6 +2107,221 @@ var init_errors = __esm({
     };
   }
 });
+function createWodMcpServer(options) {
+  const server = new mcp_js.McpServer(
+    {
+      name: "wod-wiki",
+      version: VERSION
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {}
+      }
+    }
+  );
+  const ctx = {
+    storage: options.storage,
+    feedTree: options.feedTree,
+    baseUrl: options.baseUrl,
+    onMutated: options.onMutated
+    // Over MCP HTTP/stdio, explicit confirm="<targetId>" inside tool arguments
+    // satisfies Tier 2 confirmation; when omitted, requireAgentConfirmation throws
+    // an actionable error instructing the caller to pass confirm="<targetId>".
+  };
+  for (const spec of agent.DOMAIN_AGENT_TOOLS) {
+    if (options.readonly && spec.tier !== 0) {
+      continue;
+    }
+    server.registerTool(
+      spec.name,
+      {
+        title: spec.title,
+        description: spec.description,
+        inputSchema: spec.inputSchema,
+        annotations: spec.annotations
+      },
+      async (args) => {
+        try {
+          const parsed = spec.inputSchema.parse(args ?? {});
+          const result = await spec.execute(parsed, ctx);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ],
+            structuredContent: result
+          };
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: message
+              }
+            ]
+          };
+        }
+      }
+    );
+  }
+  for (const resource of agent.AGENT_STATIC_RESOURCES) {
+    server.registerResource(
+      resource.name,
+      resource.uri,
+      {
+        description: resource.description,
+        mimeType: resource.mimeType
+      },
+      async (uri) => {
+        const res = await agent.readAgentResource(uri.toString(), ctx);
+        return {
+          contents: [
+            {
+              uri: res.uri,
+              mimeType: res.mimeType,
+              text: res.text
+            }
+          ]
+        };
+      }
+    );
+  }
+  for (const tmpl of agent.AGENT_RESOURCE_TEMPLATES) {
+    const template = new mcp_js.ResourceTemplate(tmpl.uriTemplate, { list: void 0 });
+    server.registerResource(
+      tmpl.name,
+      template,
+      {
+        description: tmpl.description,
+        mimeType: tmpl.mimeType
+      },
+      async (uri) => {
+        const res = await agent.readAgentResource(uri.toString(), ctx);
+        return {
+          contents: [
+            {
+              uri: res.uri,
+              mimeType: res.mimeType,
+              text: res.text
+            }
+          ]
+        };
+      }
+    );
+  }
+  for (const prompt of agent.AGENT_PROMPTS) {
+    const argsShape = {};
+    for (const arg of prompt.arguments) {
+      argsShape[arg.name] = arg.required ? zod.z.string().describe(arg.description) : zod.z.string().optional().describe(arg.description);
+    }
+    server.registerPrompt(
+      prompt.name,
+      {
+        title: prompt.title,
+        description: prompt.description,
+        argsSchema: argsShape
+      },
+      async (args) => {
+        const rendered = agent.renderAgentPrompt(prompt.name, args);
+        return {
+          description: rendered.description,
+          messages: rendered.messages
+        };
+      }
+    );
+  }
+  return server;
+}
+var init_createWodMcpServer = __esm({
+  "src/mcp/createWodMcpServer.ts"() {
+    init_version();
+  }
+});
+function withMcpCors(response) {
+  const headers = new Headers(response.headers);
+  for (const [k, v] of Object.entries(MCP_CORS_HEADERS)) {
+    if (!headers.has(k)) {
+      headers.set(k, v);
+    }
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function normalizeAcceptForPost(request) {
+  if (request.method !== "POST") return request;
+  const accept = request.headers.get("accept") ?? "";
+  if (accept.includes("application/json") && accept.includes("text/event-stream")) {
+    return request;
+  }
+  const headers = new Headers(request.headers);
+  headers.set("accept", "application/json, text/event-stream");
+  return new Request(request, { headers });
+}
+async function handleMcpHttpRequest(request, options) {
+  if (request.method === "OPTIONS") {
+    return new Response(null, { status: 204, headers: MCP_CORS_HEADERS });
+  }
+  const expectedToken = options.authToken ?? process.env.WOD_MCP_TOKEN?.trim();
+  if (expectedToken) {
+    const authHeader = request.headers.get("authorization") ?? "";
+    const bearer = authHeader.startsWith("Bearer ") ? authHeader.slice("Bearer ".length).trim() : "";
+    if (bearer !== expectedToken) {
+      return withMcpCors(
+        new Response(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32001, message: "Unauthorized: missing or invalid Bearer token" },
+            id: null
+          }),
+          { status: 401, headers: { "content-type": "application/json" } }
+        )
+      );
+    }
+  }
+  const storage = new sql.SqlStorage(options.db);
+  const server = createWodMcpServer({
+    storage,
+    feedTree: options.feedTree,
+    baseUrl: options.baseUrl,
+    readonly: options.readonly ?? process.env.WOD_MCP_READONLY === "1"
+  });
+  const transport = new webStandardStreamableHttp_js.WebStandardStreamableHTTPServerTransport({
+    sessionIdGenerator: void 0,
+    enableJsonResponse: true
+  });
+  await server.connect(transport);
+  try {
+    const normalizedReq = normalizeAcceptForPost(request);
+    const response = await transport.handleRequest(normalizedReq);
+    return withMcpCors(response);
+  } finally {
+    await transport.close().catch(() => {
+    });
+    await server.close().catch(() => {
+    });
+  }
+}
+var MCP_CORS_HEADERS;
+var init_httpHandler = __esm({
+  "src/mcp/httpHandler.ts"() {
+    init_createWodMcpServer();
+    MCP_CORS_HEADERS = {
+      "access-control-allow-origin": "*",
+      "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
+      "access-control-allow-headers": "Content-Type, Accept, Authorization, Mcp-Session-Id, MCP-Protocol-Version, Last-Event-ID",
+      "access-control-expose-headers": "Mcp-Session-Id, MCP-Protocol-Version"
+    };
+  }
+});
 function streamFile(path) {
   const bun = globalThis.Bun;
   if (bun?.file) return bun.file(path);
@@ -1749,10 +2553,19 @@ async function servePublishedFeed(feedTree, method, relPath) {
     throw err;
   }
 }
-async function apiRoutes(db, feedTree, req, method, sub, url) {
+async function apiRoutes(db, feedTree, req, method, sub, url, mcpOptions) {
   if (sub === "/health") {
     return json({ ok: true, driver: db.dialect }, 200);
   }
+  if (sub === "/mcp") {
+    return handleMcpHttpRequest(req, {
+      db,
+      feedTree,
+      baseUrl: url.origin,
+      readonly: mcpOptions?.readonly,
+      authToken: mcpOptions?.authToken
+    });
+  }
   if (sub === "/v1/feed/status" && method === "GET") {
     const storage = new sql.SqlStorage(db);
     const status = await wod_wiki_engine_star.checkUnpublishedFeedChanges(storage, feedTree);
@@ -1816,7 +2629,20 @@ function createHandler(db, options) {
       const method = request.method === "HEAD" ? "GET" : request.method;
       const path = url.pathname;
       if (path === "/api" || path.startsWith("/api/")) {
-        return db ? await apiRoutes(db, feedTree, request, method, path.slice("/api".length) || "/", url) : notFound();
+        return db ? await apiRoutes(
+          db,
+          feedTree,
+          request,
+          request.method === "OPTIONS" ? "OPTIONS" : method,
+          path.slice("/api".length) || "/",
+          url,
+          { readonly: options.mcpReadonly, authToken: options.mcpToken }
+        ) : notFound();
+      }
+      if (db && path === "/.well-known/agent-capabilities.json" && method === "GET") {
+        const res = await staticResponse(distRoot, method, path);
+        if (res.status === 200) return res;
+        return json(agent.exportAgentCapabilitiesManifest(), 200);
       }
       if (db) {
         const feedAsset = isPublishedFeedAssetPath(path);
@@ -1843,6 +2669,7 @@ var init_app = __esm({
   "src/server/app.ts"() {
     init_errors();
     init_nodeFeedTree();
+    init_httpHandler();
     json = (value, status) => new Response(JSON.stringify(value), { status, headers: { "content-type": "application/json" } });
     plain = (body, status) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8" } });
     notFound = () => json({ error: "not found" }, 404);
@@ -2004,7 +2831,12 @@ async function runCliServer(mode, options, writeOut) {
   try {
     const dist = resolveDist(mode, options);
     const feedDir = mode === "server" && options.database?.kind === "sqlite" ? `${options.database.path}.feed` : void 0;
-    const handler = createHandler(db?.db ?? null, { playgroundDist: dist, feedDir });
+    const handler = createHandler(db?.db ?? null, {
+      playgroundDist: dist,
+      feedDir,
+      mcpReadonly: options.mcpReadonly === true || options.env.WOD_MCP_READONLY === "1",
+      mcpToken: options.env.WOD_MCP_TOKEN?.trim()
+    });
     server = await startHttpServer(handler, host, port);
     if (mode === "server") {
       writeOut(`wod server: http://${host}:${port} \u2014 ${dbLabel} \xB7 dist ${dist}`);
@@ -2041,6 +2873,76 @@ var init_server = __esm({
     init_app();
   }
 });
+
+// src/cli/mcp.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  runMcpStdio: () => runMcpStdio
+});
+async function runMcpStdio(options) {
+  const logErr = options.writeErr ?? ((msg) => process.stderr.write(`${msg}
+`));
+  let dbHandle;
+  let storage;
+  let feedTree;
+  let baseUrl = "";
+  if (options.serverUrl) {
+    const trimmed = options.serverUrl.replace(/\/+$/, "");
+    const apiBase = trimmed.endsWith("/api") ? trimmed : `${trimmed}/api`;
+    storage = new wodWikiStorage.ApiStorage(apiBase);
+    feedTree = new wod_wiki_engine_star.MemoryFeedTree();
+    baseUrl = trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
+  } else {
+    if (!options.database) {
+      logErr("[wod mcp] Error: Missing database configuration");
+      return 1;
+    }
+    dbHandle = await openCliDb(options.database);
+    storage = dbHandle.storage;
+    feedTree = options.database.kind === "sqlite" ? new NodeFsFeedTree(`${options.database.path}.feed`) : new wod_wiki_engine_star.MemoryFeedTree();
+  }
+  const server = createWodMcpServer({
+    storage,
+    feedTree,
+    baseUrl,
+    readonly: options.readonly
+  });
+  const transport = new stdio_js.StdioServerTransport();
+  await server.connect(transport);
+  return new Promise((resolve4) => {
+    let closed = false;
+    const finish = async (code) => {
+      if (closed) return;
+      closed = true;
+      await server.close().catch(() => {
+      });
+      if (dbHandle) {
+        await dbHandle.close().catch(() => {
+        });
+      }
+      resolve4(code);
+    };
+    transport.onclose = () => {
+      void finish(0);
+    };
+    transport.onerror = (err) => {
+      logErr(`[wod mcp] Transport error: ${err.message}`);
+    };
+    process.once("SIGINT", () => {
+      void finish(0);
+    });
+    process.once("SIGTERM", () => {
+      void finish(0);
+    });
+  });
+}
+var init_mcp = __esm({
+  "src/cli/mcp.ts"() {
+    init_db();
+    init_nodeFeedTree();
+    init_createWodMcpServer();
+  }
+});
 var ParseSyntaxError = class extends Error {
   constructor(errors, message = "Parse error in Whiteboard Script") {
     const details = errors.map((e) => e.message).join("; ");
@@ -4071,7 +4973,23 @@ var VALUE_FLAGS = [
   ["--env-file", "envFile"],
   ["--host", "host"],
   ["--port", "port"],
-  ["--dist", "dist"]
+  ["--dist", "dist"],
+  ["--server", "serverUrl"],
+  ["--note", "noteId"],
+  ["--source-note", "sourceNoteId"],
+  ["--block", "blockId"],
+  ["--notebook", "notebook"],
+  ["--date", "date"],
+  ["--title", "title"],
+  ["--description", "description"],
+  ["--markdown", "markdown"],
+  ["--search", "search"],
+  ["--tag", "tag"],
+  ["--slug", "slug"],
+  ["--category", "category"],
+  ["--type", "tagType"],
+  ["--url", "url"],
+  ["--feed-id", "feedId"]
 ];
 function readValueFlag(args, i, flag) {
   const inline = args[i].startsWith(`${flag}=`);
@@ -4088,7 +5006,10 @@ function parseCliArgs(args) {
   const result = {
     format: "json",
     packs: [],
-    sources: []
+    sources: [],
+    tags: [],
+    aliases: [],
+    setPairs: []
   };
   const valueArgs = result;
   let i = 0;
@@ -4196,8 +5117,50 @@ function parseCliArgs(args) {
       const v = Number(arg.slice("--seed-version=".length));
       if (Number.isSafeInteger(v) && v >= 0) result.seedVersion = v;
       i++;
+    } else if (arg === "--json") {
+      result.json = true;
+      result.format = "json";
+      i++;
+    } else if (arg === "--no-save") {
+      result.noSave = true;
+      i++;
+    } else if (arg === "--mcp-readonly" || arg === "--readonly") {
+      result.mcpReadonly = true;
+      i++;
+    } else if (arg === "--validate-only") {
+      result.validateOnly = true;
+      i++;
+    } else if (arg === "--limit") {
+      const v = Number(args[++i]);
+      if (Number.isSafeInteger(v) && v > 0) result.limit = v;
+      i++;
+    } else if (arg.startsWith("--limit=")) {
+      const v = Number(arg.slice("--limit=".length));
+      if (Number.isSafeInteger(v) && v > 0) result.limit = v;
+      i++;
+    } else if (arg === "--tags") {
+      const raw = args[++i] ?? "";
+      result.tags.push(...raw.split(",").map((t) => t.trim()).filter(Boolean));
+      i++;
+    } else if (arg.startsWith("--tags=")) {
+      result.tags.push(...arg.slice("--tags=".length).split(",").map((t) => t.trim()).filter(Boolean));
+      i++;
+    } else if (arg === "--alias") {
+      const raw = args[++i];
+      if (raw) result.aliases.push(raw);
+      i++;
+    } else if (arg.startsWith("--alias=")) {
+      result.aliases.push(arg.slice("--alias=".length));
+      i++;
+    } else if (arg === "--set") {
+      const raw = args[++i];
+      if (raw) result.setPairs.push(raw);
+      i++;
+    } else if (arg.startsWith("--set=")) {
+      result.setPairs.push(arg.slice("--set=".length));
+      i++;
     } else if (!result.subcommand) {
-      if (arg === "parse" || arg === "run" || arg === "query" || arg === "download" || arg === "export" || arg === "import" || arg === "publish" || arg === "build" || arg === "seed" || arg === "reset" || arg === "init" || arg === "db" || arg === "server" || arg === "serve" || arg === "playground" || arg === "init-feed" || arg === "skills" || arg === "help" || arg === "version") {
+      if (arg === "parse" || arg === "run" || arg === "query" || arg === "download" || arg === "export" || arg === "import" || arg === "publish" || arg === "build" || arg === "seed" || arg === "reset" || arg === "init" || arg === "db" || arg === "server" || arg === "serve" || arg === "playground" || arg === "init-feed" || arg === "skills" || arg === "note" || arg === "journal" || arg === "notebook" || arg === "session" || arg === "catalog" || arg === "tag" || arg === "feed" || arg === "mcp" || arg === "tools" || arg === "doctor" || arg === "help" || arg === "version") {
         result.subcommand = arg;
       } else {
         result.target = arg;
@@ -4209,6 +5172,9 @@ function parseCliArgs(args) {
     } else if (!result.target2) {
       result.target2 = arg;
       i++;
+    } else if (!result.target3) {
+      result.target3 = arg;
+      i++;
     } else {
       i++;
     }
@@ -4319,9 +5285,22 @@ DB OPTIONS (for 'wod db'):
                       actions; credentials are never printed to stdout
 
   wod server [options]
-                      Serve the app (HTTP API + packaged frontend; alias: serve)
+                      Serve the app (HTTP API + /api/mcp + packaged frontend; alias: serve)
   wod playground [options]
-                      Serve the local playground (browser IndexedDB build)
+                      Serve the local playground (browser IndexedDB build + WebMCP)
+  wod mcp [--readonly] [--server <url>]
+                      Start the official MCP server over stdio for Claude/Cursor/Codex
+
+AGENT NOUN-VERB COMMANDS (all support --json and --server <url>):
+  wod note <list|get|create|update|clone|delete> [args]
+  wod journal <day|add> [date] [options]
+  wod notebook <list|save|delete> [slug] [options]
+  wod session <list|get|run|delete> [id] [options]
+  wod catalog <lookup|get|upsert> [effort|equipment|tag|tag-type] [name]
+  wod tag <list|upsert> [label] [--type <tagType>]
+  wod feed <list|status|subscribe|sync|unsubscribe|publish> [options]
+  wod tools <list|manifest> [--json]
+  wod doctor [--json]
 
 SUBCOMMANDS:
   parse <file | ->    Parse Whiteboard Script, create a note in the database
@@ -4452,6 +5431,7 @@ EXIT CODES:
   1 - General / Runtime error
   2 - Parse / Syntax error
   3 - Language Pack load error
+  4 - Destructive confirmation required (pass --yes <targetId>)
 `;
 }
 function printUsage(writer) {
@@ -4585,22 +5565,32 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       }
       const noteSource = cliNoteSource(source, parsed.target, parsed.sport);
       const ir = runParse(source, { sport: parsed.sport, sourceLabel: `cli:wod parse ${parsed.target}` });
-      const identity = wod_wiki_engine_star.extractNoteIdentity(source);
-      const tags = wod_wiki_engine_star.extractTypedTags(source);
-      const db = await openCliDb(cliDb());
-      try {
-        const persisted = await persistNote(db, {
-          source: noteSource,
-          sourceLabel: parsed.target,
-          noteId: identity?.noteId,
-          title: identity?.title,
-          tags
-        });
-        writeOut(
-          `[wod parse] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.blocks} blocks, ${persisted.efforts} efforts${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db.path}`
-        );
-      } finally {
-        await db.close();
+      if (!parsed.noSave) {
+        const identity = wod_wiki_engine_star.extractNoteIdentity(source);
+        const tags = wod_wiki_engine_star.extractTypedTags(source);
+        const db = await openCliDb(cliDb());
+        try {
+          const persisted = await persistNote(db, {
+            source: noteSource,
+            sourceLabel: parsed.target,
+            noteId: identity?.noteId,
+            title: identity?.title,
+            tags
+          });
+          if (!parsed.json) {
+            writeOut(
+              `[wod parse] note ${persisted.noteId}${persisted.created ? "" : " (updated)"} \u2014 ${persisted.blocks} blocks, ${persisted.efforts} efforts${persisted.tags > 0 ? `, ${persisted.tags} tags` : ""} \u2192 ${db.path}`
+            );
+          } else if (!parsed.output) {
+            deliverOutput(JSON.stringify({ ok: true, persisted, ir }, null, 2));
+          }
+        } finally {
+          await db.close();
+        }
+      } else if (parsed.json && !parsed.output) {
+        deliverOutput(formatParseOutput(ir, "json", true));
+      } else if (!parsed.output) {
+        writeOut(`[wod parse] valid Whiteboard Script (--no-save)`);
       }
       if (parsed.output) {
         const pretty = Boolean(process.stdout.isTTY);
@@ -4610,8 +5600,18 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       return 0;
     }
     if (parsed.subcommand === "run") {
+      if (parsed.noteId && !parsed.target) {
+        const { runAgentNounVerbCommand: runAgentNounVerbCommand2 } = await Promise.resolve().then(() => (init_agentCommands(), agentCommands_exports));
+        return runAgentNounVerbCommand2({
+          parsed: { ...parsed, subcommand: "session", target: "run", target2: parsed.noteId },
+          resolveDbConfig: cliDb,
+          readStdin: getStdin,
+          writeOut,
+          writeErr
+        });
+      }
       if (!parsed.target) {
-        writeErr('[wod run] Error: Missing input file or "-" for stdin');
+        writeErr('[wod run] Error: Missing input file, "-" for stdin, or --note <noteId>');
         return 1;
       }
       let source;
@@ -4667,6 +5667,18 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         writeErr("[wod query] Error: Missing WQL query argument");
         return 1;
       }
+      if (parsed.validateOnly) {
+        const { wodValidateWqlTool } = await import('@bitcobblers/wod-wiki-engine/agent');
+        const validation = await wodValidateWqlTool.execute({ query: parsed.target }, {
+          storage: void 0
+        });
+        if (parsed.json || parsed.format === "json") {
+          deliverOutput(JSON.stringify(validation, null, 2));
+        } else {
+          writeOut(validation.valid ? `[wod query] valid (${validation.family ?? "wql"})` : `[wod query] invalid: ${validation.error}`);
+        }
+        return validation.valid ? 0 : 2;
+      }
       const useDb = !parsed.corpus && !parsed.stdinLog && !parsed.stdinFacts;
       let stdinLogContent;
       let stdinFactsContent;
@@ -4994,10 +6006,20 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
         );
         return 1;
       }
+      if (parsed.yes !== void 0 && parsed.yes !== "RESET") {
+        writeErr("[wod reset] Invalid --yes value (expected: --yes RESET)");
+        return 4;
+      }
       const target = config.path;
       if (nodeFs().existsSync(target)) {
         nodeFs().unlinkSync(target);
-        writeOut(`[wod reset] removed ${target}`);
+        if (parsed.json) {
+          writeOut(JSON.stringify({ ok: true, removed: true, path: target }, null, 2));
+        } else {
+          writeOut(`[wod reset] removed ${target}`);
+        }
+      } else if (parsed.json) {
+        writeOut(JSON.stringify({ ok: true, removed: false, path: target }, null, 2));
       } else {
         writeOut(`[wod reset] nothing to reset \u2014 ${target} does not exist`);
       }
@@ -5042,9 +6064,29 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
       if (parsed.host !== void 0) options.host = parsed.host;
       if (parsed.port !== void 0) options.port = parsed.port;
       if (parsed.dist !== void 0) options.dist = parsed.dist;
+      if (parsed.mcpReadonly === true) options.mcpReadonly = true;
       await runCliServer2(mode, options, writeOut);
       return 0;
     }
+    if (parsed.subcommand === "mcp") {
+      const { runMcpStdio: runMcpStdio2 } = await Promise.resolve().then(() => (init_mcp(), mcp_exports));
+      return runMcpStdio2({
+        database: parsed.serverUrl ? void 0 : cliDb(),
+        serverUrl: parsed.serverUrl,
+        readonly: parsed.mcpReadonly === true || cliEnv().WOD_MCP_READONLY === "1",
+        writeErr
+      });
+    }
+    if (parsed.subcommand === "note" || parsed.subcommand === "journal" || parsed.subcommand === "notebook" || parsed.subcommand === "session" || parsed.subcommand === "catalog" || parsed.subcommand === "tag" || parsed.subcommand === "feed" || parsed.subcommand === "tools" || parsed.subcommand === "doctor") {
+      const { runAgentNounVerbCommand: runAgentNounVerbCommand2 } = await Promise.resolve().then(() => (init_agentCommands(), agentCommands_exports));
+      return runAgentNounVerbCommand2({
+        parsed,
+        resolveDbConfig: cliDb,
+        readStdin: getStdin,
+        writeOut,
+        writeErr
+      });
+    }
     writeErr(`[wod] Unknown subcommand "${parsed.subcommand}"`);
     return 1;
   } catch (error) {
@@ -5064,14 +6106,18 @@ async function cliMain(argv = process.argv.slice(2), io = {}) {
 // src/index.ts
 init_db();
 init_server();
+init_createWodMcpServer();
+init_httpHandler();
 
 exports.PackLoadError = PackLoadError;
 exports.ParseSyntaxError = ParseSyntaxError;
 exports.WqlSyntaxError = WqlSyntaxError;
 exports.cliMain = cliMain;
+exports.createWodMcpServer = createWodMcpServer;
 exports.formatExecutionOutput = formatExecutionOutput;
 exports.formatParseOutput = formatParseOutput;
 exports.formatQueryOutput = formatQueryOutput;
+exports.handleMcpHttpRequest = handleMcpHttpRequest;
 exports.loadCliEnvironment = loadCliEnvironment;
 exports.loadLanguagePack = loadLanguagePack;
 exports.loadQueryData = loadQueryData;