documcp

Instructions

Implementation Reference

• src/tools/generate-config.ts:54-158 (handler)

  Main handler function for 'generate_config' tool. Validates input with Zod schema, generates SSG-specific configuration files using helper functions, writes them to outputPath, and formats MCP response.

  export async function generateConfig(
    args: unknown,
  ): Promise<{ content: any[] }> {
    const startTime = Date.now();
    const { ssg, projectName, projectDescription, outputPath } =
      inputSchema.parse(args);
  
    try {
      // Ensure output directory exists
      await fs.mkdir(outputPath, { recursive: true });
  
      let configFiles: Array<{ path: string; content: string }> = [];
  
      switch (ssg) {
        case "docusaurus":
          configFiles = await generateDocusaurusConfig(
            projectName,
            projectDescription || "",
          );
          break;
        case "mkdocs":
          configFiles = await generateMkDocsConfig(
            projectName,
            projectDescription || "",
          );
          break;
        case "hugo":
          configFiles = await generateHugoConfig(
            projectName,
            projectDescription || "",
          );
          break;
        case "jekyll":
          configFiles = await generateJekyllConfig(
            projectName,
            projectDescription || "",
          );
          break;
        case "eleventy":
          configFiles = await generateEleventyConfig(
            projectName,
            projectDescription || "",
          );
          break;
      }
  
      // Write all config files
      for (const file of configFiles) {
        const filePath = path.join(outputPath, file.path);
        await fs.mkdir(path.dirname(filePath), { recursive: true });
        await fs.writeFile(filePath, file.content);
      }
  
      const configResult = {
        ssg,
        projectName,
        projectDescription,
        outputPath,
        filesCreated: configFiles.map((f) => f.path),
        totalFiles: configFiles.length,
      };
  
      const response: MCPToolResponse<typeof configResult> = {
        success: true,
        data: configResult,
        metadata: {
          toolVersion: "1.0.0",
          executionTime: Date.now() - startTime,
          timestamp: new Date().toISOString(),
        },
        recommendations: [
          {
            type: "info",
            title: "Configuration Complete",
            description: `Generated ${configFiles.length} configuration files for ${ssg}`,
          },
        ],
        nextSteps: [
          {
            action: "Setup Documentation Structure",
            toolRequired: "setup_structure",
            description: `Create Diataxis-compliant documentation structure`,
            priority: "high",
          },
        ],
      };
  
      return formatMCPResponse(response);
    } catch (error) {
      const errorResponse: MCPToolResponse = {
        success: false,
        error: {
          code: "CONFIG_GENERATION_FAILED",
          message: `Failed to generate config: ${error}`,
          resolution: "Ensure output path is writable and SSG type is supported",
        },
        metadata: {
          toolVersion: "1.0.0",
          executionTime: Date.now() - startTime,
          timestamp: new Date().toISOString(),
        },
      };
      return formatMCPResponse(errorResponse);
    }
  }

• src/tools/generate-config.ts:6-11 (schema)

  Zod input schema defining parameters for SSG type, project details, and output path.

  const inputSchema = z.object({
    ssg: z.enum(["jekyll", "hugo", "docusaurus", "mkdocs", "eleventy"]),
    projectName: z.string(),
    projectDescription: z.string().optional(),
    outputPath: z.string(),
  });

• src/tools/generate-config.ts:158-160 (helper)

  Helper functions like generateDocusaurusConfig, generateMkDocsConfig, etc., that return arrays of {path, content} for specific SSG configurations.

  }
  
  async function generateDocusaurusConfig(