Claude Writer's Aid MCP

Instructions

Implementation Reference

• src/tools/WriterToolHandlers.ts:252-260 (handler)

  MCP tool handler: parses input arguments and delegates to WritersAid.checkTerminology with resolved pagination limit

  private async checkTerminology(args: Record<string, unknown>) {
    const scope = args.scope as string | undefined;
    const autoDetect = (args.auto_detect as boolean) ?? true;
    const terms = args.terms as string[] | undefined;
    const limit = resolvePaginationLimit("check_terminology", args.limit as number | undefined);
    const examplesPerVariant = (args.examples_per_variant as number) || 3;
  
    return this.writersAid.checkTerminology({ scope, autoDetect, terms, limit, examplesPerVariant });
  }

• src/tools/WriterToolDefinitions.ts:198-216 (schema)

  Tool schema definition with input schema for MCP registration

  {
    name: "check_terminology",
    description: "Find inconsistent term usage",
    inputSchema: {
      type: "object",
      properties: {
        project_path: { type: "string", description: "Path to manuscript directory (defaults to current directory)" },
        scope: { type: "string", description: "File scope pattern" },
        auto_detect: { type: "boolean", description: "Auto-detect variants", default: true },
        terms: {
          type: "array",
          items: { type: "string" },
          description: "Specific terms to check",
        },
        limit: { type: "number", description: "Maximum term groups to return", default: 20 },
        examples_per_variant: { type: "number", description: "Examples per term variant", default: 3 },
      },
    },
  },

• src/WritersAid.ts:198-206 (helper)

  WritersAid orchestrator method that delegates to TerminologyChecker

  async checkTerminology(options?: {
    scope?: string;
    autoDetect?: boolean;
    terms?: string[];
    limit?: number;
    examplesPerVariant?: number;
  }) {
    return this.terminologyChecker.checkTerminology(options || {});
  }

• src/analysis/TerminologyChecker.ts:36-58 (handler)

  Core terminology consistency checker: handles specific terms or auto-detection, computes variants and reports inconsistencies

  async checkTerminology(options: {
    scope?: string;
    autoDetect?: boolean;
    terms?: string[];
    limit?: number;
    examplesPerVariant?: number;
  }): Promise<TerminologyReport> {
    const { scope, autoDetect = true, terms, limit, examplesPerVariant = 3 } = options;
  
    if (terms && terms.length > 0) {
      return this.checkSpecificTerms(terms, scope, limit, examplesPerVariant);
    }
  
    if (autoDetect) {
      return this.autoDetectVariants(scope, limit, examplesPerVariant);
    }
  
    return {
      groups: [],
      totalIssues: 0,
      filesAffected: 0,
    };
  }