coverage

Languages & the code knowledge database.

squeezy reads the languages below on your own machine and keeps a database of what your code declares and what refers to what. Questions about your code are answered from that database instead of by reading whole files into the prompt.

contents

contents

What squeezy can answer about your code

For every language listed below, squeezy indexes your files into a code knowledge database: the things your project declares, and the links between them. It is built from your code on your machine, nothing is uploaded to build it, and it keeps up as you edit.

Each of these is one lookup rather than a hunt through files.

  • Where a symbol is defined. By name, or by an id carried over from an earlier answer.
  • What refers to it, what calls it, and what it calls. Callers and callees can be walked several hops out, not only one.
  • What a module or class contains. The whole member roster in one answer, instead of a read per member.
  • What a type inherits from, and which types inherit from it. The whole chain, not only the first generation, and which subtypes override a given method.
  • What a change would affect. The files, symbols, and tests downstream of an edit, taken from a symbol you name or from the diff you already have.
  • Which symbol is at a position. A line, a column, or a byte offset resolves to the symbol around it, so a compiler error or a search hit becomes a starting point.
  • A signature on its own, or a body on its own. The model gets the lines that matter instead of the file around them.

squeezy is not a compiler and does not type-check your project. It reads structure, which is why every relationship it reports carries a confidence label: an exact match is marked differently from one candidate among several, and an answer that a macro or a build flag makes uncertain says so rather than reading as fact. When completeness matters more than precision, squeezy says so too, and falls back to plain text search.

Files in any other language still work. They fall back to bounded search, targeted reads, and shell commands, and squeezy lists them as unsupported instead of reporting a lookup it never made. What follows is the full supported list, grouped so it scans.

Systems & application languages

Compiled, statically typed code, with the project layout its ecosystem uses: Cargo workspaces, Maven and Gradle projects, C# solutions, Go modules, SwiftPM modules, and Dart pubspec packages.

C

Headers, includes, structs, functions, typedefs, macros, and references.

C++

Headers, namespaces, classes, templates, methods, and overload-heavy code.

C#

Solutions, namespaces, usings, partial types, attributes, and members.

Dart

Pubspec package identity, libraries, parts, classes, mixins, extensions, and named arguments in Flutter-style projects.

Go

Modules, packages, structs, interfaces, receivers, imports, and tests.

Java

Packages, Maven/Gradle projects, classes, members, and inheritance.

Kotlin

Packages, Gradle projects, classes, objects, companions, and extensions.

Objective-C

Interfaces, implementations, categories, protocols, selector-named methods, properties, and #import header dependencies.

Rust

Cargo workspaces, crates, traits, impls, modules, and tests.

Scala

Packages, traits, objects, case classes, enums, and extension methods.

Swift

SwiftPM modules with enforced visibility, protocols, actors, structs, extensions, and property wrappers.

Scripting & dynamic languages

Dynamic languages and the script surfaces around them, including shell, PowerShell, Gradle and Jenkins build scripts, and Godot game scripts.

GDScript

Godot scripts: class_name global types, inner classes, funcs, signals, enums, exported vars, and preload/extends resource dependencies.

Groovy

Packages, imports, classes, traits, enums, and methods, plus Gradle build scripts and Jenkins pipelines with `apply from:` script dependencies.

JavaScript

ES modules, CommonJS, functions, classes, exports, and JSX.

Lua

Module tables, dot and colon declarations, literal require paths, and chunk-local scope.

PHP

Namespaces, Composer-style code, traits, enums, attributes, and methods.

Perl

Packages, subs, `use`/`require` module loads resolved against @INC-style paths, and method calls walked through @ISA when the invocant is known.

PowerShell

Scripts, script modules, manifests, dot-sourced and imported files, functions, classes, and enums.

Python

Packages, imports, classes, functions, decorators, and inheritance.

R

Function bindings, globals, S4/reference/R6 class idioms, package attaches, and the source() closure that decides what a script can call.

Ruby

Classes, modules, mixins, singleton methods, accessors, and require paths.

Shell

Scripts, functions, commands, and executable shell entry points.

TypeScript

Types, interfaces, imports, generics, classes, and TSX.

Functional languages

Module-first languages where what a name refers to follows imports, aliases, and open or include directives rather than the file's path.

Clojure

Namespaces, requires resolved through the classpath munge, vars, protocols, records, multimethods, and .clj/.cljc/.cljs/.edn files.

Elixir

Modules resolved by fully-qualified name rather than path, alias and import directives expanded at the call site, and remote versus local call scope.

Haskell

Modules and their export lists, imports with qualification and hiding, data and newtype declarations, constructors, record selectors, type classes, instances, and where-bound helpers.

OCaml

Compilation units as modules, functors, module types, records and variants, and open/include scope resolved in the caller's own lexical scope. Signature files are indexed as declarations in their own right, never as definitions competing with the implementation they constrain.

Web & UI

Markup, stylesheets, and single-file components, where a component's script block and the template that renders it are indexed together.

Astro

Pages and layouts, frontmatter TypeScript, component imports, and rendered component references.

CSS

Selectors, classes, IDs, keyframes, and stylesheet structure.

HTML

Elements, IDs, classes, tags, and document structure.

Svelte

Components, script-block declarations, component imports, and template component references.

Vue

Single-file components, script-block declarations, component imports, and template component references.

Config, data & interface definitions

The formats a repository's wiring lives in. Keys, resources, catalog objects, and messages are indexed as declarations, and the references between files resolve like any other import.

HCL/Terraform

Terraform modules, resources, variables, locals, traversals, and generic HCL blocks.

Nix

Attribute sets, let bindings, inherited attributes, lambdas, and relative path imports across packages, modules, and flakes.

Protobuf

Packages, messages, enums, services and their rpcs, oneofs, fields, and imports resolved against include roots.

SQL

Schemas, tables, columns, views, routines, indexes, and triggers, with queries bound to the catalog objects they touch.

YAML

Mapping keys as nested declarations, anchors and aliases, and relative file references between workflows, manifests, and compose files.

Docs & markup

Prose formats, indexed for headings, anchors, and cross-references so documentation is navigable next to the code it describes.

AsciiDoc

Section titles, anchors, inline references, and documentation structure.

Markdown

Headings, sections, links, symbol references, and documentation structure.

Plain Text

Indexed text file roots for navigation and search.

reStructuredText

Underline sections, Sphinx cross-reference roles, and inline literals.

How a file gets classified

Usually by file extension. Compound endings are matched as one unit, so a .d.ts is indexed as TypeScript and a .rst.txt as reStructuredText rather than as a plain text file. Files with no extension at all are covered by name, so nothing useful is skipped for lacking a suffix: Gemfile, Rakefile, Podfile, Brewfile, and Vagrantfile are indexed as Ruby, Jenkinsfile as Groovy, and shell startup files such as .bashrc and .zshrc as Shell.

Where an extension is genuinely ambiguous, squeezy asks for evidence instead of guessing. A script with no extension is classified from a fixed list of shebang interpreters. Endings that several ecosystems share, such as .pl and .t, are indexed only when the start of the file shows which language wrote them. A .h header is decided by the C, C++, or Objective-C sources sitting beside it. A file that stays inconclusive is left out of the database and treated like any other unsupported file: still readable, still searchable, but not indexed.

Every indexed file also carries a role beside its language: implementation, test, configuration, DSL, stub, interface, and a few more. The role is separate from the grammar, which is what lets a Ruby Gemfile and a Ruby library file share a parser without being treated as the same kind of input.

How deep the coverage goes

Coverage is not uniform, and it is checked by language family: usually one language, sometimes a few close relatives indexed together. Where an outside authority for a family exists, squeezy is graded against it rather than against its own expectations: Rust against rust-analyzer, Python against CPython's own parser, Java against javac, C# against Roslyn, C and C++ against clang, JavaScript and TypeScript against the TypeScript compiler, and the same arrangement for Go, Ruby, PHP, Swift, Scala, and Dart. Every other family except the documentation formats is held to a checked-in fixture project with its own navigation questions and expected answers. The documentation formats have neither, and are covered by per-format extraction tests and doc-linking tests instead.

The benchmark page carries a measured cost result for 15 of these languages. squeezy answers the coverage question offline as well: squeezy help languages at a shell, or /help languages in a session, prints every supported language family from the registry inside the binary you installed.

Of the rows above, four sets are one family rather than one language apiece: C with C++, JavaScript with TypeScript, Astro with Svelte and Vue, and the four documentation formats (Markdown, AsciiDoc, reStructuredText, and Plain Text) together. Everything else stands on its own.

the contents list reaches every page in the docs
github

Repository access is under construction.

squeezy's repository is not public yet. The product site and documentation are available here in the meantime.