opsmith-cli 0.1.2a0__py3-none-any.whl

opsmith/deployer.py

@@ -0,0 +1,236 @@
+from enum import Enum
+from pathlib import Path
+from typing import List, Optional
+
+import yaml
+from pydantic import BaseModel, Field
+from rich import print
+
+from opsmith.agent import AgentDeps, ModelConfig, build_agent
+from opsmith.cloud_providers.base import CloudProviderDetail
+from opsmith.prompts import (
+    DOCKERFILE_GENERATION_PROMPT_TEMPLATE,
+    REPO_ANALYSIS_PROMPT_TEMPLATE,
+)
+from opsmith.repo_map import RepoMap
+from opsmith.settings import settings
+from opsmith.spinner import WaitingSpinner
+
+
+class ServiceTypeEnum(str, Enum):
+    """Enum for the different types of services that can be deployed."""
+
+    BACKEND_API = "BACKEND_API"
+    FRONTEND = "FRONTEND"
+    FULL_STACK = "FULL_STACK"
+    BACKEND_WORKER = "BACKEND_WORKER"
+
+
+class DependencyTypeEnum(str, Enum):
+    """Enum for the different types of infrastructure dependencies."""
+
+    DATABASE = "DATABASE"
+    CACHE = "CACHE"
+    MESSAGE_QUEUE = "MESSAGE_QUEUE"
+    SEARCH_ENGINE = "SEARCH_ENGINE"
+
+
+class InfrastructureDependency(BaseModel):
+    """Describes an infrastructure dependency for a service."""
+
+    dependency_type: DependencyTypeEnum = Field(
+        ..., description="The type of the infrastructure dependency."
+    )
+    provider: str = Field(
+        ...,
+        description=(
+            "The specific provider of the dependency (e.g., 'postgresql', 'redis', 'rabbitmq',"
+            " 'elasticsearch')."
+        ),
+    )
+    version: Optional[str] = Field(
+        None, description="The version of the infrastructure dependency, if identifiable."
+    )
+
+
+class EnvVarConfig(BaseModel):
+    """Describes an environment variable configuration for a service."""
+
+    key: str = Field(..., description="The name of the environment variable.")
+    is_secret: bool = Field(
+        ..., description="Whether the environment variable should be treated as a secret."
+    )
+    default_value: Optional[str] = Field(
+        None,
+        description="The default value of the environment variable, if present in the code.",
+    )
+
+
+class ServiceInfo(BaseModel):
+    """Describes a single service to be deployed."""
+
+    language: str = Field(..., description="The primary programming language of the service.")
+    language_version: Optional[str] = Field(
+        None, description="The specific version of the language, if identifiable."
+    )
+    service_type: ServiceTypeEnum = Field(..., description="The type of the service.")
+    framework: Optional[str] = Field(
+        None, description="The primary framework or library used, if any."
+    )
+    build_tool: Optional[str] = Field(
+        None,
+        description=(
+            "The build tool used for the service, if identifiable (e.g., 'maven', 'gradle', 'npm',"
+            " 'webpack')."
+        ),
+    )
+    infra_deps: List[InfrastructureDependency] = Field(
+        default_factory=list,
+        description="A list of infrastructure dependencies required by the services.",
+    )
+    env_vars: List[EnvVarConfig] = Field(
+        default_factory=list,
+        description="A list of environment variable configurations required by the service.",
+    )
+
+
+class ServiceList(BaseModel):
+    """List of services discovered within the repository."""
+
+    services: List[ServiceInfo] = Field(
+        ..., description="A list of services identified in the repository."
+    )
+
+
+class DeploymentConfig(ServiceList):
+    """Describes the deployment config for the repository, listing all services."""
+
+    app_name: str = Field(..., description="The name of the application.")
+    cloud_provider: CloudProviderDetail = Field(..., discriminator="name")
+
+
+class DockerfileContent(BaseModel):
+    """Describes the dockerfile response from the agent, including the generated Dockerfile content and reasoning for the selection."""
+
+    content: str = Field(
+        ...,
+        description="The final generated Dockerfile content.",
+    )
+    reason: Optional[str] = Field(
+        None, description="The reasoning for the selection of the final Dockerfile content."
+    )
+
+
+class Deployer:
+    def __init__(
+        self,
+        src_dir: str,
+        model_config: ModelConfig,
+        verbose: bool = False,
+        instrument: bool = False,
+    ):
+        self.deployments_path = Path(src_dir).joinpath(settings.deployments_dir)
+        self.config_file_name = "config.yml"
+        self.config_file_path = self.deployments_path / self.config_file_name
+        self.agent_deps = AgentDeps(src_dir=Path(src_dir))
+        self.agent = build_agent(model_config=model_config, instrument=instrument)
+        self.repo_map = RepoMap(
+            src_dir=src_dir,
+            verbose=verbose,
+        )
+        self.verbose = verbose
+
+    def save_deployment_config(self, deployment_config: DeploymentConfig):
+        """Saves the deployment configuration to a YAML file."""
+        self.deployments_path.mkdir(parents=True, exist_ok=True)
+        with open(self.config_file_path, "w") as f:
+            yaml.dump(deployment_config.model_dump(mode="json"), f, indent=2)
+        print(
+            f"\n[bold blue]Deployment configuration saved to: {self.config_file_path}[/bold blue]"
+        )
+
+    def get_deployment_config(self) -> Optional[DeploymentConfig]:
+        """Loads the deployment configuration from a YAML file."""
+        if not self.config_file_path.exists():
+            return None
+
+        with open(self.config_file_path, "r") as f:
+            config_data = yaml.safe_load(f)
+
+        if config_data:
+            return DeploymentConfig(**config_data)
+        else:
+            return None
+
+    def generate_dockerfiles(
+        self,
+    ):
+        """Generates Dockerfiles for each service in the deployment configuration."""
+        print("\n[bold blue]Starting Dockerfile generation...[/bold blue]")
+        deployment_config = self.get_deployment_config()
+
+        buildable_service_types = [
+            ServiceTypeEnum.BACKEND_API,
+            ServiceTypeEnum.FULL_STACK,
+            ServiceTypeEnum.BACKEND_WORKER,
+        ]
+
+        for idx, service in enumerate(deployment_config.services):
+            if service.service_type not in buildable_service_types:
+                print(
+                    f"\n[bold yellow]Dockerfile not needed for service {service.service_type},"
+                    " skipping.[/bold yellow]"
+                )
+                continue
+
+            service_name_slug = f"{service.language}_{service.service_type.value}".replace(
+                " ", "_"
+            ).lower()
+            service_dir_name = "images"
+            service_dir_path = self.deployments_path / service_dir_name / service_name_slug
+            service_dir_path.mkdir(parents=True, exist_ok=True)
+            dockerfile_path_abs = service_dir_path / "Dockerfile"
+            print(
+                f"\n[bold]Generating Dockerfile for service {idx + 1}:"
+                f" {service.language} ({service.service_type})...[/bold]"
+            )
+
+            service_info_yaml = yaml.dump(service.model_dump(mode="json"), indent=2)
+            prompt = DOCKERFILE_GENERATION_PROMPT_TEMPLATE.format(
+                service_info_yaml=service_info_yaml,
+                repo_map_str=self.repo_map.get_repo_map(),
+            )
+
+            response = self.agent.run_sync(
+                prompt, deps=self.agent_deps, output_type=DockerfileContent
+            )
+            dockerfile_content = response.output
+
+            # Write ensures the dockerfile content received from the agent to the deployments_dir.
+            with open(dockerfile_path_abs, "w", encoding="utf-8") as f:
+                f.write(dockerfile_content.content)
+            print(f"[green]Dockerfile saved to: {dockerfile_path_abs}[/green]")
+
+        print("\n[bold blue]Dockerfile generation complete.[/bold blue]")
+
+    def detect_services(self) -> ServiceList:
+        """
+        Scans the repository to determine the services to be deployed, using the AI agent.
+
+        Generates a repository map, then uses an AI agent with a file reading tool
+        to identify services and their characteristics.
+
+        Returns:
+            A ServiceList object detailing the services to be deployed.
+        """
+        repo_map_str = self.repo_map.get_repo_map()
+        if self.verbose:
+            print("Repo map generated:")
+
+        prompt = REPO_ANALYSIS_PROMPT_TEMPLATE.format(repo_map_str=repo_map_str)
+
+        print("Calling AI agent to analyse the repo and determine the services...")
+        with WaitingSpinner(text="Waiting for the LLM", delay=0.1):
+            run_result = self.agent.run_sync(prompt, output_type=ServiceList, deps=self.agent_deps)
+
+        return run_result.output

opsmith/git_repo.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+from typing import List
+
+import git
+import typer
+from rich import print
+
+
+class GitRepo:
+    def __init__(self, root_dir: Path):
+        """
+        Initialize a Git repository object for the specified directory, or its parent directories
+        if it is a subdirectory, ensuring it belongs to an actual Git repository. If the provided
+        directory is not within a Git repository, it exits the program with an error.
+
+        :param root_dir: The root directory or subdirectory intended for Git repository initialization.
+        :type root_dir: Path
+
+        :raises git.exc.InvalidGitRepositoryError: If the specified directory or its parent directories
+            do not contain a valid Git repository.
+        :raises typer.Exit: Exits the program if the directory is not part of a valid Git repository.
+        """
+        try:
+            # Initialize repo object, searching upwards from root_dir if it's a subdirectory
+            self.repo = git.Repo(str(root_dir), search_parent_directories=True)
+
+        except git.exc.InvalidGitRepositoryError:
+            print("[bold red]Not a git repository or git is not found in PATH[/bold red].")
+            raise typer.Exit()
+
+    def get_git_tracked_files(self, src_dirs: List[str]) -> List[Path]:
+        """
+        Retrieves a list of absolute file paths that are tracked by Git within the
+        specified source directories.
+
+        The function searches for files tracked by Git within the provided directories,
+        respecting the .gitignore file. If there are no tracked files, an empty list
+        is returned. The file paths returned are converted into absolute paths relative
+        to the Git repository's root directory.
+
+        :param src_dirs: List of source directories (as strings) to scan for Git-tracked
+                         files.
+        :type src_dirs: List[str]
+
+        :return: A list of absolute file paths for files tracked by Git within the
+                 specified source directories.
+        :rtype: List[Path]
+        """
+        # Searching upwards from root_dir if it's a subdirectory
+        git_root = Path(self.repo.working_dir)
+
+        # List tracked, cached, and other files (respecting .gitignore)
+        # The paths are relative to the git_root.
+        ls_files_args = ["-c", "--exclude-standard"]
+        ls_files_args.extend(src_dirs)
+
+        tracked_files_str = self.repo.git.ls_files(*ls_files_args)
+
+        if not tracked_files_str:  # Handle case where there are no tracked files
+            return []
+
+        relative_paths = tracked_files_str.strip().split("\n")
+
+        # Construct absolute paths and filter out potential empty strings from split
+        absolute_paths = [git_root / p for p in relative_paths if p]
+        return absolute_paths

opsmith/main.py

@@ -0,0 +1,269 @@
+import os
+from typing import Annotated, Optional
+
+import inquirer
+import logfire
+import typer
+import yaml
+from rich import print
+
+from opsmith.agent import AVAILABLE_MODELS_XREF, ModelConfig
+from opsmith.cloud_providers import CLOUD_PROVIDER_REGISTRY
+from opsmith.cloud_providers.base import CloudCredentialsError, CloudProviderEnum
+from opsmith.deployer import Deployer, DeploymentConfig  # Import the new Deployer class
+from opsmith.repo_map import RepoMap
+
+app = typer.Typer()
+
+
+def parse_model_arg(model: str) -> ModelConfig:
+    """
+    Fetches the configuration corresponding to the given model name.
+
+    Attempts to retrieve the configuration for the provided model from
+    the mapping of available models. If the model name is not found in
+    the mapping, an error is raised indicating that the model is unsupported.
+
+    :param model: The name of the model for which the configuration is required.
+    :type model: str
+
+    :return: The configuration corresponding to the provided model name.
+    :rtype: ModelConfig
+
+    :raises KeyError: If the given model name is not found in the available models mapping.
+    :raises typer.BadParameter: If the provided model name is unsupported.
+    """
+    try:
+        return AVAILABLE_MODELS_XREF[model]
+    except KeyError:
+        raise typer.BadParameter(
+            f"Unsupported model name: {model}, must be one of: {AVAILABLE_MODELS_XREF.keys()}"
+        )
+
+
+def api_key_callback(ctx: typer.Context, value: str):
+    """
+    This function serves as a callback for validating and processing an API key when
+    used in conjunction with a command-line interface. The function checks whether
+    the mandatory `--model` option is set before associating it with the provided
+    API key. If validation passes, it ensures the API key authentication process
+    is triggered for the specified model configuration.
+
+    Raises a BadParameter error if `--model` was not supplied before `--api-key`.
+
+    :param ctx: The Typer context object that contains information about the
+        current command execution context, including provided options and other
+        runtime parameters.
+    :type ctx: typer.Context
+    :param value: The API key provided by the user via the `--api-key` option
+        during the command-line execution.
+    :type value: str
+    :return: The validated API key after ensuring it is associated with the
+        specified model configuration.
+    :rtype: str
+    """
+    if "model" not in ctx.params:
+        raise typer.BadParameter("The --model option must be specified before --api-key.")
+    model_config = ctx.params["model"]
+    model_config.ensure_auth(value)
+    return value
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    model: Annotated[
+        ModelConfig,
+        typer.Option(
+            parser=parse_model_arg,
+            help="The LLM model to be used for by the AI Agent.",
+        ),
+    ],
+    api_key: Annotated[
+        str,
+        typer.Option(
+            callback=api_key_callback,
+            help=(
+                "The API KEY to be used for by the AI Agent. This is the API key for the specified"
+                " model."
+            ),
+        ),
+    ],
+    logfire_token: Optional[str] = typer.Option(
+        default=None,
+        help=(
+            "Logfire token to be used for logging. If not provided, logs will not be sent to"
+            " Logfire."
+        ),
+    ),
+    src_dir: Optional[str] = typer.Option(
+        default=None,
+        help="Source directory to be used by the command. Defaults to current working directory.",
+    ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Enable verbose output for repo map generation."
+    ),
+):
+    """
+    AI Devops engineer in your terminal.
+    """
+    if logfire_token:
+        logfire.configure(token=logfire_token, scrubbing=False)
+    ctx.obj = {
+        "deployer": Deployer(
+            src_dir=src_dir or os.getcwd(),
+            model_config=model,
+            verbose=verbose,
+            instrument=bool(logfire_token),
+        )
+    }
+
+
+@app.command()
+def setup(ctx: typer.Context):
+    """
+    Setup the deployment configuration for the repository.
+    Identifies services, their languages, types, and frameworks.
+    """
+    deployer = ctx.obj["deployer"]
+    deployment_config = deployer.get_deployment_config()
+
+    cloud_details = None
+    current_provider_name = None
+    services = []
+    services_updated = False
+    is_update = bool(deployment_config)
+    app_name = None
+
+    if is_update:
+        print("\n[bold yellow]Existing deployment configuration found.[/bold yellow]")
+        print("\n[bold green]Current Deployment Configuration:[/bold green]")
+        print(yaml.dump(deployment_config.model_dump(mode="json")))
+
+        update_answers = inquirer.prompt(
+            [
+                inquirer.Confirm(
+                    "update", message="Do you want to update the configuration?", default=True
+                )
+            ]
+        )
+        if not update_answers or not update_answers.get("update"):
+            print("Skipping configuration update.")
+            return
+
+        # Pre-fill with existing data
+        app_name = deployment_config.app_name
+        cloud_details = deployment_config.cloud_provider
+        current_provider_name = deployment_config.cloud_provider.name
+        services = deployment_config.services
+    else:
+        print("No existing deployment configuration found. Starting analysis...")
+
+    app_name_questions = [
+        inquirer.Text("app_name", message="Enter the application name", default=app_name),
+    ]
+    app_name_answers = inquirer.prompt(app_name_questions)
+    if not app_name_answers or not app_name_answers.get("app_name"):
+        print("[bold red]Application name is required. Aborting.[/bold red]")
+        raise typer.Exit(code=1)
+    app_name = app_name_answers["app_name"]
+
+    # Cloud Provider Selection
+    provider_questions = [
+        inquirer.List(
+            "cloud_provider",
+            message="Select the cloud provider for deployment",
+            choices=[provider.value for provider in CloudProviderEnum],
+            default=current_provider_name,
+        ),
+    ]
+    provider_answers = inquirer.prompt(provider_questions)
+    if not provider_answers:
+        print("[bold red]Cloud provider selection is required. Aborting.[/bold red]")
+        raise typer.Exit(code=1)
+
+    selected_provider_value = provider_answers["cloud_provider"]
+    selected_provider_enum = CloudProviderEnum(selected_provider_value)
+
+    # Get cloud details if new or changed
+    if not is_update or selected_provider_enum.name != current_provider_name:
+        print(f"Initializing {selected_provider_enum.name} provider...")
+        provider_class = CLOUD_PROVIDER_REGISTRY[selected_provider_enum]
+        try:
+            provider_instance = provider_class()
+            cloud_details = provider_instance.get_account_details()
+        except CloudCredentialsError as e:
+            print(f"[bold red]Cloud provider authentication/configuration error:\n{e}[/bold red]")
+            raise typer.Exit(code=1)
+        except Exception as e:
+            print(
+                "[bold red]An unexpected error occurred while initializing cloud provider or"
+                f" fetching details: {e}. Aborting.[/bold red]"
+            )
+            raise typer.Exit(code=1)
+
+    # Service Detection
+    if is_update:
+        service_questions = [
+            inquirer.Confirm(
+                "update_services", message="Do you want to re-scan for services?", default=False
+            )
+        ]
+        service_answers = inquirer.prompt(service_questions)
+        if service_answers and service_answers.get("update_services"):
+            services_updated = True
+    else:  # New config, so we must scan
+        services_updated = True
+
+    if services_updated:
+        print("Scanning your codebase now to detect services, frameworks, and languages...")
+        service_list_obj = deployer.detect_services()
+        services = service_list_obj.services
+
+    # Create/Update and Save Configuration
+    final_deployment_config = DeploymentConfig(
+        app_name=app_name,
+        cloud_provider=cloud_details,
+        services=services,
+    )
+    deployer.save_deployment_config(final_deployment_config)
+
+    if is_update:
+        print("\n[bold green]Deployment configuration updated:[/bold green]")
+    else:
+        print("\n[bold green]Created Deployment Configuration:[/bold green]")
+    print(yaml.dump(final_deployment_config.model_dump(mode="json")))
+
+    # Generate Dockerfiles if services were changed
+    if services_updated:
+        print("\n[bold blue]Services were updated. Generating Dockerfiles...[/bold blue]")
+        deployer.generate_dockerfiles()
+
+
+@app.command()
+def deploy(ctx: typer.Context):
+    """"""
+    pass
+
+
+@app.command()
+def repomap(ctx: typer.Context):
+    """
+    Generates a map of the repository, showing important files and code elements.
+    """
+    print("Generating repo map now...")
+    if ctx.parent.params["src_dir"]:
+        current_dir_str = ctx.parent.params["src_dir"]
+    else:
+        current_dir_str = os.getcwd()
+
+    repo_mapper = RepoMap(
+        src_dir=current_dir_str,
+        verbose=ctx.parent.params["verbose"],
+    )
+    repo_map_str = repo_mapper.get_repo_map()
+
+    if repo_map_str:
+        typer.echo(repo_map_str)
+    else:
+        typer.echo("No git-tracked files found in this repository or failed to generate map.")

opsmith/prompts.py

@@ -0,0 +1,76 @@
+REPO_ANALYSIS_PROMPT_TEMPLATE = """
+You are an expert DevOps engineer. Your task is to analyze the provided repository
+and identify all distinct services that need to be deployed.
+
+First, review the repository map provided below to get an overview of the project structure,
+key files, and important symbols.
+
+{repo_map_str}
+
+Based on this map and the content of relevant files (which you can request using the
+'read_file_content' tool), identify the services. For each service, determine:
+1.  `language`: The primary programming language of the service (e.g., "python", "javascript", "java").
+2.  `language_version`: The specific version of the language, if identifiable (e.g., "3.9", "17", "ES2020").
+3.  `service_type`: The type of the service. Must be one of: "backend_api", "backend_worker", "frontend", "full_stack".
+4.  `framework`: The primary framework or library used, if any (e.g., "django", "react", "spring boot", "celery").
+5.  `build_tool`: The build tool used for the service, if identifiable (e.g., "maven", "gradle", "npm", "webpack", "pip", "poetry").
+6.  `infra_deps`: A list of infrastructure dependencies required by the service. For each dependency, specify:
+    *   `dependency_type`: The type of the dependency. Must be one of: "database", "cache", "message_queue", "search_engine".
+    *   `provider`: The specific provider of the dependency (e.g., "postgresql", "redis", "rabbitmq", "elasticsearch").
+    *   `version`: The version of the dependency, if identifiable.
+7.  `env_vars`: A list of environment variable configurations required by the service. For each variable, specify:
+    *   `key`: The name of the environment variable.
+    *   `is_secret`: A boolean indicating if the variable should be treated as a secret (e.g., contains API keys, passwords, or other sensitive information).
+    *   `default_value`: The default value for the variable, if one is provided in the code.
+
+Return the information as a list of services.
+* Read the dependencies list from files like `requirements.txt`, `package.json`, `pom.xml`, `build.gradle`, etc., to get an idea of potential frameworks and infrastructure dependencies.
+* Do not rely on the repository map and dependency information alone; read relevant files such as entry points to figure out the services.
+* Look for configuration files or code that initializes connections to databases, caches, message queues, or search engines.
+* Scan the code for environment variable usage (e.g., `os.environ.get` in Python, `process.env` in Node.js or settings files) to identify required configurations. Keywords like 'SECRET', 'KEY', 'TOKEN', 'PASSWORD' in the variable name often indicate a secret.
+* Read as many files as needed until you are sure about the service and infrastructure dependency details.
+"""
+
+DOCKERFILE_GENERATION_PROMPT_TEMPLATE = """
+You are an expert DevOps engineer. Your task is to generate a Dockerfile for the
+service described below.
+
+Service Details:
+{service_info_yaml}
+
+Repository Map:
+{repo_map_str}
+
+Your task is to generate an optimized and production-ready Dockerfile for this service.
+After generating the Dockerfile content, you MUST validate it using the `build_dockerfile` tool.
+The `build_dockerfile` tool will first attempt to build the image. If the build is successful,
+it will then attempt to run the image.
+
+Analyze the output from `build_dockerfile`:
+1.  If the **build fails** (indicated by errors in the build output), revise the Dockerfile
+    content based on the error messages and try building again by calling `build_dockerfile`
+    with the updated content.
+2.  If the **build succeeds but running the image fails**, examine the run output.
+    -   If the failure is due to issues like **missing packages, command not found, file not found
+        within the container, or incorrect entrypoint/cmd**, revise the Dockerfile to fix these
+        issues and call `build_dockerfile` again.
+    -   If the failure is due to **missing environment variables, inability to connect to external
+        services (like databases or other APIs), port conflicts, or similar runtime configuration
+        issues that are not part of the Dockerfile's direct responsibility for package installation
+        or command execution**, you can consider the Dockerfile itself valid for this stage.
+Repeat this process until the Dockerfile builds successfully and, if it runs, does not fail due to
+fixable Dockerfile issues (like missing packages or commands).
+
+Ensure the final Dockerfile:
+- Uses an appropriate base image.
+- Copies only necessary files.
+- Sets up the correct working directory.
+- Installs dependencies efficiently.
+- Exposes the correct port (if applicable for the service type, e.g., backend-api, frontend, full_stack).
+- Defines the correct entrypoint or command.
+- Follows Docker best practices (e.g., multi-stage builds if beneficial, non-root user).
+
+Once the Dockerfile is successfully validated (built and, if run, passed the runtime checks for fixable errors)
+with the `build_dockerfile` tool, return only the final, validated Dockerfile content.
+If more information is required at any stage, use the `read_file_content` tool.
+"""

opsmith/queries/tree-sitter-languages/README.md

@@ -0,0 +1,7 @@
+These scm files are all adapted from the github repositories listed here:
+
+https://github.com/Goldziher/tree-sitter-language-pack/blob/main/sources/language_definitions.json
+
+See this URL for information on the licenses of each repo:
+
+https://github.com/Goldziher/tree-sitter-language-pack/

opsmith/queries/tree-sitter-languages/arduino-tags.scm

@@ -0,0 +1,5 @@
+(function_declarator
+  declarator: (identifier) @name.definition.function) @definition.function
+
+(call_expression
+  function: (identifier) @name.reference.call) @reference.call

opsmith/queries/tree-sitter-languages/c-tags.scm

@@ -0,0 +1,9 @@
+(struct_specifier name: (type_identifier) @name.definition.class body:(_)) @definition.class
+
+(declaration type: (union_specifier name: (type_identifier) @name.definition.class)) @definition.class
+
+(function_declarator declarator: (identifier) @name.definition.function) @definition.function
+
+(type_definition declarator: (type_identifier) @name.definition.type) @definition.type
+
+(enum_specifier name: (type_identifier) @name.definition.type) @definition.type