@riotprompt/riotdoc 1.0.1-dev.0 → 1.0.4

package/dist/mcp-server.js

@@ -0,0 +1,1109 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { c as createWorkspace, b as loadVoice } from "./loader-DJHV70rz.js";
+import { join, dirname, resolve } from "node:path";
+import { mkdir, appendFile, readFile, writeFile } from "node:fs/promises";
+import { l as loadDocument, c as loadOutline, a as loadObjectives } from "./loader-Cvfo7vBn.js";
+import { parse } from "yaml";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+function formatTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function executeCommand(args, context, commandFn, resultBuilder) {
+  const originalCwd = process.cwd();
+  const logs = [];
+  try {
+    if (args.path) {
+      process.chdir(args.path);
+      logs.push(`Changed to directory: ${args.path}`);
+    }
+    const result = await commandFn();
+    if (args.path) {
+      process.chdir(originalCwd);
+    }
+    const data = resultBuilder ? resultBuilder(result, args, originalCwd) : { result, path: args.path || originalCwd };
+    return {
+      success: true,
+      data,
+      message: args.dry_run ? "Dry run completed" : "Command completed successfully",
+      logs: logs.length > 0 ? logs : void 0
+    };
+  } catch (error) {
+    if (args.path && process.cwd() !== originalCwd) {
+      try {
+        process.chdir(originalCwd);
+      } catch {
+      }
+    }
+    return {
+      success: false,
+      error: error.message || "Command failed",
+      context: {
+        path: args.path || originalCwd,
+        command: error.command
+      },
+      logs: logs.length > 0 ? logs : void 0
+    };
+  }
+}
+async function executeCreate(args, context) {
+  return executeCommand(
+    args,
+    context,
+    async () => {
+      const { join: join2, resolve: resolve2 } = await import("node:path");
+      const basePath = args.base_path || process.cwd();
+      const workspacePath = resolve2(join2(basePath, args.name));
+      const title = args.title || args.name.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+      await createWorkspace({
+        path: workspacePath,
+        id: args.name,
+        title,
+        type: args.type,
+        objectives: {
+          primaryGoal: args.primary_goal || "",
+          secondaryGoals: [],
+          keyTakeaways: []
+        }
+      });
+      return {
+        workspacePath,
+        name: args.name,
+        title,
+        type: args.type
+      };
+    },
+    (result) => ({
+      workspace: result.workspacePath,
+      name: result.name,
+      title: result.title,
+      type: result.type,
+      nextSteps: [
+        "Edit voice/tone.md to define your writing voice",
+        "Edit OBJECTIVES.md to refine your goals",
+        "Run: riotdoc_outline to generate outline",
+        "Run: riotdoc_draft to create first draft"
+      ]
+    })
+  );
+}
+const CheckpointCreateSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  name: z.string().describe("Checkpoint name (kebab-case)"),
+  message: z.string().describe("Description of why checkpoint created"),
+  capturePrompt: z.boolean().optional().default(true).describe("Capture conversation context")
+});
+const CheckpointListSchema = z.object({
+  path: z.string().optional().describe("Path to document directory")
+});
+const CheckpointShowSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  checkpoint: z.string().describe("Checkpoint name")
+});
+const CheckpointRestoreSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  checkpoint: z.string().describe("Checkpoint name")
+});
+const HistoryShowSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  since: z.string().optional().describe("Show events since this ISO timestamp"),
+  eventType: z.string().optional().describe("Filter by event type"),
+  limit: z.number().optional().describe("Maximum number of events to show")
+});
+async function logEvent(docPath, event) {
+  const historyDir = join(docPath, ".history");
+  await mkdir(historyDir, { recursive: true });
+  const timelinePath = join(historyDir, "timeline.jsonl");
+  const line = JSON.stringify(event) + "\n";
+  await appendFile(timelinePath, line);
+}
+({
+  inputSchema: CheckpointCreateSchema.shape
+});
+({
+  inputSchema: CheckpointListSchema.shape
+});
+({
+  inputSchema: CheckpointShowSchema.shape
+});
+({
+  inputSchema: CheckpointRestoreSchema.shape
+});
+({
+  inputSchema: HistoryShowSchema.shape
+});
+const InsertSectionSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  title: z.string().describe("Section title"),
+  position: z.number().optional().describe("Position to insert (1-based, optional)"),
+  after: z.string().optional().describe("Insert after this section title (optional)")
+});
+const RenameSectionSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  oldTitle: z.string().describe("Current section title"),
+  newTitle: z.string().describe("New section title")
+});
+const DeleteSectionSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  title: z.string().describe("Section title to delete")
+});
+const MoveSectionSchema = z.object({
+  path: z.string().optional().describe("Path to document directory"),
+  title: z.string().describe("Section title to move"),
+  position: z.number().describe("New position (1-based)")
+});
+function parseOutline(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  for (const line of lines) {
+    if (line.match(/^##\s+/)) {
+      sections.push(line);
+    }
+  }
+  return sections;
+}
+async function insertSection(args) {
+  const docPath = args.path || process.cwd();
+  const outlinePath = join(docPath, "outline.md");
+  const content = await readFile(outlinePath, "utf-8");
+  const lines = content.split("\n");
+  let insertIndex;
+  if (args.after) {
+    const afterIndex = lines.findIndex(
+      (line) => line.toLowerCase().includes(args.after.toLowerCase())
+    );
+    if (afterIndex === -1) {
+      throw new Error(`Section not found: ${args.after}`);
+    }
+    insertIndex = afterIndex + 1;
+  } else if (args.position) {
+    const sections = parseOutline(content);
+    if (args.position < 1 || args.position > sections.length + 1) {
+      throw new Error(`Invalid position: ${args.position}. Must be between 1 and ${sections.length + 1}`);
+    }
+    let sectionCount = 0;
+    insertIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].match(/^##\s+/)) {
+        sectionCount++;
+        if (sectionCount === args.position) {
+          insertIndex = i;
+          break;
+        }
+      }
+    }
+    if (insertIndex === 0) {
+      insertIndex = lines.length;
+    }
+  } else {
+    insertIndex = lines.length;
+  }
+  const newSection = `## ${args.title}`;
+  lines.splice(insertIndex, 0, newSection, "");
+  await writeFile(outlinePath, lines.join("\n"));
+  await logEvent(docPath, {
+    timestamp: formatTimestamp(),
+    type: "outline_created",
+    data: {
+      action: "insert",
+      title: args.title,
+      position: insertIndex
+    }
+  });
+  return `✅ Section inserted: "${args.title}" at position ${insertIndex}`;
+}
+async function renameSection(args) {
+  const docPath = args.path || process.cwd();
+  const outlinePath = join(docPath, "outline.md");
+  const content = await readFile(outlinePath, "utf-8");
+  const lines = content.split("\n");
+  let found = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^##\s+/) && lines[i].toLowerCase().includes(args.oldTitle.toLowerCase())) {
+      lines[i] = `## ${args.newTitle}`;
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    throw new Error(`Section not found: ${args.oldTitle}`);
+  }
+  await writeFile(outlinePath, lines.join("\n"));
+  await logEvent(docPath, {
+    timestamp: formatTimestamp(),
+    type: "outline_created",
+    data: {
+      action: "rename",
+      oldTitle: args.oldTitle,
+      newTitle: args.newTitle
+    }
+  });
+  return `✅ Section renamed: "${args.oldTitle}" → "${args.newTitle}"`;
+}
+async function deleteSection(args) {
+  const docPath = args.path || process.cwd();
+  const outlinePath = join(docPath, "outline.md");
+  const content = await readFile(outlinePath, "utf-8");
+  const lines = content.split("\n");
+  let found = false;
+  let deleteIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^##\s+/) && lines[i].toLowerCase().includes(args.title.toLowerCase())) {
+      deleteIndex = i;
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    throw new Error(`Section not found: ${args.title}`);
+  }
+  lines.splice(deleteIndex, lines[deleteIndex + 1] === "" ? 2 : 1);
+  await writeFile(outlinePath, lines.join("\n"));
+  await logEvent(docPath, {
+    timestamp: formatTimestamp(),
+    type: "outline_created",
+    data: {
+      action: "delete",
+      title: args.title
+    }
+  });
+  return `✅ Section deleted: "${args.title}"`;
+}
+async function moveSection(args) {
+  const docPath = args.path || process.cwd();
+  const outlinePath = join(docPath, "outline.md");
+  const content = await readFile(outlinePath, "utf-8");
+  const lines = content.split("\n");
+  let sectionIndex = -1;
+  let sectionLine = "";
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^##\s+/) && lines[i].toLowerCase().includes(args.title.toLowerCase())) {
+      sectionIndex = i;
+      sectionLine = lines[i];
+      break;
+    }
+  }
+  if (sectionIndex === -1) {
+    throw new Error(`Section not found: ${args.title}`);
+  }
+  lines.splice(sectionIndex, 1);
+  const sections = parseOutline(lines.join("\n"));
+  if (args.position < 1 || args.position > sections.length + 1) {
+    throw new Error(`Invalid position: ${args.position}. Must be between 1 and ${sections.length + 1}`);
+  }
+  let insertIndex = 0;
+  let sectionCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].match(/^##\s+/)) {
+      sectionCount++;
+      if (sectionCount === args.position) {
+        insertIndex = i;
+        break;
+      }
+    }
+  }
+  if (insertIndex === 0 && args.position > sections.length) {
+    insertIndex = lines.length;
+  }
+  lines.splice(insertIndex, 0, sectionLine);
+  await writeFile(outlinePath, lines.join("\n"));
+  await logEvent(docPath, {
+    timestamp: formatTimestamp(),
+    type: "outline_created",
+    data: {
+      action: "move",
+      title: args.title,
+      newPosition: args.position
+    }
+  });
+  return `✅ Section moved: "${args.title}" to position ${args.position}`;
+}
+async function executeInsertSection(args, _context) {
+  try {
+    const validated = InsertSectionSchema.parse(args);
+    const result = await insertSection(validated);
+    return { success: true, data: { message: result } };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function executeRenameSection(args, _context) {
+  try {
+    const validated = RenameSectionSchema.parse(args);
+    const result = await renameSection(validated);
+    return { success: true, data: { message: result } };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function executeDeleteSection(args, _context) {
+  try {
+    const validated = DeleteSectionSchema.parse(args);
+    const result = await deleteSection(validated);
+    return { success: true, data: { message: result } };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function executeMoveSection(args, _context) {
+  try {
+    const validated = MoveSectionSchema.parse(args);
+    const result = await moveSection(validated);
+    return { success: true, data: { message: result } };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+({
+  inputSchema: InsertSectionSchema.shape
+});
+({
+  inputSchema: RenameSectionSchema.shape
+});
+({
+  inputSchema: DeleteSectionSchema.shape
+});
+({
+  inputSchema: MoveSectionSchema.shape
+});
+async function executeDraft(args, _context) {
+  const workspacePath = args.path || process.cwd();
+  return {
+    success: true,
+    data: {
+      action: "pending",
+      path: workspacePath,
+      note: "Draft creation implementation pending - requires AI integration",
+      assistanceLevel: args.assistance_level
+    },
+    message: "Draft command - implementation pending"
+  };
+}
+async function executeStatus(args, context) {
+  return executeCommand(
+    args,
+    context,
+    async () => {
+      const workspacePath = args.path || process.cwd();
+      const doc = await loadDocument(workspacePath);
+      if (!doc) {
+        throw new Error("Not a RiotDoc workspace");
+      }
+      return {
+        path: workspacePath,
+        title: doc.config.title,
+        type: doc.config.type,
+        status: doc.config.status,
+        createdAt: doc.config.createdAt.toISOString(),
+        updatedAt: doc.config.updatedAt.toISOString(),
+        targetWordCount: doc.config.targetWordCount,
+        audience: doc.config.audience,
+        draftCount: doc.drafts.length,
+        evidenceCount: doc.evidence.length
+      };
+    }
+  );
+}
+async function executeSpellcheck(args, _context) {
+  const workspacePath = args.path || process.cwd();
+  return {
+    success: true,
+    data: {
+      action: "pending",
+      path: workspacePath,
+      file: args.file,
+      note: "Spellcheck implementation pending"
+    },
+    message: "Spellcheck command - implementation pending"
+  };
+}
+async function executeCleanup(args, _context) {
+  const workspacePath = args.path || process.cwd();
+  return {
+    success: true,
+    data: {
+      action: "pending",
+      path: workspacePath,
+      keepDrafts: args.keep_drafts || 5,
+      dryRun: args.dry_run || false,
+      note: "Cleanup implementation pending"
+    },
+    message: "Cleanup command - implementation pending"
+  };
+}
+async function executeExport(args, _context) {
+  const workspacePath = args.path || process.cwd();
+  return {
+    success: true,
+    data: {
+      action: "pending",
+      path: workspacePath,
+      format: args.format,
+      draft: args.draft,
+      output: args.output,
+      note: "Export implementation pending"
+    },
+    message: "Export command - implementation pending"
+  };
+}
+async function executeRevise(args, _context) {
+  const workspacePath = args.path || process.cwd();
+  return {
+    success: true,
+    data: {
+      action: "pending",
+      path: workspacePath,
+      draft: args.draft,
+      feedback: args.feedback,
+      note: "Revise implementation pending"
+    },
+    message: "Revise command - implementation pending"
+  };
+}
+async function executeTool(toolName, args, context) {
+  try {
+    switch (toolName) {
+      case "riotdoc_create":
+        return await executeCreate(args, context);
+      case "riotdoc_outline_insert_section":
+        return await executeInsertSection(args, context);
+      case "riotdoc_outline_rename_section":
+        return await executeRenameSection(args, context);
+      case "riotdoc_outline_delete_section":
+        return await executeDeleteSection(args, context);
+      case "riotdoc_outline_move_section":
+        return await executeMoveSection(args, context);
+      case "riotdoc_draft":
+        return await executeDraft(args, context);
+      case "riotdoc_status":
+        return await executeStatus(args, context);
+      case "riotdoc_spellcheck":
+        return await executeSpellcheck(args, context);
+      case "riotdoc_cleanup":
+        return await executeCleanup(args, context);
+      case "riotdoc_export":
+        return await executeExport(args, context);
+      case "riotdoc_revise":
+        return await executeRevise(args, context);
+      default:
+        return {
+          success: false,
+          error: `Unknown tool: ${toolName}`
+        };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message || "Tool execution failed",
+      context: {
+        tool: toolName,
+        args
+      }
+    };
+  }
+}
+function parseRiotdocUri(uri) {
+  if (!uri.startsWith("riotdoc://")) {
+    throw new Error(`Invalid riotdoc URI: ${uri}`);
+  }
+  const withoutScheme = uri.slice("riotdoc://".length);
+  const [pathPart, queryPart] = withoutScheme.split("?");
+  const segments = pathPart.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    throw new Error(`Invalid riotdoc URI: missing resource type`);
+  }
+  const type = segments[0];
+  const path = segments.slice(1).join("/") || void 0;
+  const query = {};
+  if (queryPart) {
+    const params = new URLSearchParams(queryPart);
+    for (const [key, value] of params) {
+      query[key] = value;
+    }
+  }
+  return {
+    scheme: "riotdoc",
+    type,
+    path,
+    query: Object.keys(query).length > 0 ? query : void 0
+  };
+}
+async function readConfigResource(uri) {
+  const directory = uri.path || process.cwd();
+  const configPath = join(directory, "riotdoc.yaml");
+  try {
+    const content = await readFile(configPath, "utf-8");
+    const config = parse(content);
+    return {
+      path: directory,
+      exists: true,
+      config
+    };
+  } catch {
+    return {
+      path: directory,
+      exists: false,
+      config: void 0
+    };
+  }
+}
+async function readStatusResource(uri) {
+  const directory = uri.path || process.cwd();
+  const doc = await loadDocument(directory);
+  if (!doc) {
+    throw new Error("Not a RiotDoc workspace");
+  }
+  return {
+    path: directory,
+    title: doc.config.title,
+    type: doc.config.type,
+    status: doc.config.status,
+    createdAt: doc.config.createdAt.toISOString(),
+    updatedAt: doc.config.updatedAt.toISOString(),
+    targetWordCount: doc.config.targetWordCount,
+    audience: doc.config.audience
+  };
+}
+async function readDocumentResource(uri) {
+  const directory = uri.path || process.cwd();
+  const doc = await loadDocument(directory);
+  if (!doc) {
+    throw new Error("Not a RiotDoc workspace");
+  }
+  return {
+    path: directory,
+    config: {
+      id: doc.config.id,
+      title: doc.config.title,
+      type: doc.config.type,
+      status: doc.config.status,
+      createdAt: doc.config.createdAt.toISOString(),
+      updatedAt: doc.config.updatedAt.toISOString(),
+      targetWordCount: doc.config.targetWordCount,
+      audience: doc.config.audience
+    },
+    voice: doc.voice,
+    objectives: doc.objectives,
+    outline: void 0,
+    // Loaded separately if needed
+    drafts: doc.drafts.map((d) => ({
+      number: d.number,
+      path: d.path,
+      createdAt: d.createdAt.toISOString(),
+      wordCount: d.wordCount
+    })),
+    evidence: doc.evidence.map((e) => ({
+      id: e.id,
+      path: e.path,
+      description: e.description,
+      type: e.type
+    }))
+  };
+}
+async function readOutlineResource(uri) {
+  const directory = uri.path || process.cwd();
+  try {
+    const content = await loadOutline(directory);
+    return {
+      path: directory,
+      content,
+      exists: true
+    };
+  } catch {
+    return {
+      path: directory,
+      content: "",
+      exists: false
+    };
+  }
+}
+async function readObjectivesResource(uri) {
+  const directory = uri.path || process.cwd();
+  const objectives = await loadObjectives(directory);
+  return {
+    path: directory,
+    primaryGoal: objectives.primaryGoal,
+    secondaryGoals: objectives.secondaryGoals,
+    keyTakeaways: objectives.keyTakeaways,
+    callToAction: objectives.callToAction,
+    emotionalArc: objectives.emotionalArc
+  };
+}
+async function readVoiceResource(uri) {
+  const directory = uri.path || process.cwd();
+  const voice = await loadVoice(directory);
+  return {
+    path: directory,
+    tone: voice.tone,
+    pointOfView: voice.pointOfView,
+    styleNotes: voice.styleNotes,
+    avoid: voice.avoid,
+    examplePhrases: voice.examplePhrases
+  };
+}
+async function readStyleReportResource(uri) {
+  const directory = uri.path || process.cwd();
+  return {
+    path: directory,
+    issues: [],
+    summary: {
+      errors: 0,
+      warnings: 0,
+      info: 0
+    }
+  };
+}
+function getResources() {
+  return [
+    {
+      uri: "riotdoc://config",
+      name: "Configuration",
+      description: "Loads riotdoc configuration from riotdoc.yaml. URI format: riotdoc://config[/path/to/workspace]. If no path is provided, uses current working directory. Returns: { path: string, exists: boolean, config: object }. The config object includes document metadata, type, status, and settings.",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotdoc://status",
+      name: "Document Status",
+      description: "Gets the current document status including title, type, dates, and progress. URI format: riotdoc://status[/path/to/workspace]. Returns: { path, title, type, status, createdAt, updatedAt, targetWordCount, audience }. Use this to check the state of a document before operations.",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotdoc://document",
+      name: "Complete Document",
+      description: "Loads complete document state including config, voice, objectives, drafts, and evidence. URI format: riotdoc://document[/path/to/workspace]. Returns comprehensive document information. Use this to get a full snapshot of the document workspace.",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotdoc://outline",
+      name: "Document Outline",
+      description: "Retrieves the document outline from OUTLINE.md. URI format: riotdoc://outline[/path/to/workspace]. Returns: { path, content, exists }. The outline provides the structural framework for the document.",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotdoc://objectives",
+      name: "Document Objectives",
+      description: "Loads document objectives from OBJECTIVES.md. URI format: riotdoc://objectives[/path/to/workspace]. Returns: { path, primaryGoal, secondaryGoals, keyTakeaways, callToAction, emotionalArc }. Objectives define what the document aims to achieve.",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotdoc://voice",
+      name: "Voice Configuration",
+      description: "Retrieves voice and tone configuration from voice/tone.md. URI format: riotdoc://voice[/path/to/workspace]. Returns: { path, tone, pointOfView, styleNotes, avoid, examplePhrases }. Voice configuration defines the writing style and tone.",
+      mimeType: "application/json"
+    },
+    {
+      uri: "riotdoc://style-report",
+      name: "Style Validation Report",
+      description: "Gets style validation results for the document. URI format: riotdoc://style-report[/path/to/workspace]. Returns: { path, issues: Array<{line, column, severity, message, rule}>, summary }. Use this to check for style violations and writing quality issues.",
+      mimeType: "application/json"
+    }
+  ];
+}
+async function readResource(uri) {
+  const parsed = parseRiotdocUri(uri);
+  switch (parsed.type) {
+    case "config":
+      return readConfigResource(parsed);
+    case "status":
+      return readStatusResource(parsed);
+    case "document":
+      return readDocumentResource(parsed);
+    case "outline":
+      return readOutlineResource(parsed);
+    case "objectives":
+      return readObjectivesResource(parsed);
+    case "voice":
+      return readVoiceResource(parsed);
+    case "style-report":
+      return readStyleReportResource(parsed);
+    default:
+      throw new Error(`Unknown resource type: ${parsed.type}`);
+  }
+}
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+function getPromptsDir() {
+  const isBundled = __dirname$1.includes("/dist") || __dirname$1.endsWith("dist") || __filename$1.includes("dist/mcp-server.js") || __filename$1.includes("dist\\mcp-server.js");
+  if (isBundled) {
+    const promptsDir = resolve(__dirname$1, "mcp/prompts");
+    return promptsDir;
+  }
+  return __dirname$1;
+}
+function loadTemplate(name) {
+  const promptsDir = getPromptsDir();
+  const path = resolve(promptsDir, `${name}.md`);
+  try {
+    return readFileSync(path, "utf-8").trim();
+  } catch (error) {
+    throw new Error(`Failed to load prompt template "${name}" from ${path}: ${error}`);
+  }
+}
+function fillTemplate(template, args) {
+  return template.replace(/\${(\w+)}/g, (_, key) => {
+    return args[key] || `[${key}]`;
+  });
+}
+function getPrompts() {
+  return [
+    {
+      name: "create_document",
+      description: "Guided workflow for creating a new document workspace",
+      arguments: [
+        {
+          name: "name",
+          description: "Document workspace name",
+          required: true
+        },
+        {
+          name: "type",
+          description: "Document type (blog-post, podcast-script, technical-doc, newsletter, custom)",
+          required: true
+        },
+        {
+          name: "title",
+          description: "Document title",
+          required: false
+        },
+        {
+          name: "goal",
+          description: "Primary goal",
+          required: false
+        },
+        {
+          name: "audience",
+          description: "Target audience",
+          required: false
+        },
+        {
+          name: "base_path",
+          description: "Base path for workspace",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "outline_document",
+      description: "Guided workflow for generating or refining document outline",
+      arguments: [
+        {
+          name: "path",
+          description: "Document workspace path",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "draft_document",
+      description: "Guided workflow for creating document drafts with AI assistance",
+      arguments: [
+        {
+          name: "path",
+          description: "Document workspace path",
+          required: false
+        },
+        {
+          name: "level",
+          description: "Assistance level (generate, expand, revise, cleanup, spellcheck)",
+          required: false
+        }
+      ]
+    },
+    {
+      name: "review_document",
+      description: "Guided workflow for reviewing and providing feedback on drafts",
+      arguments: [
+        {
+          name: "path",
+          description: "Document workspace path",
+          required: false
+        },
+        {
+          name: "draft_number",
+          description: "Draft number to review",
+          required: false
+        }
+      ]
+    }
+  ];
+}
+async function getPrompt(name, args) {
+  const prompts = getPrompts();
+  if (!prompts.find((p) => p.name === name)) {
+    throw new Error(`Unknown prompt: ${name}`);
+  }
+  const template = loadTemplate(name);
+  const filledArgs = { ...args };
+  if (!filledArgs.path) filledArgs.path = "current directory";
+  if (!filledArgs.base_path) filledArgs.base_path = "current directory";
+  const content = fillTemplate(template, filledArgs);
+  return [
+    {
+      role: "user",
+      content: {
+        type: "text",
+        text: content
+      }
+    }
+  ];
+}
+function removeUndefinedValues(obj) {
+  if (obj === void 0) {
+    return void 0;
+  }
+  if (obj === null) {
+    return null;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(removeUndefinedValues).filter((item) => item !== void 0);
+  }
+  if (typeof obj === "object") {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+      const cleanedValue = removeUndefinedValues(value);
+      if (cleanedValue !== void 0) {
+        cleaned[key] = cleanedValue;
+      }
+    }
+    return cleaned;
+  }
+  return obj;
+}
+async function main() {
+  const server = new McpServer(
+    {
+      name: "riotdoc",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {
+          subscribe: false,
+          listChanged: false
+        },
+        prompts: {
+          listChanged: false
+        }
+      }
+    }
+  );
+  function registerTool(name, description, inputSchema) {
+    server.tool(
+      name,
+      description,
+      inputSchema,
+      async (args, { sendNotification, _meta }) => {
+        const context = {
+          workingDirectory: process.cwd(),
+          config: void 0,
+          logger: void 0,
+          sendNotification: async (notification) => {
+            if (notification.method === "notifications/progress" && _meta?.progressToken) {
+              const params = {
+                progressToken: _meta.progressToken,
+                progress: notification.params.progress
+              };
+              if (notification.params.total !== void 0) {
+                params.total = notification.params.total;
+              }
+              if (notification.params.message !== void 0) {
+                params.message = notification.params.message;
+              }
+              await sendNotification({
+                method: "notifications/progress",
+                params: removeUndefinedValues(params)
+              });
+            }
+          },
+          progressToken: _meta?.progressToken
+        };
+        const result = await executeTool(name, args, context);
+        if (result.success) {
+          const content = [];
+          if (result.logs && result.logs.length > 0) {
+            content.push({
+              type: "text",
+              text: "=== Command Output ===\n" + result.logs.join("\n") + "\n\n=== Result ==="
+            });
+          }
+          const cleanData = removeUndefinedValues(result.data);
+          content.push({
+            type: "text",
+            text: JSON.stringify(cleanData, null, 2)
+          });
+          return { content };
+        } else {
+          const errorParts = [];
+          if (result.logs && result.logs.length > 0) {
+            errorParts.push("=== Command Output ===");
+            errorParts.push(result.logs.join("\n"));
+            errorParts.push("\n=== Error ===");
+          }
+          errorParts.push(result.error || "Unknown error");
+          if (result.context && typeof result.context === "object") {
+            errorParts.push("\n=== Context ===");
+            for (const [key, value] of Object.entries(result.context)) {
+              if (value !== void 0 && value !== null) {
+                errorParts.push(`${key}: ${String(value)}`);
+              }
+            }
+          }
+          if (result.recovery && result.recovery.length > 0) {
+            errorParts.push("\n=== Recovery Steps ===");
+            errorParts.push(...result.recovery.map((step, i) => `${i + 1}. ${step}`));
+          }
+          return {
+            content: [{
+              type: "text",
+              text: errorParts.join("\n")
+            }],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  registerTool(
+    "riotdoc_create",
+    "Create a new document workspace with structured directories and configuration",
+    {
+      name: z.string(),
+      title: z.string().optional(),
+      type: z.enum(["blog-post", "podcast-script", "technical-doc", "newsletter", "custom"]),
+      base_path: z.string().optional(),
+      primary_goal: z.string().optional(),
+      audience: z.string().optional()
+    }
+  );
+  registerTool(
+    "riotdoc_outline",
+    "Generate or retrieve document outline",
+    {
+      path: z.string().optional(),
+      generate: z.boolean().optional()
+    }
+  );
+  registerTool(
+    "riotdoc_draft",
+    "Create a new draft or retrieve existing drafts",
+    {
+      path: z.string().optional(),
+      assistance_level: z.enum(["generate", "expand", "revise", "cleanup", "spellcheck"]).optional(),
+      draft_number: z.number().optional()
+    }
+  );
+  registerTool(
+    "riotdoc_status",
+    "Get document status and metadata",
+    {
+      path: z.string().optional()
+    }
+  );
+  registerTool(
+    "riotdoc_spellcheck",
+    "Run spell checking on document content",
+    {
+      path: z.string().optional(),
+      file: z.string().optional()
+    }
+  );
+  registerTool(
+    "riotdoc_cleanup",
+    "Clean up document workspace by removing temporary files and old drafts",
+    {
+      path: z.string().optional(),
+      keep_drafts: z.number().optional(),
+      dry_run: z.boolean().optional()
+    }
+  );
+  registerTool(
+    "riotdoc_export",
+    "Export document to various formats",
+    {
+      path: z.string().optional(),
+      format: z.enum(["html", "pdf", "docx", "markdown"]),
+      draft: z.number().optional(),
+      output: z.string().optional()
+    }
+  );
+  registerTool(
+    "riotdoc_revise",
+    "Add revision feedback to a draft",
+    {
+      path: z.string().optional(),
+      draft: z.number().optional(),
+      feedback: z.string()
+    }
+  );
+  const resources = getResources();
+  for (const resource of resources) {
+    server.resource(
+      resource.name,
+      resource.uri,
+      {
+        description: resource.description || ""
+      },
+      async () => {
+        const data = await readResource(resource.uri);
+        return {
+          contents: [{
+            uri: resource.uri,
+            mimeType: resource.mimeType || "application/json",
+            text: JSON.stringify(data, null, 2)
+          }]
+        };
+      }
+    );
+  }
+  const prompts = getPrompts();
+  for (const prompt of prompts) {
+    const promptArgs = {};
+    if (prompt.arguments) {
+      for (const arg of prompt.arguments) {
+        promptArgs[arg.name] = arg.required ? z.string() : z.string().optional();
+      }
+    }
+    server.prompt(
+      prompt.name,
+      prompt.description,
+      promptArgs,
+      async (args, _extra) => {
+        const argsRecord = {};
+        for (const [key, value] of Object.entries(args)) {
+          if (typeof value === "string") {
+            argsRecord[key] = value;
+          }
+        }
+        const messages = await getPrompt(prompt.name, argsRecord);
+        return {
+          messages: messages.map((msg) => {
+            if (msg.content.type === "text") {
+              return {
+                role: msg.role,
+                content: {
+                  type: "text",
+                  text: msg.content.text || ""
+                }
+              };
+            }
+            return msg;
+          })
+        };
+      }
+    );
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("MCP Server error:", error);
+  process.exit(1);
+});
+export {
+  removeUndefinedValues
+};
+//# sourceMappingURL=mcp-server.js.map