Skip to content

v1.0.0 — First Stable Release

Released: 2025-04-14

The first production-ready release. Canopy now ships a complete codebase intelligence engine: AST parsing, dependency graph queries, health checks, a plugin system, git ingestion, coverage ingestion, SCIP import, and full-text keyword search — all reachable via 21 MCP tools and 11 CLI commands. Everything in this release is under the API stability guarantee.

Added

Section titled “Added”

MCP Server and Tools

Section titled “MCP Server and Tools”
  • 21 MCP tools reachable over JSON-RPC 2.0 stdio, grouped into seven categories:
    • AST — canopy_parse_file, canopy_extract_symbol
    • Graph — canopy_trace_imports, canopy_trace_dependents, canopy_check_wiring, canopy_find_cycles, canopy_dependency_graph
    • Health — canopy_health_check, canopy_architecture_map
    • Index — canopy_index_status, canopy_reindex
    • Search — canopy_search, canopy_search_symbols, canopy_pattern_search
    • Git — canopy_git_history, canopy_git_blame
    • Workflow composites — canopy_prepare, canopy_validate, canopy_understand
    • Ingest — canopy_ingest_scip, canopy_coverage
  • Server instructions at handshake — the MCP initialize response injects usage rules directly into the connected agent’s system prompt. Agents learn to call canopy_prepare before edits and canopy_validate after without being explicitly told.
  • Panic-safe dispatch — every tool call is wrapped in catch_unwind so a panic in one handler returns a structured JSON-RPC error instead of crashing the server.

CLI

Section titled “CLI”
  • 11 subcommands: index, reindex, serve, status, search, pattern, health, map, ingest-scip, ingest-coverage, git-blame
  • canopy serve --watch — background file-system watcher triggers incremental re-index on every save

Language Support

Section titled “Language Support”

Five languages fully supported across the AST extractor, graph, and symbol search:

  • TypeScript / JavaScript — functions, classes, interfaces, types, enums, variables; ES module imports/exports plus CommonJS require; tsconfig.json path mapping
  • Python — functions, classes, decorators; import and from ... import statements
  • Rust — functions, structs, enums, traits, impls, type aliases, constants; use declarations with full path resolution (super, crate, relative); pub items
  • Go — functions, types, structs, interfaces, methods; import blocks; exported identifiers

Storage and Indexing

Section titled “Storage and Indexing”
  • SQLite backend via rusqlite — files, symbols, imports, health_findings, chunks tables
  • Config layering — built-in defaults → ~/.canopy/config.toml (global) → <repo>/.canopy/config.toml (per-repo), last-wins
  • Full and incremental indexing — incremental walks file mtime and content hash; only changed files are re-parsed
Section titled “Search”
  • Tantivy-powered full-text index with camelCase/snake_case tokenization — searching “payment” finds processPayment, payment_handler, PaymentService
  • Symbol-name search across all indexed files with kind and language filters
  • Structural pattern search via ast-grep with $VAR and $$$SPREAD wildcards

Plugins

Section titled “Plugins”
  • Plugin system — extend health checks with project-specific rules in .canopy/plugins/*.yaml
  • Plugin YAML schema (frozen as of this release): id, name, description, severity (info/warning/error/critical), pattern (ast-grep), language, include/exclude glob lists
  • Plugins are discovered automatically on every canopy health run and canopy_health_check MCP call

Git and Coverage

Section titled “Git and Coverage”
  • forge-git crate — pure-Rust git history and blame via gix. Walks commit history into SQLite; per-file, per-line-range blame queries; hotspot analysis surfaces recently modified files in canopy_prepare
  • Coverage ingestion — auto-detects LCOV, Istanbul JSON, and Cobertura XML by file extension. Coverage line ranges are joined to symbol definitions so every symbol shows its test state in canopy_prepare and canopy_understand

SCIP

Section titled “SCIP”
  • forge-ingest crate — SCIP index ingestion via prost. Upgrades heuristic import edges to compiler-resolved edges. Available via the canopy_ingest_scip MCP tool and canopy ingest-scip CLI command

Distribution

Section titled “Distribution”
  • Cross-platform release builds — Linux x86-64, Linux ARM64, macOS (Intel and Apple Silicon)
  • Dockerfile — multi-stage: rust:slim builder + debian:bookworm-slim runtime
  • docker-compose.yml — containerized canopy serve for quick MCP setup

Stability Guarantee

Section titled “Stability Guarantee”

This release establishes the public API. The following interfaces are frozen:

  • 21 MCP tool signatures — parameter names, types, and return shapes
  • 11 CLI subcommand flags and output formats
  • Plugin YAML schema — id, name, description, severity, pattern, language, include, exclude

Breaking changes require a major version bump. New optional parameters and new commands are non-breaking (minor bump).

Known Limitations

Section titled “Known Limitations”
  • Only TypeScript, JavaScript, Python, Rust, and Go are supported. C, C++, Java, Ruby, PHP, and C# are planned for future minor releases.
  • Embeddings and semantic search are not included in v1.0.0. They ship in v1.1.0.
  • No commercial licensing, heartbeat, or trial system yet — v1.0.0 runs freely with all features enabled. Licensing and tiering land in v1.2.0.