ontomics

Semantic concept lookup — returns all variants (including abbreviations like trf for transform), related concepts, naming conventions, function signatures, and file locations in one call. Richer than grep: querying 'transform' also finds 'trf', 'spatial_transform', 'apply_transform', and related concepts like 'displacement'. Use when asked 'what is X', 'what does X mean', or 'where is X used'.

Check if an identifier follows project naming conventions — detects inconsistencies like 'n_dims' vs the project's 'ndim' convention, or 'numFeatures' vs 'nb_features'. Returns a consistent/inconsistent verdict with the canonical form and suggestions. Use before committing new code or when reviewing identifier names.

Generate project-consistent identifier names from a natural language description. Uses the project's actual conventions (prefixes like nb_, patterns like is_/has_, conversion patterns like x_to_y) to suggest names that fit the existing codebase style. Use when naming new functions, variables, or parameters.

Compare the domain ontology between two git revisions — shows concepts that were added, removed, or changed. Useful for understanding how the project's vocabulary evolved across commits or for reviewing whether a PR introduced naming inconsistencies.

List the project's domain vocabulary ranked by importance — a semantic overview of what this codebase is about that reading individual files cannot provide. Returns concept names as a ranked list. Use query_concept or locate_concept to drill into any result. Use when asked 'what is this project about', 'what are the main concepts', or when orienting in an unfamiliar codebase.

List the project's actual naming conventions detected from code — prefix patterns (nb_, is_, has_), suffix patterns, conversion patterns (x_to_y), and casing rules, each with real examples from the codebase. More accurate than guessing from a few files. Use when asked about coding style, before writing new code, or when onboarding to a project.

Describe a function or class WITHOUT reading its source file — returns signature, parameters, callers, callees, and related domain concepts. Faster and more informative than Read for understanding what a symbol does and how it fits into the codebase. Use when asked 'what does function X do' or 'what is class X'.

Describe a file's structure WITHOUT reading it — returns classes, functions, and methods annotated with domain concepts and semantic roles. Use when you need to understand a file's shape, what symbols it contains, or what concepts it implements. Accepts partial paths (e.g. 'networks.py' matches 'src/networks.py'). Use describe_symbol to drill into any symbol shown.

Find the best entry points for understanding a concept — returns a ranked shortlist of key functions, classes, and files to read, plus contrastive concepts that clarify boundaries. Saves reading dozens of grep matches by surfacing the most important locations first. Use when asked 'how does X work', 'where should I look for X', or 'where are X defined'.

Export the project's full domain knowledge as a portable YAML pack — abbreviations, conventions, domain terms, and concept associations. Use when asked to 'export conventions', 'create a domain pack', or 'share naming rules'. The output can be reviewed, curated, and saved for use in other projects or tools.

Find all classes and functions matching a concept — e.g. all loss functions, all network architectures, all transform utilities. Returns entity names with their domain concept tags. Use describe_symbol to drill into any result. Impossible with grep alone because it understands which functions implement a concept, not just mention it. Use when asked 'what loss functions exist', 'show me the network classes', 'what uses concept X', or 'list all X'.

Measure the vocabulary health of this codebase — returns convention coverage (how many identifiers follow conventions), consistency ratio (how uniformly concepts are spelled), and cluster cohesion (how well semantic clusters hold together). Use when asked about code quality, naming consistency, or vocabulary health. Returns an overall score plus top inconsistencies and uncovered identifiers.

Trace how a domain concept flows through the codebase via function call chains — shows which functions produce the concept, which consume it, and the call path between them including bridge functions on the path. Returns an ordered call chain with file locations and producer/ consumer roles. Use when asked 'how does concept X propagate', 'what calls what for X', or 'trace X through the code'.

Describe the behavioral logic of a function or class — returns the raw function body, logic cluster membership (which other entities behave similarly), and structural centrality (PageRank importance in the dependency graph). Use when asked 'what does this function do internally', 'how does X work at a high level', or 'what is the logic of X'.

Find entities with similar behavioral patterns — uses logic embeddings to find functions/classes that do similar things regardless of naming. Returns similarity scores. Use when asked 'what other functions do the same thing', 'find similar implementations', or 'what behaves like X'.

Assemble minimal, token-efficient context for a concept, entity, or file — combines function body + structural summary + domain concepts + logic cluster into a compact text block suitable for LLM prompt injection. Much smaller than full source while preserving behavioral and structural information. Use when assembling context for another LLM, when asked to 'summarize X compactly', or when building prompts about codebase entities.

Semantic topology of the codebase — shows which directories concentrate which domain concepts, with entity counts and concept density. Use as a first call to understand codebase layout before drilling into specific concepts or symbols.

Trace how types flow through the codebase along call edges. Shows which types dominate the data pipeline and how they propagate between functions. Returns all typed data-flow edges, dominant types ranked by frequency, and counts of typed vs untyped call edges.

Find all data-flow edges involving a specific type. Shows which functions pass and receive this type through call edges. Use when asked 'where does Tensor flow', 'how is type X passed around', or 'which functions use type X'.