search_wiki

Instructions

Implementation Reference

• src/server.ts:220-241 (handler)

  Handler method that parses the search_wiki request args via WikiSearchRequestSchema, resolves organization/project, creates a client, and calls client.searchWiki(request). Returns results as formatted JSON.

  private async handleSearchWiki(args: any) {
    const request = WikiSearchRequestSchema.parse(args);
    const organization = request.organization || this.config.defaultOrganization;
    const project = request.project || this.config.defaultProject;
    
    if (!organization) {
      throw new Error('Organization is required either as parameter or in server configuration');
    }
    if (!project) {
      throw new Error('Project is required either as parameter or in server configuration');
    }
    
    const client = await this.getClient(organization, project);
    const results = await client.searchWiki(request);
    
    return {
      content: [{
        type: 'text',
        text: JSON.stringify(results, null, 2)
      }]
    };
  }

• src/azure-client.ts:64-151 (handler)

  Actual implementation of the wiki search logic. Builds a POST request to the Azure DevOps Search API endpoint (almsearch.dev.azure.com), sends the search text and optional wiki filter, and maps the response to WikiSearchResult objects.

  async searchWiki(request: WikiSearchRequest): Promise<WikiSearchResult[]> {
    if (!this.wikiApi || !this.connection) {
      throw new Error('Azure DevOps client not initialized');
    }
  
    try {
      const organization = request.organization || this.config.organization;
      const project = request.project || this.config.project;
      
      if (!organization || !project) {
        throw new Error('Organization and project must be provided');
      }
  
      const searchApiUrl = `https://almsearch.dev.azure.com/${organization}/${project}/_apis/search/wikisearchresults?api-version=7.1`;
      
      interface WikiSearchRequestBody {
        searchText: string;
        $skip: number;
        $top: number;
        includeFacets: boolean;
        filters?: {
          Wiki?: string[];
        };
      }
  
      const requestBody: WikiSearchRequestBody = {
        searchText: request.searchText,
        $skip: 0,
        $top: 100, // Default to 100 results
        includeFacets: false
      };
  
      // Add wiki filter if specified
      if (request.wikiId) {
        requestBody.filters = {
          Wiki: [request.wikiId]
        };
      }
  
      const response = await this.connection.rest.client.post(searchApiUrl, JSON.stringify(requestBody), {
        'Content-Type': 'application/json'
      });
      
      if (!response.message || response.message.statusCode !== 200) {
        throw new Error(`Search failed: HTTP ${response.message?.statusCode || 'Unknown'}`);
      }
  
      const responseBody = await response.readBody();
      if (!responseBody) {
        return [];
      }
  
      const data = JSON.parse(responseBody);
      
      if (!data.results || !Array.isArray(data.results)) {
        return [];
      }
  
      interface WikiSearchResultItem {
        fileName?: string;
        path?: string;
        url?: string;
        matches?: {
          content?: { text: string }[];
        };
        project?: {
          name: string;
        };
        wiki?: {
          name: string;
        };
      }
  
      return data.results.map((result: WikiSearchResultItem) => ({
        title: result.fileName || (result.path ? result.path.split('/').pop() || 'Unknown' : 'Unknown'),
        url: result.url || '',
        content: result.matches && result.matches.content 
          ? result.matches.content.map((match) => match.text).join(' ')
          : '',
        project: result.project?.name || project,
        wiki: result.wiki?.name || request.wikiId || 'Unknown',
        pagePath: this.formatPagePath(result.path || '')
      }));
  
    } catch (error) {
      throw new Error(`Failed to search wiki: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

• src/types.ts:3-8 (schema)

  Zod schema for search_wiki input validation. Defines fields: organization (optional string), project (optional string), searchText (required string), and wikiId (optional string).

  export const WikiSearchRequestSchema = z.object({
    organization: z.string().min(1).optional(),
    project: z.string().min(1).optional(),
    searchText: z.string().min(1),
    wikiId: z.string().optional(),
  });

• src/types.ts:43-50 (schema)

  WikiSearchResult TypeScript interface defining the output shape: title, url, content, project, wiki, and pagePath.

  export interface WikiSearchResult {
    title: string;
    url: string;
    content: string;
    project: string;
    wiki: string;
    pagePath: string;
  }

• src/server.ts:31-55 (registration)

  Registration of the search_wiki tool in the ListToolsRequestSchema handler, including its name, description, and inputSchema.

    name: 'search_wiki',
    description: 'Search across wiki content using Azure DevOps Search API',
    inputSchema: {
      type: 'object',
      properties: {
        organization: {
          type: 'string',
          description: 'Azure DevOps organization name'
        },
        project: {
          type: 'string',
          description: 'Project name'
        },
        searchText: {
          type: 'string',
          description: 'Search query string'
        },
        wikiId: {
          type: 'string',
          description: 'Optional specific wiki identifier'
        }
      },
      required: ['searchText']
    }
  },