npm - @tastehub/ckb-linux-arm64 - Versions diffs - 7.5.0 → 8.0.0 - Mend

@tastehub/ckb-linux-arm64 7.5.0 → 8.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/bin/README.md CHANGED Viewed

@@ -1,68 +1,103 @@
 # CKB — Code Knowledge Backend
+**Know your code. Change it safely. Ship with confidence.**
 [![npm version](https://img.shields.io/npm/v/@tastehub/ckb.svg)](https://www.npmjs.com/package/@tastehub/ckb)
-[![codecov](https://codecov.io/gh/SimplyLiz/CodeMCP/graph/badge.svg)](https://codecov.io/gh/SimplyLiz/CodeMCP)
 [![Documentation](https://img.shields.io/badge/docs-wiki-blue.svg)](https://github.com/SimplyLiz/CodeMCP/wiki)
-**The missing link between your codebase and AI assistants.**
+CKB transforms your codebase into a queryable knowledge base. Ask questions, understand impact, find owners, detect dead code—all through CLI, API, or AI assistants.
-CKB gives AI assistants deep understanding of your code. Instead of grepping through files, your AI can now *navigate* code like a senior engineer—with knowledge of who owns what, what's risky to change, and how everything connects.
+> Think of it as a senior engineer who knows every line of code, every decision, and every owner—available 24/7 to answer your questions.
-> CKB analyzes and explains your code but never modifies it. Think of it as a librarian who knows everything about the books but never rewrites them.
+---
-## The Problem
+## Instant Answers to Hard Questions
-### AI Assistants Are Blind to Code Structure
+| Question | Without CKB | With CKB |
+|----------|-------------|----------|
+| "What breaks if I change this?" | Grep and hope | Precise blast radius with risk score |
+| "Who should review this PR?" | Guess from git blame | Data-driven reviewer suggestions |
+| "Is this code still used?" | Delete and see what breaks | Confidence-scored dead code detection |
+| "What tests should I run?" | Run everything (30 min) | Run affected tests only (2 min) |
+| "How does this system work?" | Read code for hours | Query architecture instantly |
+| "Who owns this code?" | Search CODEOWNERS manually | Ownership with drift detection |
+| "Are there exposed secrets?" | Manual grep for patterns | Automated scanning with 26 patterns |
-When you ask an AI "what calls this function?", it typically:
-1. Searches for text patterns (error-prone)
-2. Reads random files hoping to find context (inefficient)
-3. Gives up and asks you to provide more context (frustrating)
+---
-### Existing Tools Don't Talk to Each Other
+## What You Can Do
-Your codebase has valuable intelligence scattered across SCIP indexes, language servers, git history, and CODEOWNERS files. Each speaks a different language. None are optimized for AI consumption.
+🔍 **Understand** — Semantic search, call graphs, usage tracing, architecture maps
-### Context Windows Are Limited
+⚡ **Analyze** — Impact analysis, risk scoring, hotspot detection, coupling analysis
-Even with 100K+ token context, you can't dump your entire codebase into an LLM. You need relevant information only, properly compressed, with smart truncation.
+🛡️ **Protect** — Affected test detection, breaking change warnings, PR risk assessment
-## What CKB Gives You
+🔐 **Secure** — Secret detection, credential scanning, security-sensitive code identification
-```
-You: "What's the impact of changing UserService.authenticate()?"
-CKB provides:
-├── Symbol details (signature, visibility, location)
-├── 12 direct callers across 4 modules
-├── Risk score: HIGH (public API, many dependents)
-├── Affected modules: auth, api, admin, tests
-├── Code owners: @security-team, @api-team
-└── Suggested drilldowns for deeper analysis
-```
+👥 **Collaborate** — Ownership lookup, reviewer suggestions, architectural decisions (ADRs)
-```
-You: "Show me the architecture of this codebase"
-CKB provides:
-├── Module dependency graph
-├── Key symbols per module
-├── Module responsibilities and ownership
-├── Import/export relationships
-└── Compressed to fit LLM context
-```
+📊 **Improve** — Dead code detection, tech debt tracking, documentation coverage
+🚀 **Compound Operations** — Single-call tools (`explore`, `understand`, `prepareChange`) reduce AI tool calls by 60-70%
+🔗 **Integrate** — CLI, HTTP API, MCP for AI tools, CI/CD pipelines, custom scripts
+---
+## Try It Now
+```bash
+# See what's risky in your codebase
+ckb hotspots
+# Check impact before changing code
+ckb impact diff
+# Find tests to run for your changes
+ckb affected-tests --output=command
+# Scan for exposed secrets
+ckb scan-secrets
+# Get reviewers for your PR
+ckb reviewers
+# Check architecture at a glance
+ckb arch
 ```
-You: "Is it safe to rename this function?"
-CKB provides:
-├── All references (not just text matches)
-├── Cross-module dependencies
-├── Test coverage of affected code
-├── Hotspot risk assessment
-└── Breaking change warnings
+---
+## Works Everywhere
+| AI Assistants | CI/CD | Your Tools |
+|---------------|-------|------------|
+| Claude Code, Cursor, Windsurf, VS Code | GitHub Actions, GitLab CI | CLI, HTTP API, Scripts |
+**83% token reduction** with smart presets—load only the tools you need.
+```bash
+# One command to connect to Claude Code
+ckb setup
 ```
+> **Building your own tools?** Use CKB as a backend via CLI, HTTP API, or MCP. See the **[Integration Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Integration-Guide)** for examples in Node.js, Python, Go, and shell scripts.
+---
+## Learn More
+| Resource | Description |
+|----------|-------------|
+| 📖 **[Features Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Features)** | Complete feature list with examples |
+| 💬 **[Prompt Cookbook](https://github.com/SimplyLiz/CodeMCP/wiki/Prompt-Cookbook)** | Real prompts for real problems |
+| 🔌 **[Integration Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Integration-Guide)** | Use CKB in your own tools and scripts |
+| ⚡ **[Impact Analysis](https://github.com/SimplyLiz/CodeMCP/wiki/Impact-Analysis)** | Blast radius, affected tests, PR risk |
+| 🔧 **[CI/CD Integration](https://github.com/SimplyLiz/CodeMCP/wiki/CI-CD-Integration)** | GitHub Actions, GitLab CI templates |
+---
 ## Quick Start
 ### Option 1: npm (Recommended)
@@ -100,6 +135,14 @@ ckb setup  # creates .mcp.json automatically
 claude mcp add --transport stdio ckb -- npx @tastehub/ckb mcp
 ```
+**Token efficiency shown at startup:**
+```
+CKB MCP Server v8.0.0
+  Active tools: 14 / 76 (18%)
+  Estimated context: ~1k tokens
+  Preset: core
+```
 Now Claude can answer questions like:
 - *"What calls the HandleRequest function?"*
 - *"How is ProcessPayment reached from the API?"*
@@ -126,315 +169,117 @@ Now Claude can answer questions like:
 | **[CLI](https://github.com/SimplyLiz/CodeMCP/wiki/User-Guide)** | Quick lookups from terminal, scripting |
 | **[HTTP API](https://github.com/SimplyLiz/CodeMCP/wiki/API-Reference)** | IDE plugins, CI integration, custom tooling |
-## Features
-### Core Intelligence
-- **Symbol Navigation** — Find any function, class, or variable in milliseconds
-- **Call Flow & Tracing** — Trace how code is reached from API endpoints, CLI commands, or jobs
-- **Impact Analysis** — Know exactly what breaks before refactoring, with risk scores
-- **Architecture Maps** — Module dependency graphs, responsibilities, domain concepts
-- **Dead Code Detection** — Keep/investigate/remove verdicts based on usage analysis
-### Ownership & Risk
-- **Ownership Intelligence** — CODEOWNERS + git blame with time-weighted analysis
-- **Hotspot Detection** — Track churn trends, get 30-day risk projections
-- **Architectural Decisions** — Record and query ADRs with full-text search
-### Advanced Capabilities
-- **Federation** — Query across multiple repos organization-wide
-- **Multi-Repo Management** — Named repo registry with quick MCP context switching
-- **Daemon Mode** — Always-on service with HTTP API, scheduled tasks, webhooks
-- **Contract Analysis** — Protobuf and OpenAPI discovery with cross-repo impact
-- **Runtime Observability** — OpenTelemetry integration for dead code detection
-- **Developer Intelligence** — Symbol origins, co-change coupling, risk audit
-### Fast Indexing
-- **Zero-Index Operation** — Tree-sitter fallback works without SCIP index
-- **Incremental Updates** — O(changed files) instead of full reindex (Go, TypeScript, Python, Dart, Rust)
-- **Smart Caching** — Skip-if-fresh, watch mode, transitive invalidation
-- **Auto Index Updates** — Watch mode, daemon file watcher, webhook API for CI/CD
-### Remote Index Server
-- **Index Serving** — Serve symbol indexes over HTTP for federation
-- **Index Upload** — Push SCIP indexes with compression (gzip/zstd)
-- **Delta Updates** — Upload only changed files
-- **API Key Auth** — Scoped keys with rate limiting
-- **Remote Federation** — Connect to remote CKB servers and query alongside local repos
-📋 **[Full Changelog](https://github.com/SimplyLiz/CodeMCP/blob/main/CHANGELOG.md)** — Detailed version history from v5.1 to current
-### Zero-Friction UX (v7.0+)
-- **npm Distribution** — `npm install -g @tastehub/ckb` or `npx @tastehub/ckb`
-- **Auto-Setup** — `ckb setup` configures Claude Code integration automatically
-- **Update Notifications** — Automatic update check for npm installs (disable with `CKB_NO_UPDATE_CHECK=1`)
-### Zero-Index Operation (v7.1)
-- **Tree-sitter Fallback** — Symbol search works without SCIP index (8 languages)
-- **Auto-Index** — `ckb index` detects language and runs the right SCIP indexer
-- **Install Guidance** — Shows indexer install commands when missing
-- **Universal MCP Docs** — Setup for Claude Code, Cursor, Windsurf, VS Code, OpenCode, Claude Desktop
-### Smart Indexing & Explicit Tiers (v7.2)
-- **Skip-if-Fresh** — `ckb index` automatically skips if index is current with HEAD
-- **Freshness Tracking** — Tracks commits behind HEAD + uncommitted changes
-- **Index Status** — `ckb status` shows index freshness with commit hash
-- **Watch Mode** — `ckb mcp --watch` polls every 30s and auto-reindexes when stale
-- **Lock File** — Prevents concurrent indexing with flock-based locking
-- **Explicit Tiers** — Control analysis mode: `--tier=fast|standard|full` or `CKB_TIER` env var
-- **Tier Diagnostics** — `ckb doctor --tier enhanced` shows exactly what's missing and how to fix it
-### Doc-Symbol Linking (v7.3)
-- **Backtick Detection** — Automatically detect `Symbol.Name` references in markdown
-- **Directive Support** — Explicit `<!-- ckb:symbol -->` and `<!-- ckb:module -->` directives
-- **Fence Scanning** — Extract symbols from fenced code blocks via tree-sitter (8 languages)
-- **Staleness Detection** — Find broken references when symbols are renamed or deleted
-- **Rename Awareness** — Suggest new names when documented symbols are renamed
-- **CI Enforcement** — `--fail-under` flag for documentation coverage thresholds
-### Standardized Response Envelope (v7.4)
-- **Unified Metadata** — All 76 MCP tool responses now include structured metadata
-- **Confidence Tiers** — High/Medium/Low/Speculative tiers based on data freshness and source
-- **Provenance Tracking** — Know which backends (SCIP, Git, LSP) contributed to results
-- **Truncation Awareness** — Metadata shows when results are truncated and total counts
-- **Suggested Next Calls** — Structured drilldown suggestions for follow-up queries
-### Production Hardening (v7.3)
-- **Delta Artifacts** — CI-generated diffs for O(delta) ingestion instead of O(N)
-- **FTS5 Search** — SQLite FTS5 for instant search (replaces LIKE scans)
-- **Compaction Scheduler** — Automatic snapshot cleanup and database maintenance
-- **Prometheus Metrics** — `/metrics` endpoint for monitoring and alerting
-- **Load Shedding** — Graceful degradation under load with priority endpoints
-- **Health Details** — `/health/detailed` endpoint with per-repo and storage metrics
-### Language Quality (v7.3)
-- **Quality Tiers** — 4-tier classification (Tier 1: Go, Tier 2: TS/Python, Tier 3: Rust/Java, Tier 4: Experimental)
-- **Quality Assessment** — Per-language metrics (ref accuracy, callgraph quality)
-- **Python Venv Detection** — Auto-detect virtual environments with activation recommendations
-- **TypeScript Monorepo** — Detect pnpm, lerna, nx, yarn workspaces with per-package tsconfig status
-### Auto Index Updates (v7.5)
-- **Watch Mode** — `ckb index --watch` and `ckb mcp --watch --watch-interval 15s`
-- **Daemon File Watcher** — Automatic incremental refresh on git changes
-- **Webhook API** — `POST /api/v1/refresh` for CI/CD integration
-- **Index Staleness** — `ckb status` and `getStatus` show commits behind, index age, staleness reasons
-- **Token Efficiency Visibility** — Startup banner shows active tools, estimated tokens, preset savings (83% with core)
-### Multi-Language Incremental (v7.5)
-- **Expanded Support** — Go, TypeScript, Python, Dart, Rust (automatic indexer detection)
-- **Graceful Degradation** — Install hints when indexer is missing
-- **Unified API** — `IndexIncrementalWithLang(ctx, since, lang)` for all languages
-### Performance Improvements (v7.5)
-- **SCIP Backend** — Up to 2,500x faster: FindReferences (136x), SearchSymbols (7x), FindSymbolLocation (2,500x)
-- **Git Backend** — 53x faster getHotspots (single git command vs 4 per file)
-- **Pre-computed Indexes** — RefIndex, ConvertedSymbols cache, ContainerIndex for O(1) lookups
-## MCP Tools (76 Available)
-CKB exposes code intelligence through the Model Context Protocol:
-<details>
-<summary><strong>v5.1 — Core Navigation</strong></summary>
-| Tool | Purpose |
-|------|---------|
-| `searchSymbols` | Find symbols by name with filtering |
-| `getSymbol` | Get symbol details |
-| `findReferences` | Find all usages |
-| `explainSymbol` | AI-friendly symbol explanation |
-| `justifySymbol` | Keep/investigate/remove verdict |
-| `getCallGraph` | Caller/callee relationships |
-| `getModuleOverview` | Module statistics |
-| `analyzeImpact` | Change risk analysis |
-| `getStatus` | System health |
-| `doctor` | Diagnostics |
-</details>
-<details>
-<summary><strong>v5.2 — Discovery & Flow</strong></summary>
-| Tool | Purpose |
-|------|---------|
-| `traceUsage` | How is this symbol reached? |
-| `listEntrypoints` | System entrypoints (API, CLI, jobs) |
-| `explainFile` | File-level orientation |
-| `explainPath` | Why does this path exist? |
-| `summarizeDiff` | What changed, what might break? |
-| `getArchitecture` | Module dependency overview |
-| `getHotspots` | Volatile areas with trends |
-| `listKeyConcepts` | Domain concepts in codebase |
-| `recentlyRelevant` | What matters now? |
+## How Indexing Works
-</details>
+CKB uses **SCIP indexes** to understand your code. Think of it like a database that knows where every function is defined, who calls it, and how everything connects.
-<details>
-<summary><strong>v6.0 — Architectural Memory</strong></summary>
+### The Basics
-| Tool | Purpose |
-|------|---------|
-| `getOwnership` | Who owns this code? |
-| `getModuleResponsibilities` | What does this module do? |
-| `recordDecision` | Create an ADR |
-| `getDecisions` | Query architectural decisions |
-| `annotateModule` | Add module metadata |
-| `refreshArchitecture` | Rebuild architectural model |
+```bash
+# 1. Generate an index (auto-detects language)
+ckb index
-</details>
+# 2. Check if your index is fresh
+ckb status
+```
-<details>
-<summary><strong>v6.1 — Production Ready</strong></summary>
+Without an index, CKB still works using tree-sitter parsing (basic mode), but with an index you get:
+- Cross-file references ("who calls this function?")
+- Precise impact analysis
+- Call graph navigation
-| Tool | Purpose |
-|------|---------|
-| `getJobStatus` | Query background job status |
-| `listJobs` | List jobs with filters |
-| `cancelJob` | Cancel queued/running job |
-| `summarizePr` | PR risk analysis & reviewers |
-| `getOwnershipDrift` | CODEOWNERS vs actual ownership |
+### Language Support
-</details>
+Not all languages are equal. CKB classifies languages into **quality tiers** based on indexer maturity:
-<details>
-<summary><strong>v6.2+ — Federation, Daemon, Contracts, Telemetry, Intelligence</strong></summary>
-| Tool | Purpose |
-|------|---------|
-| `listFederations` | List all federations |
-| `federationStatus` | Get federation status |
-| `federationSearchModules` | Cross-repo module search |
-| `federationSearchOwnership` | Cross-repo ownership search |
-| `federationGetHotspots` | Merged hotspots across repos |
-| `daemonStatus` | Daemon health and stats |
-| `listSchedules` | List scheduled tasks |
-| `listWebhooks` | List configured webhooks |
-| `getFileComplexity` | Cyclomatic/cognitive complexity |
-| `listContracts` | List contracts in federation |
-| `analyzeContractImpact` | Contract change impact |
-| `getTelemetryStatus` | Coverage metrics and sync status |
-| `getObservedUsage` | Observed usage for a symbol |
-| `findDeadCodeCandidates` | Zero runtime call detection |
-| `explainOrigin` | Why does this code exist? |
-| `analyzeCoupling` | Co-change analysis |
-| `exportForLLM` | LLM-friendly export |
-| `auditRisk` | Multi-signal risk audit |
+| Tier | Quality | Languages |
+|------|---------|-----------|
+| **Tier 1** | Full support, all features | Go |
+| **Tier 2** | Full support, minor edge cases | TypeScript, JavaScript, Python |
+| **Tier 3** | Basic support, call graph may be incomplete | Rust, Java, Kotlin, C++, Ruby, Dart |
+| **Tier 4** | Experimental | C#, PHP |
-</details>
+**Key limitations:**
+- **Incremental indexing** is Go-only. Other languages require full reindex.
+- **TypeScript monorepos** may need `--infer-tsconfig` flag
+- **C/C++** requires `compile_commands.json`
+- **Python** works best with activated virtual environment
-<details>
-<summary><strong>v7.3 — Doc-Symbol Linking</strong></summary>
+Run `ckb doctor --tier standard` to check if your language tools are properly installed.
-| Tool | Purpose |
-|------|---------|
-| `indexDocs` | Scan and index documentation |
-| `getDocsForSymbol` | Find docs referencing a symbol |
-| `getSymbolsInDoc` | List symbols in a document |
-| `getDocsForModule` | Find docs linked to a module |
-| `checkDocStaleness` | Check for stale references |
-| `getDocCoverage` | Documentation coverage stats |
+See **[Language Support](https://github.com/SimplyLiz/CodeMCP/wiki/Language-Support)** for indexer installation, known issues, and the full feature matrix.
-</details>
+### Keeping Your Index Fresh
-<details>
-<summary><strong>v7.3 — Multi-Repo Management</strong></summary>
+Your index becomes stale when you make commits. CKB offers several ways to stay current:
-| Tool | Purpose |
-|------|---------|
-| `listRepos` | List registered repos with state |
-| `switchRepo` | Switch active repo context |
-| `getActiveRepo` | Get current repo info |
+| Method | Command | When to Use |
+|--------|---------|-------------|
+| Manual | `ckb index` | One-off updates, scripts |
+| Watch mode | `ckb index --watch` | Auto-refresh during development |
+| MCP watch | `ckb mcp --watch` | Auto-refresh in AI sessions |
+| CI webhook | `POST /api/v1/refresh` | Trigger from CI/CD |
-</details>
-<details>
-<summary><strong>v7.3 — Remote Federation</strong></summary>
-| Tool | Purpose |
-|------|---------|
-| `federationAddRemote` | Add a remote CKB index server |
-| `federationRemoveRemote` | Remove a remote server |
-| `federationListRemote` | List remote servers in federation |
-| `federationSyncRemote` | Sync metadata from remote servers |
-| `federationStatusRemote` | Check remote server connectivity |
-| `federationSearchSymbolsHybrid` | Search across local + remote |
-| `federationListAllRepos` | List repos from local and remote |
-</details>
-## CLI Usage
+**Quick start for AI sessions:**
+```bash
+ckb mcp --watch  # Auto-reindexes every 30s when stale
+```
+**Check staleness:**
 ```bash
-# System status
 ckb status
+# Shows: "5 commits behind HEAD" or "Up to date"
+```
-# Search for symbols
-ckb search NewServer
+For Go projects, CKB uses **incremental indexing**—only changed files are processed, making updates fast.
-# Find references
-ckb refs NewServer
+See the **[Index Management Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Index-Management)** for complete documentation.
-# Get architecture overview
-ckb arch
-# Analyze change impact
-ckb impact <symbol-id>
+## Features
-# Query ownership
-ckb ownership internal/api/handler.go
+| Feature | Description |
+|---------|-------------|
+| [**Compound Operations**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#compound-operations) | `explore`, `understand`, `prepareChange` — single-call tools that reduce AI overhead by 60-70% |
+| [**Code Navigation**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#code-navigation--discovery) | Semantic search, call graphs, trace usage, find entrypoints |
+| [**Impact Analysis**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#impact-analysis--safety) | Blast radius, risk scoring, affected tests, breaking changes (`compareAPI`) |
+| [**Architecture**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#architectural-understanding) | Module overview, ADRs, dependency graphs, explain origin |
+| [**Ownership**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#ownership--review) | CODEOWNERS + git blame, reviewer suggestions, drift detection |
+| [**Code Quality**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#code-quality--risk) | Dead code detection (`findDeadCode`), coupling analysis, complexity |
+| [**Security**](https://github.com/SimplyLiz/CodeMCP/wiki/Security) | Secret detection, credential scanning, allowlists |
+| [**Documentation**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#documentation-intelligence) | Doc-symbol linking, staleness detection, coverage metrics |
+| [**Multi-Repo**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#multi-repo--federation) | Federation, API contracts, remote index serving |
+| [**Runtime**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#runtime-intelligence) | OpenTelemetry integration, observed usage, production dead code |
+| [**Streaming**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#streaming) | SSE streaming for `findReferences`, `searchSymbols` with real-time progress |
+| [**Automation**](https://github.com/SimplyLiz/CodeMCP/wiki/Features#automation--cicd) | Daemon mode, watch mode, webhooks, incremental indexing |
-# List architectural decisions
-ckb decisions
+📖 **[Full Features Guide](https://github.com/SimplyLiz/CodeMCP/wiki/Features)** — Detailed documentation with examples
-# Run diagnostics
-ckb doctor
+📋 **[Changelog](https://github.com/SimplyLiz/CodeMCP/blob/main/CHANGELOG.md)** — Version history
-# Check tier-specific requirements
-ckb doctor --tier enhanced
+## CLI
-# Start MCP server for AI assistants
-ckb mcp
+```bash
+ckb status          # System health (with remediation suggestions)
+ckb search Handler  # Find symbols
+ckb impact diff     # Analyze changes
+ckb affected-tests  # Tests to run
+ckb hotspots        # Risky areas
+ckb arch            # Architecture overview
+ckb reviewers       # PR reviewers
+ckb mcp             # Start MCP server
 ```
-<details>
-<summary><strong>More CLI commands</strong></summary>
+**v8.0 Compound Operations (via MCP):**
 ```bash
-# Federation (v6.2)
-ckb federation create platform --description "Our microservices"
-ckb federation add platform --repo-id=api --path=/code/api
-ckb federation status platform
-ckb federation sync platform
-# Remote Federation (v7.3)
-ckb federation add-remote platform prod --url=https://ckb.company.com --token=$CKB_TOKEN
-ckb federation list-remote platform
-ckb federation sync-remote platform
-ckb federation status-remote platform prod
-# Daemon (v6.2.1)
-ckb daemon start [--port=9120]
-ckb daemon status
-ckb daemon logs --follow
-ckb daemon stop
-# Contracts (v6.3)
-ckb contracts list platform
-ckb contracts impact platform --repo=api --path=proto/api/v1/user.proto
-ckb contracts deps platform --repo=api
-# Telemetry (v6.4)
-ckb telemetry status
-ckb telemetry usage --symbol="internal/api/handler.go:HandleRequest"
-ckb dead-code --min-confidence=0.7
-# Developer Intelligence (v6.5)
-ckb explain internal/api/handler.go:42
-ckb coupling internal/query/engine.go --min-correlation=0.5
-ckb export --min-complexity=10 --max-symbols=200
-ckb audit --min-score=60 --quick-wins
+# These tools combine multiple queries into single calls
+explore      # Area exploration: symbols, dependencies, hotspots
+understand   # Symbol deep-dive: refs, callers, explanation
+prepareChange # Pre-change analysis: impact, tests, risk
+batchGet     # Fetch up to 50 symbols at once
+batchSearch  # Run up to 10 searches at once
 ```
-</details>
+📖 **[User Guide](https://github.com/SimplyLiz/CodeMCP/wiki/User-Guide)** — All CLI commands and options
 ## HTTP API
@@ -628,9 +473,12 @@ Use `cmd /c` wrapper in any config above:
 <details>
 <summary><strong>Presets (Token Optimization)</strong></summary>
-CKB exposes 76 tools, but most sessions only need a subset. Use presets to reduce token overhead by up to 83%:
+CKB exposes 80+ tools, but most sessions only need a subset. Use presets to reduce token overhead by up to 83%:
 ```bash
+# List all available presets with tool counts and token estimates
+ckb mcp --list-presets
 # Default: core preset (14 essential tools)
 ckb mcp
@@ -641,7 +489,7 @@ ckb mcp --preset=refactor    # 19 tools - core + coupling, dead code
 ckb mcp --preset=federation  # 28 tools - core + cross-repo
 ckb mcp --preset=docs        # 20 tools - core + doc-symbol linking
 ckb mcp --preset=ops         # 25 tools - core + jobs, webhooks, metrics
-ckb mcp --preset=full        # 76 tools - all tools (legacy)
+ckb mcp --preset=full        # 80+ tools - all tools (legacy)
 ```
 In MCP config:
@@ -684,6 +532,24 @@ Persistent knowledge survives across sessions:
 - **Code reviewers** — See the full picture of changes
 - **Tech leads** — Track architectural health over time
+## Limitations (Honest Take)
+**CKB excels at:**
+- Static code navigation—finding definitions, references, call graphs
+- Impact analysis for safe refactoring
+- Ownership lookup (CODEOWNERS + git blame)
+- Architecture and module understanding
+**CKB won't help with:**
+- Dynamic dispatch / runtime behavior (use debugger)
+- Generated code that isn't indexed
+- Code generation, linting, or formatting
+- Cross-repo calls (use [federation](https://github.com/SimplyLiz/CodeMCP/wiki/Federation) for this)
+> CKB is static analysis, not magic. Always verify critical decisions by reading the actual code.
+📖 **[Practical Limits](https://github.com/SimplyLiz/CodeMCP/wiki/Practical-Limits)** — Full guide on accuracy, blind spots, and when to trust results
 ## Documentation
 See the **[Full Documentation Wiki](https://github.com/SimplyLiz/CodeMCP/wiki)** for:
@@ -693,14 +559,16 @@ See the **[Full Documentation Wiki](https://github.com/SimplyLiz/CodeMCP/wiki)**
 - [Language Support](https://github.com/SimplyLiz/CodeMCP/wiki/Language-Support) — SCIP indexers and support tiers
 - [Practical Limits](https://github.com/SimplyLiz/CodeMCP/wiki/Practical-Limits) — Accuracy notes, blind spots
 - [User Guide](https://github.com/SimplyLiz/CodeMCP/wiki/User-Guide) — CLI commands and best practices
+- [Index Management](https://github.com/SimplyLiz/CodeMCP/wiki/Index-Management) — How indexing works, auto-refresh methods
 - [Incremental Indexing](https://github.com/SimplyLiz/CodeMCP/wiki/Incremental-Indexing) — Fast index updates for Go projects
 - [Doc-Symbol Linking](https://github.com/SimplyLiz/CodeMCP/wiki/Doc-Symbol-Linking) — Symbol detection in docs, staleness checking
 - [Authentication](https://github.com/SimplyLiz/CodeMCP/wiki/Authentication) — API tokens, scopes, rate limiting
-- [MCP Integration](https://github.com/SimplyLiz/CodeMCP/wiki/MCP-Integration) — Claude Code setup, 76 tools
+- [MCP Integration](https://github.com/SimplyLiz/CodeMCP/wiki/MCP-Integration) — Claude Code setup, 80+ tools
 - [API Reference](https://github.com/SimplyLiz/CodeMCP/wiki/API-Reference) — HTTP API documentation
 - [Daemon Mode](https://github.com/SimplyLiz/CodeMCP/wiki/Daemon-Mode) — Always-on service with scheduler, webhooks
 - [Configuration](https://github.com/SimplyLiz/CodeMCP/wiki/Configuration) — All options including MODULES.toml
 - [Architecture](https://github.com/SimplyLiz/CodeMCP/wiki/Architecture) — System design and components
+- [Security](https://github.com/SimplyLiz/CodeMCP/wiki/Security) — Secret detection, credential scanning
 - [Telemetry](https://github.com/SimplyLiz/CodeMCP/wiki/Telemetry) — Runtime observability, dead code detection
 - [Federation](https://github.com/SimplyLiz/CodeMCP/wiki/Federation) — Cross-repository queries
 - [CI/CD Integration](https://github.com/SimplyLiz/CodeMCP/wiki/CI-CD-Integration) — GitHub Actions, PR analysis

package/bin/ckb CHANGED Viewed

Binary file

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@tastehub/ckb-linux-arm64",
-  "version": "7.5.0",
+  "version": "8.0.0",
   "description": "CKB binary for linux-arm64",
   "os": ["linux"],
   "cpu": ["arm64"],