apply_prompt_infra

Instructions

Implementation Reference

• mcp_hitchcode/server.py:343-366 (handler)

  The core handler function that takes infrastructure_info, renders the 'infra' prompt template using render_prompt_template, and returns it as TextContent.

  async def apply_prompt_infra(
      infrastructure_info: str,
      specific_instructions: str = "",
      version: str = "latest",
  ) -> list[types.TextContent]:
      """
      Provides a prompt template for laying out system infrastructure and tool stack information.
  
      Args:
          infrastructure_info: Description of the infrastructure and tool stack.
          specific_instructions: Optional specific instructions to include in the prompt.
          version: The version of the prompt template to use. Defaults to "latest".
  
      Returns:
          A list containing a TextContent object with the prompt.
      """
      # Render the prompt template with the infrastructure info and specific instructions
      response_text = render_prompt_template(
          "infra",
          version_str=version,
          objective=infrastructure_info,
          specific_instructions=specific_instructions,
      )
      return [types.TextContent(type="text", text=response_text)]

• mcp_hitchcode/server.py:747-768 (registration)

  Registration of the tool in the list_tools() function, including name, description, and input schema definition.

  types.Tool(
      name="apply_prompt_infra",
      description="Provides a prompt template for laying out system infrastructure and tool stack information",
      inputSchema={
          "type": "object",
          "required": ["infrastructure_info"],
          "properties": {
              "infrastructure_info": {
                  "type": "string",
                  "description": "Description of the infrastructure and tool stack",
              },
              "specific_instructions": {
                  "type": "string",
                  "description": "Optional specific instructions to include in the prompt",
              },
              "version": {
                  "type": "string",
                  "description": "The version of the prompt template to use (e.g., '1.0.0', '1.1.0', or 'latest')",
              },
          },
      },
  ),

• mcp_hitchcode/server.py:750-766 (schema)

  Input schema defining the parameters for the tool: required infrastructure_info, optional specific_instructions and version.

  inputSchema={
      "type": "object",
      "required": ["infrastructure_info"],
      "properties": {
          "infrastructure_info": {
              "type": "string",
              "description": "Description of the infrastructure and tool stack",
          },
          "specific_instructions": {
              "type": "string",
              "description": "Optional specific instructions to include in the prompt",
          },
          "version": {
              "type": "string",
              "description": "The version of the prompt template to use (e.g., '1.0.0', '1.1.0', or 'latest')",
          },
      },

• mcp_hitchcode/templates/template_loader.py:278-342 (helper)

  Key helper function used by the handler to load the specific version of the 'infra' prompt template from the prompts directory and render it with Jinja2 using the provided variables.

  def render_prompt_template(
      template_name: str, version_str: str = "latest", **kwargs: Any
  ) -> str:
      """
      Render a prompt template with the given variables.
  
      Args:
          template_name: The name of the prompt template.
          version_str: The version of the template to use. Defaults to "latest".
          **kwargs: The variables to pass to the template.
  
      Returns:
          str: The rendered prompt template.
  
      Raises:
          FileNotFoundError: If the template file does not exist.
          jinja2.exceptions.TemplateError: If there is an error rendering the template.
          ValueError: If the specified version does not exist.
      """
      _build_version_registry()
  
      # Check if the template exists
      if template_name not in _version_registry:
          raise FileNotFoundError(f"Template not found: {template_name}")
  
      # Resolve the version
      if version_str == "latest":
          version_str = _version_registry[template_name].get("latest")
          if not version_str:
              raise ValueError(f"No versions found for template: {template_name}")
      elif version_str not in _version_registry[template_name]:
          # Try to find the closest version
          available_versions = get_template_versions(template_name)
          if not available_versions:
              raise ValueError(f"No versions found for template: {template_name}")
  
          # Find the highest version that is less than or equal to the requested version
          requested_ver = version.parse(version_str)
          for v in available_versions:
              if version.parse(v) <= requested_ver:
                  version_str = v
                  break
          else:
              # If no suitable version is found, use the oldest version
              version_str = available_versions[-1]
  
      # Get the filename from the registry
      filename = _version_registry[template_name][version_str]
  
      # Build the template path
      template_path = f"prompts/{template_name}/{filename}"
  
      # Load the template content
      content = load_template(template_path)
  
      # Parse the metadata and template content
      metadata, template_content = _parse_template_metadata(content)
  
      # Create a new template with just the content (without the front matter)
      env = get_template_env()
      template = env.from_string(template_content)
  
      # Render the template
      return template.render(**kwargs)