Skip to content
Back to search

compass

Native, local-first knowledge graph engine for code and project artifacts—inspired by Graphify, built in Rust, and evolving beyond it.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/crabbuild--compass/badge.svg)](/listings/crabbuild--compass)

HTML

<a href="/listings/crabbuild--compass"><img src="/api/listings/crabbuild--compass/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

On macOS or Linux, use the installer for Apple Silicon or Intel and AMD systems:

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/crabbuild/compass/releases/latest/download/install.sh | sh

On Windows, use the installer for x64 or ARM64 systems:

irm https://github.com/crabbuild/compass/releases/latest/download/install.ps1 | iex

For an offline install, download the matching archive and `.sha256` file from the [latest release](https://github.com/crabbuild/compass/releases/latest), verify the checksum, extract the archive, and add the directory to `PATH`.

To build from source, use the pinned Rust 1.97.1 or newer toolchain:

git clone https://github.com/crabbuild/compass.git
cd compass
cargo install --locked --path crates/compass-cli --bin compass

You can also use the repository installer:

make install

`make install` uses `~/.cargo/bin` when it exists. Otherwise, it creates and uses `~/.local/bin`. Set `BINDIR` when you want a different destination:

make install BINDIR="$HOME/bin"

Upgrade an installed Compass executable with `compass upgrade`.

Compass reads a bounded static release manifest, verifies the selected archive size and SHA-256 digest, and checks the staged executable version before replacement. The upgrade path does not use the rate-limited GitHub REST API. When no newer release exists, the command exits successfully and reports the installed version.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 467 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="apps/web/public/brand/compass-mark.svg" alt="Compass logo" width="128">
  3. </p>
  4. <h1 align="center">Compass</h1>
  5. <div align="center">
  6. <p><strong>Understand the shape of a codebase before you change it.</strong></p>
  7. <p>Compass is a local-first Rust workbench for architecture maps, dependency paths, impact analysis, and Git history.</p>
  8. <p>
  9. <a href="docs/getting-started.md">Get started</a> ·
  10. <a href="docs/README.md">Documentation</a> ·
  11. <a href="docs/roadmap.md">Roadmap</a> ·
  12. <a href="https://marketplace.visualstudio.com/items?itemName=crabbuild.crabbuild-compass-vscode">VS Code extension</a> ·
  13. <a href="https://github.com/crabbuild/compass/releases">Releases</a>
  14. </p>
  15. </div>
  16. <p align="center">
  17. <a href="https://github.com/crabbuild/compass/actions/workflows/compass-ci.yml"><img src="https://github.com/crabbuild/compass/actions/workflows/compass-ci.yml/badge.svg" alt="CI status"></a>
  18. <a href="https://github.com/crabbuild/compass/releases"><img src="https://img.shields.io/github/v/release/crabbuild/compass?display_name=tag&sort=semver" alt="Latest release"></a>
  19. <a href="https://github.com/crabbuild/compass/blob/main/LICENSE-MIT"><img src="https://img.shields.io/badge/license-MIT%20%2F%20Apache--2.0-4c8bf5" alt="MIT or Apache-2.0 license"></a>
  20. </p>
  21. Compass turns source code and project artifacts into a directed, queryable knowledge graph. It gives people and coding assistants a shared map of symbols, files, communities, relationships, and evidence.
  22. ```text
  23. large codebase
  24. |
  25. v
  26. Compass -----> architecture map
  27. | \-> dependency and impact answers
  28. | \-> exact CompassQL results
  29. | \-> historical graph diffs
  30. | \-> focused context for assistants
  31. v
  32. less searching, smaller context, traceable evidence
  33. ```
  34. ## What Compass gives you
  35. Compass covers the path from repository orientation to verified automation:
  36. | Need | Compass capability |
  37. | --- | --- |
  38. | Understand an unfamiliar repository | Communities, architecture reports, god-node detection, and interactive HTML |
  39. | Find implementation paths | Natural-language graph discovery, symbol explanations, and directed paths |
  40. | Estimate change impact | Reverse dependency traversal and version-to-version topology diffs |
  41. | Automate structural checks | Deterministic, read-only [CompassQL](docs/COMPASSQL.md) with JSON and JSONL output |
  42. | Ask questions about old revisions | Immutable graph realizations for exact Git commits |
  43. | Give assistants focused context | Native skills, hooks, MCP serving, and compact graph queries |
  44. | Connect other tools | Graph JSON, GraphML, SVG, Wiki, Obsidian, Neo4j, FalkorDB, and other exports |
  45. Structural extraction and graph queries run locally. They do not require Python, embeddings, a vector database, model credentials, or runtime parser downloads.
  46. ## See the graph before you open every file
  47. Compass exports a self-contained workbench. Move from a repository map to subsystem flow, call evidence, or bounded dependency neighborhoods without changing snapshots.
  48. <table>
  49. <tr>
  50. <td width="50%">
  51. <img src="docs/assets/screenshots/readme-ripgrep-architecture.png" alt="Compass architecture map of the ripgrep repository with subsystem call direction and source details" width="100%">
  52. <br><sub><strong>Architecture map · ripgrep</strong><br>Subsystem boundaries, call direction, and source-backed details.</sub>
  53. </td>
  54. <td width="50%">
  55. <img src="docs/assets/screenshots/readme-cli11-code-graph.png" alt="Compass code graph of the CLI11 repository with community filters and minimap" width="100%">
  56. <br><sub><strong>Repository map · CLI11</strong><br>Large-scale structure with communities, filters, and a minimap.</sub>
  57. </td>
  58. </tr>
  59. <tr>
  60. <td width="50%">
  61. <img src="docs/assets/screenshots/readme-ripgrep-call-graph.png" alt="Compass bounded call graph centered on ripgrep SearchWorker search" width="100%">
  62. <br><sub><strong>Call graph · ripgrep</strong><br>Follow callers, callees, direction, depth, and evidence coverage.</sub>
  63. </td>
  64. <td width="50%">
  65. <img src="docs/assets/screenshots/readme-ripgrep-dependencies.png" alt="Compass dependency lens for the ripgrep repository with community filters" width="100%">
  66. <br><sub><strong>Dependency lens · ripgrep</strong><br>Inspect bounded relationships while keeping the surrounding context visible.</sub>
  67. </td>
  68. </tr>
  69. </table>
  70. These are real Compass exports from public repositories, not product mockups: [BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep/tree/435f59fc4b43af3ab32f34d53fa34978f393fe52) and [CLIUtils/CLI11](https://github.com/CLIUtils/CLI11/tree/60492bddb50422f32cfa33c1365b96ebee4205ca). Counts and visible symbols reflect those exact revisions and will change as the projects evolve.
  71. ## Find the answer at the right scale
  72. | Question | Compass surface |
  73. | --- | --- |
  74. | Where does this subsystem live? | Communities, architecture flow, ownership, and source details |
  75. | Which areas need attention first? | Communities, architecture reports, god-node detection, and interactive HTML |
  76. | What calls this function? | Bounded caller and callee graphs with direction and depth controls |
  77. | What could this change affect? | Reverse dependency paths, affected nodes, and evidence limits |
  78. | Which files belong to this workflow? | Search, explanations, paths, and relationship filters |
  79. | How do I automate structural checks? | Deterministic, read-only [CompassQL](docs/COMPASSQL.md) with JSON and JSONL output |
  80. | What changed between revisions? | Immutable historical graphs and semantic diffs over exact Git commits |
  81. | How do assistants stay focused? | Native skills, hooks, MCP serving, and compact graph queries |
  82. | How do I share the result? | VS Code, self-contained HTML, JSON, GraphML, SVG, Wiki, Obsidian, Neo4j, FalkorDB, and MCP integrations |
  83. ## Start with one repository
  84. ### Install the CLI
  85. On macOS or Linux, use the installer for Apple Silicon or Intel and AMD systems:
  86. ```bash
  87. curl --proto '=https' --tlsv1.2 -LsSf \
  88. https://github.com/crabbuild/compass/releases/latest/download/install.sh | sh
  89. ```
  90. On Windows, use the installer for x64 or ARM64 systems:
  91. ```powershell
  92. irm https://github.com/crabbuild/compass/releases/latest/download/install.ps1 | iex
  93. ```
  94. For an offline install, download the matching archive and `.sha256` file from the [latest release](https://github.com/crabbuild/compass/releases/latest), verify the checksum, extract the archive, and add the directory to `PATH`.
  95. To build from source, use the pinned Rust 1.97.1 or newer toolchain:
  96. ```bash
  97. git clone https://github.com/crabbuild/compass.git
  98. cd compass
  99. cargo install --locked --path crates/compass-cli --bin compass
  100. ```
  101. You can also use the repository installer:
  102. ```bash
  103. make install
  104. ```
  105. `make install` uses `~/.cargo/bin` when it exists. Otherwise, it creates and uses `~/.local/bin`. Set `BINDIR` when you want a different destination:
  106. ```bash
  107. make install BINDIR="$HOME/bin"
  108. ```
  109. Upgrade an installed Compass executable with `compass upgrade`.
  110. Compass reads a bounded static release manifest, verifies the selected archive size and SHA-256 digest, and checks the staged executable version before replacement. The upgrade path does not use the rate-limited GitHub REST API. When no newer release exists, the command exits successfully and reports the installed version.
  111. ### Build the first graph
  112. ```bash
  113. cd your-project
  114. compass init
  115. ```
  116. `compass init` previews the eligible corpus, saves the project scope in `.compass/config.toml`, and performs the first structural build. Compass writes a coherent snapshot under `compass-out/`.
  117. For a focused monorepo scope, pass include and exclude patterns during initialization:
  118. ```bash
  119. compass init . --include src --include 'services/*/src' --exclude '**/generated/**' --yes
  120. ```
  121. ```text
  122. compass-out/
  123. ├── graph.json machine-readable graph
  124. ├── GRAPH_REPORT.md architecture and community summary
  125. ├── orientation.json bounded orientation for assistants
  126. ├── graph.html interactive visualization when size permits
  127. ├── manifest.json incremental build state
  128. ├── snapshots/ retained coherent build snapshots
  129. ├── current-snapshot selected snapshot identifier
  130. └── store/ SQLite query index when enabled
  131. ```
  132. After setup, `compass update` and `compass watch` reuse the saved scope automatically.
  133. Keep the graph current while you work:
  134. ```bash
  135. compass watch
  136. ```
  137. Run `compass watch` in a second terminal. It reuses the saved scope and refreshes the graph as files change.
  138. ### Put Compass in your daily loop
  139. Use Compass as a local context layer for coding assistants. The complete loop is:
  140. ```bash
  141. compass init
  142. compass install
  143. compass watch
  144. ```
  145. Run `compass watch` in a second terminal. For a focused task, an installed assistant starts with `compass query "your_question_here"`. For a first session or broad repository orientation, it reads the bounded Agent Orientation at the start of `compass-out/GRAPH_REPORT.md`, then runs a focused query.
  146. ### Ask a focused question
  147. ```bash
  148. compass query "where is authentication enforced?"
  149. compass query "where is authentication enforced?" --evidence
  150. compass query "where is authentication enforced?" --cursor 'query_cursor_token'
  151. compass explain TokenVerifier
  152. compass path ApiHandler TokenVerifier
  153. compass affected TokenVerifier --depth 3
  154. ```
  155. These commands read the saved graph locally. Results are bounded, read-only, and tied to graph evidence instead of a model-generated guess.
  156. Plain-language `query` uses bounded structured discovery. Its default text is a concise map of seeds, nodes, edges, and source locations; pass `--evidence` for full provenance and semantic digests. Each page contains complete deterministic entries within the `--text-budget` value, which defaults to 8,000. Follow `next=query_cursor_token` with the unchanged question and evidence tier until `next=none`.
  157. The cursor fails when semantic inputs, evidence tier, the selected graph, or the semantic result changes. Exact-looking symbol operands that do not resolve are reported as `NO EXACT MATCH` before any fuzzy or lexical fallback candidates. The `--traverse`, `--budget`, and `--page` options retain the legacy traversal contract; CompassQL uses its own versioned contract.
  158. ### Open the workbench
  159. ```bash
  160. compass export html
  161. ```
  162. Build several perspectives into one self-contained page:
  163. ```bash
  164. symbol_id="your_symbol_id"
  165. compass export html \
  166. --code-graph \
  167. --architecture-graph \
  168. --call-graph "$symbol_id" \
  169. --impact-graph "$symbol_id"
  170. ```
  171. The same workbench is available through the [Compass Codegraph extension for VS Code](https://marketplace.visualstudio.com/items?itemName=crabbuild.crabbuild-compass-vscode). Search for a symbol or file, select a node, inspect its evidence and relationships, then open the exact source location.
  172. The exported page and VS Code graph use the same workbench shell. Switch among code, call, impact, affected, architecture, history, and artifact views without losing the snapshot context.
  173. Use this sequence when you explore a graph:
  174. 1. Search for a symbol or file.
  175. 2. Select a node to inspect its source, signature, community, evidence, and relationships.
  176. 3. Open the source card, or double-click a located node, to jump to the exact code.
  177. 4. Filter communities or change the layout when you need a different level of detail.
  178. The graph toolbar includes an exploration panel for isolating a selected neighborhood up to four hops deep. Follow incoming, outgoing, or both edge directions, adjust layout spacing, and use the minimap to keep your place. Press `?` in the graph to see camera and exploration shortcuts.
  179. In VS Code, right-click inside a function to open callers, callees, impact, related symbols, or a path.
  180. ## Keep it local and traceable
  181. Compass is built for teams that need useful structure without handing a repository to a remote service.
  182. | Principle | What it means in practice |
  183. | --- | --- |
  184. | Native by default | Structural extraction and graph queries run in one Rust executable. They do not require Python, embeddings, a vector database, model credentials, or runtime parser downloads. |
  185. | Evidence first | Relationships retain direction, source anchors, and provenance. Ambiguous matches remain visible as uncertainty. |
  186. | Bounded by design | Query rows, paths, expansions, memory, and time stay within explicit limits. A limit is reported as a limit, not an empty result. |
  187. | History without rewriting | Historical realizations use exact Git commits and immutable fingerprints. Current and past graphs can be queried, exported, and compared. |
  188. Optional semantic workflows use a configured provider only when you select them. Read [Security and privacy](docs/design/security-and-privacy.md) before processing sensitive repositories.
  189. ## Connect your existing tools
  190. ### VS Code
  191. Install [Compass Codegraph](https://marketplace.visualstudio.com/items?itemName=crabbuild.crabbuild-compass-vscode), open a repository, and use the Compass sidebar to initialize or open the graph. Cursor-rooted call graphs, architecture flow, queries, and Git evolution use the same snapshot model.
  192. Read the [VS Code extension guide](docs/guides/vscode.md) for current graphs, cursor-rooted call graphs, architecture flow, queries, and exact Git evolution. You can also install the extension from a terminal:
  193. ```bash
  194. code --install-extension crabbuild.crabbuild-compass-vscode
  195. ```
  196. ### Coding assistants
  197. Install the portable Agent Skills integration or a host-specific adapter from the repository root:
  198. ```bash
  199. compass install
  200. compass install --platform codex
  201. compass install --platform codex --platform claude
  202. compass install --all --dry-run
  203. compass install --user --format json
  204. ```
  205. Inside a Git repository, `compass install` detects supported coding agents at the repository root and always includes the portable Agent Skills integration. Codex, Gemini CLI, OpenCode, Copilot, and generic Agent Skills clients share `.agents/skills/compass`; Claude Code, Kiro, and Cline use their native skill roots.
  206. Check `Selected` in the command output:
  207. 1. If your intended host appears, start a new assistant session.
  208. 2. If the output lists only `agents`, use an explicit `--platform` selection.
  209. 3. In Codex, review and trust the hook under `/hooks`.
  210. 4. In Gemini CLI, run `/skills reload` after installation.
  211. An explicit platform selection bypasses host detection. Installation configures the integration but does not build a graph.
  212. The integration starts with a bounded orientation or focused query, checks completeness and ambiguity, and opens only the cited source needed for verification. It uses `compass watch` in a second terminal, or reports `compass update .` as a refresh fallback.
  213. For a first session or broad repository orientation, the assistant reads only the bounded Agent Orientation at the start of `GRAPH_REPORT.md`, then runs a focused query. It checks direction, ambiguity, graph completeness, domain truncation, and pagination. Ambiguous seeds are retried by exact node ID.
  214. ```text
  215. focused task ───────────────> focused query
  216. first/broad orientation ────> bounded Agent Orientation ──> focused query
  217. |
  218. v
  219. inspect completion and the smallest cited source set
  220. ```
  221. Read the [assistant setup guide](docs/guides/assistant-setup.md) for supported platforms, scope, strict mode, upgrades, and uninstall.
  222. ### Graph exports and Model Context Protocol (MCP)
  223. Use `compass export` for machine-readable graph JSON, GraphML, SVG, Wiki, Obsidian, Neo4j, and FalkorDB workflows. Use [`compass serve`](docs/guides/integrating-compass.md) when you want graph resources and tools inside a compatible MCP client.
  224. Inspect the supported transports and authentication options before starting a server:
  225. ```bash
  226. compass serve --help
  227. ```
  228. The MCP surface exposes bounded graph resources and tools through the same local snapshot used by the CLI and VS Code. Read the [integration guide](docs/guides/integrating-compass.md) for transport setup, health checks, and client configuration.
  229. ### Program evidence
  230. Structural graphs are the default. Add the optional language-neutral Program Intermediate Representation (Program IR) when a workflow needs functions, conservative basic blocks, operations, call candidates, capability coverage, or derived summaries:
  231. ```bash
  232. compass update . --program
  233. compass program summary
  234. compass program coverage
  235. compass program functions --language rust --name build
  236. ```
  237. Native `init`, `update`, `extract`, and `watch` builds publish the structural graph by default. Pass `--program` when a workflow needs `program.json`; repeat `--program-artifact` to add offline evidence artifacts.
  238. The offline-first pipeline combines Tree-sitter syntax evidence for Rust and TypeScript-family languages with any Source Code Intelligence Protocol (SCIP) indexes already on disk. Compass does not invoke an indexer, compiler, language server, model, or network service to build this artifact.
  239. The schema `http://crab.build/compass/v1` reports each capability as `complete`, `partial`, `indeterminate`, or `failed`. Each non-complete state includes machine-readable reasons. Unresolved calls remain uncertainty; Compass never treats them as proof that no downstream target exists.
  240. Inspect or query the current artifact without custom JSON scripts:
  241. ```bash
  242. symbol_id="your_symbol_id"
  243. compass program summary
  244. compass program coverage
  245. compass program functions --language rust --name build
  246. compass program show "$symbol_id"
  247. compass program callers "$symbol_id"
  248. compass program explain-call src/lib.rs:240
  249. compass program query \
  250. "MATCH (f) WHERE f.kind = 'program_function' RETURN f LIMIT 20"
  251. ```
  252. Decoded indexes are cached by artifact digest. Freshness and normalization are invalidated per indexed document. Supply additional offline evidence with repeatable `--program-artifact path/to/index.scip` options.
  253. ## Compare history, not memory
  254. ```bash
  255. compass history enable --code-only
  256. compass history build main
  257. compass history build HEAD --profile-from main
  258. compass query "authentication" --at HEAD~20
  259. compass diff main HEAD
  260. compass diff main HEAD --format html --output semantic-diff.html
  261. ```
  262. Historical builds use exact Git commits and immutable extraction fingerprints. Current and historical graphs can be queried, compared, and exported without putting generated graph data into Git.
  263. `compass diff` surfaces likely breaks, behavior changes, affected callers and modules, test evidence, and known limitations in one offline report. Use `--all` to include routine symbol churn. Use `--limit number_of_findings` to raise the text display budget.
  264. HTML output is a self-contained interactive reviewer report. It includes semantic findings, an enhanced unified and split source diff, and a changed-subgraph view with exhaustive node and edge delta lists. The source view uses the pinned `@pierre/diffs` library and retains the exact Git patch as an offline fallback. HTML output requires an explicit `--output` path.
  265. Read the [versioned history guide](docs/guides/versioned-history.md) and [storage design](docs/design/storage-and-history.md) for retention, profiles, and compatibility details.
  266. ## Performance
  267. Compass maintains qualified performance baselines while preserving deterministic graph output and correctness. See [Performance qualification](PERFORMANCE.md) for the evidence policy and benchmark commands.
  268. ## How it works
  269. ![Compass graph construction and query pipeline](docs/assets/diagrams/graph-pipeline.svg)
  270. Compass discovers project files, extracts entities and relationships, resolves cross-file references, analyzes communities, and publishes one consistent snapshot.
  271. ```text
  272. function / class / file / document / schema object → node
  273. CALLS / IMPORTS_FROM / USES / CONTAINS → relationship
  274. dense group of related nodes → community
  275. direct / resolved / uncertain evidence → provenance
  276. ```
  277. The graph keeps relationship direction, source location, and provenance together:
  278. ```text
  279. CheckoutHandler
  280. |
  281. +-- CALLS [EXTRACTED] --> authorizePayment()
  282. | |
  283. | +-- USES --> PaymentGateway
  284. |
  285. +-- CALLS [INFERRED] --> reserveInventory()
  286. ```
  287. Read [How Compass works](docs/concepts/how-it-works.md) for the full pipeline and [Graph model](docs/concepts/graph-model.md) for the data contract.
  288. ## Query exact graph patterns with CompassQL
  289. CompassQL is a deterministic, read-only, parameterized, and resource-bounded openCypher subset:
  290. ```bash
  291. compass query --cql \
  292. "MATCH (caller)-[:CALLS]->(target)
  293. WHERE target.label = 'authorizePayment()'
  294. RETURN caller.id, target.id
  295. LIMIT 20" \
  296. --format json
  297. ```
  298. Read the [language contract](docs/COMPASSQL.md) and [support matrix](docs/COMPASSQL_SUPPORT.md) for syntax, limits, and machine-readable output.
  299. ## Choose the smallest mode that answers the question
  300. | Command | Network behavior | Best use |
  301. | --- | --- | --- |
  302. | `compass update .` | Local only | Normal source-code graph updates |
  303. | `compass extract . --code-only` | Local only | Explicit no-model extraction |
  304. | `compass extract . --code-only --cargo` | Local only | Code plus Cargo dependency edges |
  305. | `compass extract docs --backend …` | Configured provider | Semantic facts from supported documents and media |
  306. Compass gives explicit control over optional provider boundaries. Structural graph building remains local-first and independent of those providers.
  307. ## Project lineage and compatibility
  308. Compass is inspired by and modeled after [Graphify](https://github.com/Graphify-Labs/graphify), which established the workflow of extracting a codebase into a knowledge graph, analyzing communities, and querying focused context.
  309. Compass is now an independent product with its own Rust implementation, commands, configuration, artifacts, and test suite. It does not execute or depend on Graphify.
  310. ### Compass capabilities
  311. | Area | What Compass does |
  312. | --- | --- |
  313. | Runtime | Runs structural extraction and graph queries in one native Rust executable |
  314. | Exact queries | Provides CompassQL, a deterministic and bounded read-only openCypher subset |
  315. | Versioned graphs | Keeps immutable realizations for exact commits, historical queries, exports, and diffs |
  316. | Incremental operation | Reuses compatible unchanged extraction work and atomically publishes graph plus manifest |
  317. | Query safety | Enforces explicit row, path, expansion, memory, and time limits |
  318. | Native distribution | Links parsers and native implementations for supported graph, media, database, and service boundaries |
  319. Read [Compatibility](COMPATIBILITY.md) for Compass-owned contracts and [Migration from Graphify](MIGRATION.md) for the one-time hard cutover.
  320. ## Find your next page
  321. | You are… | Start here |
  322. | --- | --- |
  323. | Evaluating Compass | [Getting started](docs/getting-started.md) → [How it works](docs/concepts/how-it-works.md) |
  324. | Using or integrating Compass | [Documentation hub](docs/README.md) → [Cookbook](docs/cookbook/README.md) |
  325. | Extending the Rust workspace | [Architecture](docs/design/architecture.md) → [Workspace tour](docs/implementation/workspace-tour.md) |
  326. | Looking up an interface | [Commands](docs/reference/commands.md) → [Outputs](docs/reference/outputs.md) |
  327. | Tracking future direction | [Roadmap](docs/roadmap.md) |
  328. The [documentation hub](docs/README.md) links every concept, guide, design, implementation note, recipe, and reference. Start with the [guides](docs/README.md#complete-a-task) when you have a concrete task to complete.
  329. ## Community and contributing
  330. | Need | Destination |
  331. | --- | --- |
  332. | Usage question or idea | [GitHub Discussions](https://github.com/crabbuild/compass/discussions) |
  333. | Bug or actionable feature request | [GitHub Issues](https://github.com/crabbuild/compass/issues/new/choose) |
  334. | Security vulnerability | [Private vulnerability reporting](https://github.com/crabbuild/compass/security/advisories/new) |
  335. | Code or documentation contribution | [Contributing guide](CONTRIBUTING.md) |
  336. Development checks and architecture boundaries live in [CONTRIBUTING.md](CONTRIBUTING.md). Support and disclosure boundaries live in [SUPPORT.md](SUPPORT.md) and [SECURITY.md](SECURITY.md).
  337. ## License
  338. Compass's original work is dual-licensed under [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-APACHE). Third-party components retain their original licenses; see [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.