Clear Thought Server

Instructions

Implementation Reference

• src/tools/programmingParadigmServer.ts:64-93 (handler)

  Main execution logic for the 'programmingparadigm' tool, processing input, validating, formatting output, and returning structured JSON response.

  public processParadigm(input: unknown): { content: Array<{ type: string; text: string }>; isError?: boolean } {
    try {
      const validatedInput = this.validateParadigmData(input);
      const formattedOutput = this.formatParadigmOutput(validatedInput);
      console.error(formattedOutput);
  
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            paradigmName: validatedInput.paradigmName,
            status: 'success',
            hasApproach: validatedInput.approach.length > 0,
            hasCodeExample: !!validatedInput.codeExample
          }, null, 2)
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            error: error instanceof Error ? error.message : String(error),
            status: 'failed'
          }, null, 2)
        }],
        isError: true
      };
    }
  }

• src/index.ts:117-172 (schema)

  Tool definition including name, description, and detailed inputSchema for the 'programmingparadigm' tool.

  const PROGRAMMING_PARADIGM_TOOL: Tool = {
      name: "programmingparadigm",
      description: `A tool for applying different programming paradigms to solve problems.
  Supports various programming paradigms including:
  - Imperative Programming
  - Procedural Programming
  - Object-Oriented Programming
  - Functional Programming
  - Declarative Programming
  - Logic Programming
  - Event-Driven Programming
  - Aspect-Oriented Programming
  - Concurrent Programming
  - Reactive Programming
  
  Each paradigm provides a different approach to structuring and executing code.`,
      inputSchema: {
          type: "object",
          properties: {
              paradigmName: {
                  type: "string",
                  enum: [
                      "imperative",
                      "procedural",
                      "object_oriented",
                      "functional",
                      "declarative",
                      "logic",
                      "event_driven",
                      "aspect_oriented",
                      "concurrent",
                      "reactive",
                  ],
              },
              problem: { type: "string" },
              approach: {
                  type: "array",
                  items: { type: "string" },
              },
              benefits: {
                  type: "array",
                  items: { type: "string" },
              },
              limitations: {
                  type: "array",
                  items: { type: "string" },
              },
              codeExample: { type: "string" },
              languages: {
                  type: "array",
                  items: { type: "string" },
              },
          },
          required: ["paradigmName", "problem"],
      },
  };

• src/index.ts:1070-1082 (registration)

  MCP server request handler registration that dispatches 'programmingparadigm' tool calls to the paradigmServer.processParadigm method.

  case "programmingparadigm": {
      const result = paradigmServer.processParadigm(
          request.params.arguments
      );
      return {
          content: [
              {
                  type: "text",
                  text: JSON.stringify(result, null, 2),
              },
          ],
      };
  }

• src/models/interfaces.ts:37-45 (schema)

  TypeScript interface defining the data structure for programming paradigm inputs, used in validation.

  export interface ProgrammingParadigmData {
      paradigmName: string;
      problem: string;
      approach: string[];
      benefits: string[];
      limitations: string[];
      codeExample?: string;
      languages?: string[];
  }

• src/tools/programmingParadigmServer.ts:5-24 (helper)

  Helper function for input validation and type casting to ProgrammingParadigmData.

  private validateParadigmData(input: unknown): ProgrammingParadigmData {
    const data = input as Record<string, unknown>;
  
    if (!data.paradigmName || typeof data.paradigmName !== 'string') {
      throw new Error('Invalid paradigmName: must be a string');
    }
    if (!data.problem || typeof data.problem !== 'string') {
      throw new Error('Invalid problem: must be a string');
    }
  
    return {
      paradigmName: data.paradigmName as string,
      problem: data.problem as string,
      approach: Array.isArray(data.approach) ? data.approach.map(String) : [],
      benefits: Array.isArray(data.benefits) ? data.benefits.map(String) : [],
      limitations: Array.isArray(data.limitations) ? data.limitations.map(String) : [],
      codeExample: typeof data.codeExample === 'string' ? data.codeExample as string : undefined,
      languages: Array.isArray(data.languages) ? data.languages.map(String) : undefined
    };
  }