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 }; }