codecks-mcp

Instructions

Implementation Reference

• src/tools/registry.ts:191-222 (handler)

  The async handler function that executes the get_lane_registry tool. Filters lanes based on the required_only parameter and returns a structured response with lane definitions, count, required_lanes, and optional_lanes.

  async (args) => {
    let lanes = LANES;
    if (args.required_only) {
      lanes = lanes.filter((l) => l.required);
    }
  
    const laneDicts = lanes.map((l) => ({
      name: l.name,
      display_name: l.displayName,
      required: l.required,
      keywords: l.keywords,
      default_checklist: l.defaultChecklist,
      tags: l.tags,
      cli_help: l.cliHelp,
    }));
  
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(
            finalizeToolResult({
              lanes: laneDicts,
              count: laneDicts.length,
              required_lanes: LANES.filter((l) => l.required).map((l) => l.name),
              optional_lanes: LANES.filter((l) => !l.required).map((l) => l.name),
            }),
          ),
        },
      ],
    };
  },

• src/tools/registry.ts:182-223 (registration)

  Registration of the get_lane_registry tool with the MCP server, including title, description, and input schema.

  server.registerTool(
    "get_lane_registry",
    {
      title: "Get Lane Registry",
      description: "Get the local lane (deck category) definitions and metadata. No auth needed.",
      inputSchema: z.object({
        required_only: z.boolean().default(false).describe("If true, return only required lanes"),
      }),
    },
    async (args) => {
      let lanes = LANES;
      if (args.required_only) {
        lanes = lanes.filter((l) => l.required);
      }
  
      const laneDicts = lanes.map((l) => ({
        name: l.name,
        display_name: l.displayName,
        required: l.required,
        keywords: l.keywords,
        default_checklist: l.defaultChecklist,
        tags: l.tags,
        cli_help: l.cliHelp,
      }));
  
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(
              finalizeToolResult({
                lanes: laneDicts,
                count: laneDicts.length,
                required_lanes: LANES.filter((l) => l.required).map((l) => l.name),
                optional_lanes: LANES.filter((l) => !l.required).map((l) => l.name),
              }),
            ),
          },
        ],
      };
    },
  );

• src/tools/registry.ts:187-189 (schema)

  Input schema definition using Zod for the get_lane_registry tool, defining the optional required_only boolean parameter.

  inputSchema: z.object({
    required_only: z.boolean().default(false).describe("If true, return only required lanes"),
  }),

• src/tools/registry.ts:84-92 (schema)

  Type definition interface for LaneDefinition that defines the structure of lane objects used by get_lane_registry.

  interface LaneDefinition {
    name: string;
    displayName: string;
    required: boolean;
    keywords: string[];
    defaultChecklist: string[];
    tags: string[];
    cliHelp: string;
  }

• src/tools/registry.ts:94-131 (schema)

  LANES constant containing the lane registry data (code, design, art, audio) with their definitions that get_lane_registry returns.

  const LANES: LaneDefinition[] = [
    {
      name: "code",
      displayName: "Code",
      required: true,
      keywords: ["programming", "implementation", "backend", "frontend"],
      defaultChecklist: ["- [] Implementation", "- [] Unit tests", "- [] Code review"],
      tags: ["code"],
      cliHelp: "Destination deck for Code sub-cards",
    },
    {
      name: "design",
      displayName: "Design",
      required: true,
      keywords: ["ui", "ux", "wireframe", "mockup", "layout"],
      defaultChecklist: ["- [] Wireframes", "- [] Visual design", "- [] Design review"],
      tags: ["design"],
      cliHelp: "Destination deck for Design sub-cards",
    },
    {
      name: "art",
      displayName: "Art",
      required: false,
      keywords: ["sprite", "texture", "model", "animation", "illustration"],
      defaultChecklist: ["- [] Concept art", "- [] Asset creation", "- [] Art review"],
      tags: ["art"],
      cliHelp: "Destination deck for Art sub-cards (optional)",
    },
    {
      name: "audio",
      displayName: "Audio",
      required: false,
      keywords: ["sound", "music", "sfx", "voice"],
      defaultChecklist: ["- [] Sound design", "- [] Implementation", "- [] Audio review"],
      tags: ["audio"],
      cliHelp: "Destination deck for Audio sub-cards (optional)",
    },
  ];