cellar

Cellar

使用 cellar 查询 JVM 依赖项的 API，而不要靠猜测，也不要手动下载、解压并搜索 JAR 文件来查找类型签名。

前置条件

运行 cellar --version，确认 cellar 已加入 PATH。如果找不到，则需要安装： https://github.com/VirtusLab/cellar#installation

项目感知命令（在项目根目录运行）

查询当前项目的代码及其所有依赖项。Cellar 会自动检测构建工具（Mill、sbt、scala-cli）。

cellar get [--module <name>] <fqn>       # 单个符号（签名、成员、文档）
cellar list [--module <name>] <package>  # 列出包或类中的符号
cellar search [--module <name>] <query>  # 不区分大小写的子串搜索

• Mill/sbt 项目：必须指定 --module（例如 --module lib、--module core）
• scala-cli 项目：省略 --module
• --test：查询测试作用域的类路径（sbt/scala-cli；对于 Mill，直接使用测试模块，例如 --module foo.test）
• --no-cache：跳过类路径缓存，改为从构建工具重新提取
• --java-home <path>：覆盖 JRE 类路径
• -l、--limit <N>：list/search 的结果数量上限（默认：50）
• --hide-inherited：仅显示类型自身声明的成员（get 命令）
• --group-inherited：按声明类型分组成员，并添加分节标题（get 命令）
• -v、--verbose / --debug：将诊断信息输出到 stderr。若预期的符号被报告为未找到，请使用此选项：get 命令中的 --verbose 会列出尝试过的查找策略，而 --debug 会在任何命令中添加解析后的类路径和构建工具检测信息。

外部命令（查询任意 Maven 坐标）

通过明确的坐标（group:artifact:version）查询任何已发布的构件：

cellar get-external <coordinate> <fqn>       # 单个符号
cellar list-external <coordinate> <package>  # 列出符号
cellar search-external <coordinate> <query>  # 按名称搜索
cellar get-source <coordinate> <fqn>         # 获取源代码
cellar deps <coordinate>                     # 依赖树

• 坐标必须明确指定：group:artifact_3:version（不能使用 :: 简写）
• 对于 sbt 插件，请使用完整的 Scala 和 sbt 后缀：group:artifact_2.12_1.0:version（例如 org.scala-native:sbt-scala-native_2.12_1.0:latest）
• 对于编译器插件及其他带完整 Scala 版本后缀的构件，请使用完整版本：group:artifact_3.3.8:version
• 将版本指定为 latest，以解析最新发布版本
• -r、--repository <url>：额外的 Maven 仓库（可重复指定），会追加到 ~/.cellar/cellar.conf 或 .cellar/cellar.conf 中 maven.repositories 配置的仓库之后

工作流

1. 不知道包名？ → cellar search / cellar search-external
2. 知道包名，不知道类型？ → cellar list / cellar list-external
3. 知道类型？ → cellar get / cellar get-external
4. 需要实现代码？ → cellar get-source

示例

# Look up a Scala 3 trait
cellar get-external org.typelevel:cats-core_3:2.10.0 cats.Monad

# Look up a Java class
cellar get-external org.apache.commons:commons-lang3:3.14.0 org.apache.commons.lang3.StringUtils

# List a package
cellar list-external io.circe:circe-core_3:0.14.6 io.circe

# Search for a method
cellar search-external org.typelevel:cats-core_3:2.10.0 flatMap

# Get source code
cellar get-source org.typelevel:cats-core_3:2.10.0 cats.Monad

# Dependency tree
cellar deps org.typelevel:cats-effect_3:3.5.4

# sbt plugin (use full Scala + sbt suffix)
cellar deps org.scala-native:sbt-scala-native_2.12_1.0:latest

# Project-aware (from a Mill project root)
cellar get --module lib cats.Monad
cellar list --module core cats
cellar search --module lib flatMap

示例输出

cellar get-external --hide-inherited org.typelevel:cats-core_3:2.10.0 cats.Monad

## cats.Monad
```scala
trait Monad[F[_]] extends FlatMap[F] with Applicative[F]
```
**Supertypes:** cats.Applicative, cats.InvariantMonoidal, cats.FlatMap, cats.FlatMapArityFunctions, cats.Apply, cats.ApplyArityFunctions, cats.InvariantSemigroupal, cats.Semigroupal, cats.Functor, cats.Invariant, java.io.Serializable

Monad.
Allows composition of dependent effectful functions.
See: [[http://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/baastad.pdf Monads for functional programming]]
Must obey the laws defined in cats.laws.MonadLaws.

**Origin:** cats.Monad
**Members:**
```scala
def iterateWhile[A](f: F[A])(p: A => Boolean): F[A]
def untilM[G[_], A](f: F[A])(cond: => F[Boolean])(implicit G: Alternative[G]): F[G[A]]
def ifElseM[A](branches: (F[Boolean], F[A])*)(els: F[A]): F[A]
def iterateUntilM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
def map[A, B](fa: F[A])(f: A => B): F[B]
def whileM_[A](p: F[Boolean])(body: => F[A]): F[Unit]
def whileM[G[_], A](p: F[Boolean])(body: => F[A])(implicit G: Alternative[G]): F[G[A]]
def untilM_[A](f: F[A])(cond: => F[Boolean]): F[Unit]
def iterateUntil[A](f: F[A])(p: A => Boolean): F[A]
def iterateWhileM[A](init: A)(f: A => F[A])(p: A => Boolean): F[A]
```
**Companion members:**
```scala
trait Ops[F[_], A] extends Serializable
object ops
def apply[F[_]](implicit instance: Monad[F]): Monad[F]
trait ToMonadOps extends Serializable
object nonInheritedOps extends ToMonadOps
trait AllOps[F[_], A] extends Ops[F, A] with FlatMap.AllOps[F, A] with Applicative.AllOps[F, A]
```

**Supertypes:** 会按线性化顺序列出所有祖先，这是成员查找所遵循的顺序。

选择成员输出方式

• 默认：列出该类型可调用的所有成员，包括继承的成员。用于查找可调用的内容。
• --hide-inherited：仅列出该类型自身声明的成员。用于查看子类型新增的内容，或在完整输出过长时使用。
• --group-inherited：在 // Declared on / // Inherited from 标题下列出成员。需要了解成员由哪个父类型声明时使用，例如查看其文档或确定要重写什么。

同时可以使用 Metals MCP 时

对于外部依赖 API 查询，仅优先使用 cellar（cellar get-external 与 Metals 的 inspect/get-docs 相比）：cellar 无需导入项目，适用于任何已发布的 Maven 坐标。对于所有其他任务——跳转到定义、查找引用、重命名、诊断和编译——使用 Metals。

输出

• stdout：Markdown，可直接使用
• stderr：诊断信息（警告、截断提示）
• Exit 0：成功，Exit 1：错误