get_shortcuts

Instructions

Implementation Reference

• src/handlers.ts:4-38 (handler)

  The handler function that executes the get_shortcuts tool: filters relevant shortcut data by OS/desktop/app, queries the Opus client with the natural language query, and returns the response as tool content.

  export async function handleGetShortcuts(
    params: GetShortcutsParams,
    dataStore: DataStore,
    opusClient: OpusClient
  ): Promise<{ content: Array<{ type: string; text: string }> }> {
    // Filter data based on parameters
    const relevantData = dataStore.getByFilters({
      os: params.os,
      desktop: params.desktop,
      application: params.application,
    });
  
    if (relevantData.length === 0) {
      return {
        content: [
          {
            type: 'text',
            text: `No shortcut data found for: OS=${params.os}${params.desktop ? `, Desktop=${params.desktop}` : ''}${params.application ? `, App=${params.application}` : ''}`,
          },
        ],
      };
    }
  
    // Query Opus with filtered data
    const response = await opusClient.queryShortcuts(params.query, relevantData);
  
    return {
      content: [
        {
          type: 'text',
          text: response,
        },
      ],
    };
  }

• src/index.ts:20-25 (schema)

  Zod schema for input validation of get_shortcuts tool parameters.

  const GetShortcutsParamsSchema = z.object({
    os: z.string().describe('Operating system (e.g., ubuntu, macos, windows)'),
    query: z.string().describe('Natural language query about keyboard shortcuts'),
    desktop: z.string().optional().describe('Desktop environment (e.g., gnome, kde)'),
    application: z.string().optional().describe('Specific application (e.g., firefox, tmux)'),
  });

• src/types.ts:21-26 (schema)

  TypeScript interface defining the input parameters for the get_shortcuts tool.

  export interface GetShortcutsParams {
    os: string;
    query: string;
    desktop?: string;
    application?: string;
  }

• src/index.ts:41-72 (registration)

  Registers the get_shortcuts tool in the ListToolsRequestHandler, providing name, description, and inputSchema.

  server.setRequestHandler(ListToolsRequestSchema, async () => {
    return {
      tools: [
        {
          name: 'get_shortcuts',
          description: 'Query keyboard shortcuts for a specific OS, desktop environment, and/or application. Uses Claude Opus to intelligently search and return relevant shortcuts based on natural language queries.',
          inputSchema: {
            type: 'object',
            properties: {
              os: {
                type: 'string',
                description: 'Operating system (e.g., ubuntu, macos, windows)',
              },
              query: {
                type: 'string',
                description: 'Natural language query about keyboard shortcuts (e.g., "how do I split a pane vertically?")',
              },
              desktop: {
                type: 'string',
                description: 'Desktop environment (e.g., gnome, kde) - optional',
              },
              application: {
                type: 'string',
                description: 'Specific application (e.g., firefox, tmux) - optional',
              },
            },
            required: ['os', 'query'],
          },
        },
      ],
    };
  });

• src/index.ts:75-82 (registration)

  Dispatches tool calls to get_shortcuts by validating arguments with the schema and invoking the handleGetShortcuts function.

  server.setRequestHandler(CallToolRequestSchema, async (request) => {
    if (request.params.name === 'get_shortcuts') {
      const params = GetShortcutsParamsSchema.parse(request.params.arguments) as GetShortcutsParams;
      return handleGetShortcuts(params, dataStore, opusClient);
    }
  
    throw new Error(`Unknown tool: ${request.params.name}`);
  });