codesift-mcp 0.3.0 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # CodeSift -- Token-efficient code intelligence for AI agents
 
-CodeSift indexes your codebase with tree-sitter AST parsing and gives AI agents 66 search, retrieval, and analysis tools via CLI or MCP server. It uses 61-95% fewer tokens than raw grep/Read workflows on typical code navigation tasks.
+CodeSift indexes your codebase with tree-sitter AST parsing and gives AI agents 146 MCP tools (51 core + 95 discoverable) via CLI or MCP server. It uses 61-95% fewer tokens than raw grep/Read workflows on typical code navigation tasks.
 
 **Works with:** Claude Code, Cursor, Codex, Gemini CLI, Zed, Aider, Continue — any MCP client.
 
@@ -17,6 +17,7 @@ codesift setup claude    # Claude Code — config + rules + hooks
 codesift setup codex     # Codex CLI — config + AGENTS.md rules
 codesift setup cursor    # Cursor IDE — config + .cursor/rules
 codesift setup gemini    # Gemini CLI — config + GEMINI.md rules
+codesift setup antigravity # Google Antigravity — config only
 codesift setup all       # All platforms at once
 ```
 
@@ -26,7 +27,7 @@ codesift setup all       # All platforms at once
 |-----------|-------------|---------|
 | **MCP config** | Registers codesift-mcp server | (required) |
 | **Rules file** | Tool mapping, hints, ALWAYS/NEVER rules for your AI agent | `--no-rules` |
-| **Hooks** (Claude only) | Auto-index after Edit/Write, redirect large Read to CodeSift | `--no-hooks` |
+| **Hooks** (where supported) | Auto-index after Edit/Write, redirect large Read/Bash flows to CodeSift | `--no-hooks` |
 
 Additionally, every MCP client receives ~800 tokens of compact guidance automatically via the MCP `instructions` field — zero setup needed.
 
@@ -149,7 +150,7 @@ codesift retrieve local/my-project \
 | `codesift impact <repo> --since <ref>` | Blast radius of git changes + affected tests + risk scores per file |
 | `codesift context <repo> <query>` | Assemble relevant code context. Supports `--level L0\|L1\|L2\|L3` for compression. |
 | `codesift knowledge-map <repo>` | Module dependency map with circular dependency detection |
-| `codesift trace-route <repo> <path>` | Trace HTTP route → handler → service → DB calls (NestJS/Next.js/Express) |
+| `codesift trace-route <repo> <path>` | Trace HTTP route → handler → service → DB calls (NestJS/Next.js/Express/Ktor/Spring Boot Kotlin) |
 | `codesift communities <repo>` | Louvain community detection — discover code clusters from import graph |
 
 ### Code analysis
@@ -160,7 +161,7 @@ codesift retrieve local/my-project \
 | `codesift complexity <repo>` | Cyclomatic complexity + nesting depth per function |
 | `codesift clones <repo>` | Copy-paste detection (hash bucketing + line similarity) |
 | `codesift hotspots <repo>` | Git churn x complexity = risk-ranked file list |
-| `codesift patterns <repo> <pattern>` | Structural anti-pattern search (9 built-in + custom regex) |
+| `codesift patterns <repo> <pattern>` | Structural anti-pattern search (33 built-in + custom regex) |
 
 ### Cross-repo
 
@@ -185,28 +186,32 @@ codesift retrieve local/my-project \
 | `codesift generate-claude-md <repo>` | Generate CLAUDE.md project summary |
 | `codesift list-patterns` | List all built-in anti-pattern names |
 
-## MCP tools (66 total — 35 core + 31 discoverable)
+## MCP tools (146 total — 51 core + 95 discoverable)
 
-When running as an MCP server, CodeSift exposes 35 core tools directly. The remaining 31 niche tools are discoverable via `discover_tools` and `describe_tools`.
+When running as an MCP server, CodeSift exposes 51 core tools directly. The remaining 95 niche tools are discoverable via `discover_tools` and `describe_tools`, or via `plan_turn` which routes a natural-language task to the best-fit tools and auto-reveals any hidden ones.
 
 | Category | Tools |
 |----------|-------|
 | **Indexing** | `index_folder` (mtime skip, dirty propagation), `index_repo`, `index_file` (single-file reindex, 9ms), `list_repos`, `invalidate_cache` |
-| **Search** | `search_symbols` (detail_level: compact/standard/full, token_budget), `search_text` (auto_group, group_by_file) |
-| **Outline** | `get_file_tree`, `get_file_outline`, `get_repo_outline`, `suggest_queries` |
-| **Symbol retrieval** | `get_symbol`, `get_symbols`, `find_and_show`, `get_context_bundle` |
-| **References & graph** | `find_references` (LSP-enhanced), `trace_call_chain`, `impact_analysis`, `trace_route` (HTTP route → handler → DB) |
+| **Search** | `search_symbols` (detail_level: compact/standard/full, token_budget, kind filter incl. `component`/`hook`), `search_text` (auto_group, group_by_file, ranked) |
+| **Outline** | `get_file_tree`, `get_file_outline`, `get_repo_outline`, `suggest_queries` (React-aware: suggests component/hook queries when detected) |
+| **Symbol retrieval** | `get_symbol`, `get_symbols`, `find_and_show`, `get_context_bundle` (React enrichment: hooks_used, child_components, parent_components, wrapper pattern) |
+| **References & graph** | `find_references` (LSP-enhanced), `trace_call_chain` (JSX-aware: `<Component>` = call edge; `filter_react_hooks` option), `impact_analysis`, `trace_route` (HTTP route → handler → DB — NestJS/Next.js/Express/Ktor/Spring Boot/Yii2/Laravel) |
+| **React** | `trace_component_tree` (BFS JSX composition tree with Mermaid output), `analyze_hooks` (hook inventory, Rule of Hooks violations, custom hook composition), `analyze_renders` (re-render risk: inline props, missing memo, children-aware threshold, markdown output), `analyze_context_graph` (createContext → Provider → useContext consumer mapping) |
 | **LSP bridge** | `go_to_definition` (LSP + index fallback), `get_type_info` (hover), `rename_symbol` (cross-file type-safe rename) |
 | **Context & knowledge** | `assemble_context` (level: L0/L1/L2/L3), `get_knowledge_map`, `detect_communities` (Louvain) |
 | **Conversation search** | `index_conversations`, `search_conversations`, `find_conversations_for_symbol` |
 | **Diff** | `diff_outline`, `changed_symbols` |
 | **Batch retrieval** | `codebase_retrieval` (batch multiple sub-queries with shared token budget, incl. `type: "conversation"`) |
 | **Security** | `scan_secrets` (AST-aware secret detection, ~1,100 rules, masked output) |
-| **Analysis** | `find_dead_code` (framework-aware), `analyze_complexity`, `find_clones`, `analyze_hotspots`, `search_patterns` (9 built-in incl. scaffolding), `list_patterns`, `frequency_analysis` (AST subtree clustering) |
-| **Architecture** | `classify_roles` (symbol role classification via call graph), `check_boundaries` (architecture boundary enforcement), `ast_query` (structural grep via tree-sitter) |
+| **PHP / Yii2** | `resolve_php_namespace` (PSR-4 FQCN→file), `trace_php_event` (event→listener chain), `find_php_views` (render→view mapping), `resolve_php_service` (Yii::\$app→concrete class), `php_security_scan` (compound: SQL injection, XSS, eval, exec, unserialize), `php_project_audit` (meta-tool — includes ActiveRecord analysis, N+1 detection, god-model detection via `checks=` parameter) |
+| **Analysis** | `find_dead_code` (framework-aware incl. React/Next.js route entry points), `analyze_complexity` (React: hook_count, state_count, effect_count, jsx_depth), `find_clones`, `analyze_hotspots`, `search_patterns` (33 built-in: JS/TS ×9, React ×20, Kotlin ×6, PHP ×4), `list_patterns`, `frequency_analysis` (AST subtree clustering), `find_perf_hotspots` (6 perf anti-patterns: unbounded queries, sync I/O, N+1 loops, unbounded parallel, missing pagination, expensive recompute), `explain_query` (Prisma→SQL with EXPLAIN ANALYZE), `audit_scan` (5-gate composite: dead code + clones + patterns + complexity + hotspots) |
+| **Architecture** | `classify_roles` (symbol role classification via call graph), `check_boundaries` (architecture boundary enforcement), `ast_query` (structural grep via tree-sitter), `fan_in_fan_out` (import graph coupling: most-imported, most-dependent, hub files, coupling score 0-100), `co_change_analysis` (temporal coupling from git history: Jaccard similarity, cluster detection), `architecture_summary` (one-call composite: stack + communities + coupling + circular deps + LOC + entry points, Mermaid output) |
 | **Cross-repo** | `cross_repo_search`, `cross_repo_refs` |
 | **Report** | `generate_report` (standalone HTML with complexity, dead code, hotspots, communities) |
 | **Tool discovery** | `discover_tools` (keyword search across hidden tools), `describe_tools` (full schema on demand, optional `reveal`) |
+| **Discovery** | `plan_turn(query=...)` — route natural-language task description to best-fit tools, symbols, and files; returns ranked recommendations with confidence scores, reveal_required hints, and gap analysis |
+| **Meta** | `index_status` (check if repo is indexed: file/symbol counts, language breakdown, text_stub languages), `analyze_project` (stack + conventions detection), `get_extractor_versions` (parser language support) |
 | **Utility** | `generate_claude_md` (architecture + behavioral guidance), `usage_stats` (with token savings tracking) |
 
 ### Conversation search
@@ -268,6 +273,51 @@ scan_secrets(repo="local/my-project", file_pattern="src/config/**")
 - Severity mapping: cloud keys (AWS, GCP) = critical, API keys (OpenAI, GitHub) = high
 - Inline warnings in `index_file` responses when secrets detected
 
+### PHP / Yii2 support
+
+Full PHP code intelligence with first-on-market Yii2 framework awareness. No other general-purpose MCP tool provides static Yii2 intelligence.
+
+**Symbol extraction** (tree-sitter-based):
+- Namespaces, classes, interfaces, traits, enums (PHP 8.1), functions, methods, properties, constants
+- PHPDoc extraction, signature extraction with type hints and return types
+- PHPUnit test detection: `TestCase` subclass = `test_suite`, `test*` methods = `test_case`, `setUp`/`tearDown` = `test_hook`
+
+**Yii2 framework awareness:**
+- Convention routing: `trace_route("site/index")` resolves to `SiteController::actionIndex()` (incl. module nesting)
+- `analyze_project` detects Yii2 via `composer.json` and extracts: controllers, models, modules, widgets, behaviors, components, assets, config files
+- 6 PHP-specific tools: namespace resolution (PSR-4), event/listener tracing, view mapping, service locator resolution, security scanning, project audit (meta-tool with ActiveRecord analysis, N+1 detection, god-model detection via `checks=` parameter)
+- **Auto-load**: PHP tools are automatically enabled when `composer.json` is detected at CWD — no need to call `discover_tools`/`describe_tools` first
+
+**Laravel support:**
+- Route tracing via `Route::get('/path', [Controller::class, 'method'])` pattern matching
+- Convention extraction: controllers, middleware, models, routes, migrations
+
+```bash
+# Trace a Yii2 route
+trace_route(repo, path="site/about")
+
+# Analyze ActiveRecord models (via php_project_audit)
+php_project_audit(repo, checks=["activerecord"], model_name="User")
+
+# PHP security scan (8 parallel checks)
+php_security_scan(repo)
+
+# Resolve PSR-4 namespace to file
+resolve_php_namespace(repo, class_name="App\\Models\\User")
+```
+
+**LSP bridge:** Intelephense configured for go-to-definition, find-references, type-info, and rename across PHP files.
+
+### Next.js intelligence
+
+Deep Next.js static analysis — 3 core tools covering routing, rendering, security, SEO, and architecture:
+
+- `framework_audit` — one-call meta-audit: runs route map + metadata + server actions + boundary + data flow + middleware + component classification checks. Returns composite score with prioritized findings. Use `checks=` parameter to run individual checks (e.g., `checks=["server-actions"]`, `checks=["boundary"]`, `checks=["link-integrity"]`, `checks=["data-flow"]`, `checks=["middleware"]`, `checks=["components"]`, `checks=["api-contract"]`)
+- `nextjs_route_map` — maps all App Router and Pages Router routes with rendering strategy (SSG/SSR/ISR/PPR), dynamic params, route groups, parallel routes, and intercepting routes
+- `nextjs_metadata_audit` — detects missing/incomplete metadata exports, OpenGraph gaps, missing robots/sitemap, and SEO anti-patterns across all routes
+
+**Auto-load**: Next.js tools are automatically enabled when `next` is detected in package.json — no manual discovery needed.
+
 ## When to use CodeSift vs grep
 
 | Task | Best tool | Why |
@@ -291,11 +341,12 @@ scan_secrets(repo="local/my-project", file_pattern="src/config/**")
 | Rename across files | `rename_symbol` | LSP type-safe rename in all files at once |
 | Detect hardcoded secrets | `scan_secrets` | ~1,100 rules, AST-aware, masked output, auto-cached |
 | Ranked text search | `search_text(ranked=true)` | Classifies hits by function, saves follow-up get_symbol calls |
-| Find hidden tools | `discover_tools` + `describe_tools` | 52 tools hidden by default — search by keyword, get full schema |
+| Find hidden tools | `discover_tools` + `describe_tools` | 95 tools hidden by default — search by keyword, get full schema |
+| Route task → tools | `plan_turn(query="...")` | Natural-language router: ranked tool/symbol/file recommendations with auto-reveal |
 | Find ALL occurrences | `grep -rn` | Exhaustive, no top_k cap |
 | Count matches | `grep -c` | Simple exact count |
 
-## Built-in anti-patterns
+## Built-in anti-patterns (33 total)
 
 The `patterns` command searches for common code quality issues across your codebase:
 
@@ -305,17 +356,76 @@ The `patterns` command searches for common code quality issues across your codeb
 | `any-type` | `: any` or `as any` — lost type safety |
 | `console-log` | `console.log/debug/info` in production code |
 | `await-in-loop` | Sequential `await` inside `for` loops |
-| `useEffect-no-cleanup` | React useEffect without cleanup return |
 | `no-error-type` | Catch without `instanceof Error` narrowing |
 | `toctou` | Read-then-write without atomic operation |
 | `unbounded-findmany` | Prisma `findMany` without `take` limit |
 | `scaffolding` | TODO/FIXME/HACK markers, Phase/Step stubs, "not implemented" throws |
+| `runblocking-in-coroutine` | Kotlin: `runBlocking` inside suspend function — deadlock risk |
+| `globalscope-launch` | Kotlin: `GlobalScope.launch/async` — lifecycle leak |
+| `data-class-mutable` | Kotlin: `data class` with `var` property — breaks hashCode contract |
+| `lateinit-no-check` | Kotlin: `lateinit var` without `isInitialized` check |
+| `empty-when-branch` | Kotlin: empty `when` branch — swallowed case |
+| `mutable-shared-state` | Kotlin: mutable `var` inside `object`/`companion` — thread-unsafe |
+| **React (14 + 6 below)** | |
+| `useEffect-no-cleanup` | useEffect without cleanup return — memory leak |
+| `hook-in-condition` | Hook inside if/for/while/switch — Rule of Hooks violation |
+| `useEffect-async` | async function directly in useEffect |
+| `useEffect-object-dep` | Object/array literal in dep array — infinite re-render |
+| `missing-display-name` | React.memo/forwardRef without displayName |
+| `index-as-key` | Array index used as React key — incorrect reconciliation |
+| `inline-handler` | Arrow function in JSX event handler — memoization killer |
+| `conditional-render-hook` | Hook called after early return — Rule of Hooks violation |
+| `dangerously-set-html` | dangerouslySetInnerHTML — XSS risk |
+| `direct-dom-access` | document.getElementById/querySelector — use useRef |
+| `unstable-default-value` | `= []`/`= {}` default in params — new ref every render |
+| `jsx-falsy-and` | `{count && <Comp/>}` renders "0" when count is 0 |
+| `nested-component-def` | Component inside component — remounts every render |
+| `usecallback-no-deps` | useCallback/useMemo without dep array — useless memoization |
+| **React 19 (4)** | |
+| `react19-use-without-suspense` | use(promise) call — verify Suspense boundary |
+| `react19-server-action-not-async` | Non-async function in `"use server"` file |
+| `react19-form-action-non-function` | `<form action="url">` instead of action={fn} |
+| `react19-useoptimistic-no-transition` | useOptimistic without useTransition pair |
+| **RSC (2)** | |
+| `rsc-non-serializable-prop` | Function passed as prop across RSC boundary |
+| `rsc-date-prop` | Date object in JSX prop — loses prototype across boundary |
+| **PHP (7)** | |
+| `sql-injection-php` | User input flowing into SQL query |
+| `xss-php` | Unescaped user input echoed to output |
+| `eval-php` / `exec-php` | eval/shell execution — injection risk |
+| `unserialize-php` | `unserialize()` on user input |
+| `unescaped-yii-view` | Yii2 view without `Html::encode()` |
+| `raw-query-yii` | Yii2 createCommand with string interpolation |
 
 Custom regex is also supported: `codesift patterns local/project "Promise<.*any>"`.
 
+### Performance anti-patterns (`find_perf_hotspots`)
+
+A separate tool scans for performance-specific issues with balanced-brace loop body extraction (not just regex):
+
+| Pattern | What it finds | Severity |
+|---------|---------------|----------|
+| `unbounded-query` | `findMany`/`find` without `take`/`limit` | high |
+| `sync-in-handler` | `readFileSync`/`execSync` in route/handler/controller files | high |
+| `n-plus-one` | DB/fetch call inside `for`/`while` loop body | high |
+| `unbounded-parallel` | `Promise.all(arr.map(...))` without concurrency control | medium |
+| `missing-pagination` | API response from unbounded list query | medium |
+| `expensive-recompute` | Same method called 2+ times in loop body (excludes common methods) | low |
+
+```bash
+# Scan all patterns
+find_perf_hotspots(repo)
+
+# Only N+1 and unbounded queries
+find_perf_hotspots(repo, patterns="n-plus-one,unbounded-query")
+
+# Scope to API directory
+find_perf_hotspots(repo, file_pattern="src/api")
+```
+
 ## MCP server setup
 
-CodeSift runs as an [MCP](https://modelcontextprotocol.io) server, exposing 66 tools to AI agents (35 core + 31 discoverable). The fastest setup method is `codesift setup <platform>` which handles everything automatically. Manual configuration is also supported:
+CodeSift runs as an [MCP](https://modelcontextprotocol.io) server, exposing 146 tools to AI agents (51 core + 95 discoverable). The fastest setup method is `codesift setup <platform>` which handles everything automatically. Manual configuration is also supported:
 
 ### OpenAI Codex
 
@@ -413,13 +523,28 @@ You can also use the Gemini CLI:
 gemini mcp add codesift -s user npx -- -y codesift-mcp
 ```
 
+### Google Antigravity
+
+Add this to `~/.gemini/antigravity/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "codesift": {
+      "command": "npx",
+      "args": ["-y", "codesift-mcp"]
+    }
+  }
+}
+```
+
 ### All platforms at once
 
 ```bash
 codesift setup all
 ```
 
-This configures Codex, Claude Code, Cursor, and Gemini CLI in one command. Safe to run multiple times — skips platforms that are already configured.
+This configures Codex, Claude Code, Cursor, Gemini CLI, and Antigravity in one command. Safe to run multiple times — skips platforms that are already configured.
 
 ## Semantic search
 
@@ -478,7 +603,7 @@ All configuration is via environment variables.
 
 7. **Agent onboarding** -- MCP `instructions` field sends ~800 tokens of guidance (tool discovery, hints, ALWAYS/NEVER rules) to every client automatically. `codesift setup` installs full rules files per platform + Claude Code hooks for enforcement.
 
-8. **LSP bridge** (optional) -- When a language server is installed (typescript-language-server, pylsp, gopls, rust-analyzer, solargraph, intelephense), CodeSift uses it for type-safe `find_references`, precise `go_to_definition`, `get_type_info` via hover, and cross-file `rename_symbol`. Falls back to tree-sitter/grep when LSP is unavailable. Lazy start + 5 min idle kill — zero overhead when not used.
+8. **LSP bridge** (optional) -- When a language server is installed (typescript-language-server, pylsp, gopls, rust-analyzer, kotlin-language-server, solargraph, intelephense), CodeSift uses it for type-safe `find_references`, precise `go_to_definition`, `get_type_info` via hover, and cross-file `rename_symbol`. Falls back to tree-sitter/grep when LSP is unavailable. Lazy start + 5 min idle kill — zero overhead when not used.
 
 ## Glob pattern support
 
@@ -490,9 +615,74 @@ File pattern parameters (`file_pattern`) support full glob syntax via [picomatch
 - `[!.]*.ts` — character classes
 - `service` — plain substring match (no glob chars)
 
+## React workflow with CodeSift
+
+CodeSift auto-loads 6 React tools when a React project is detected (package.json with `react` + .tsx/.jsx files). Zero config.
+
+### Day 1 — new React codebase (1 command, ~5s)
+
+```
+react_quickstart
+```
+
+One call returns: component/hook counts, stack (state mgmt, routing, UI lib, form lib, build tool), critical pattern violations, top hooks used, and suggested next queries. Replaces 5+ manual exploration calls.
+
+### Daily development
+
+```
+analyze_renders("MyComponent")          # re-render risk for a specific component
+trace_component_tree("App")             # JSX composition hierarchy
+analyze_hooks(component_name="Foo")     # hook inventory + Rule of Hooks check
+trace_call_chain("useAuth", filter_react_hooks=true)  # hook dependency graph, stdlib filtered
+find_references("UserContext")          # where this context is consumed
+analyze_context_graph                   # all createContext → Provider → useContext flows
+```
+
+### PR review
+
+```
+review_diff                             # 10-check composite (React patterns auto-skipped on non-.tsx diffs)
+changed_symbols(since="HEAD~3")         # what changed structurally
+search_patterns("hook-in-condition")    # Rule of Hooks violations in changed files
+impact_analysis(since="HEAD~3")         # blast radius of your changes
+```
+
+### CI gates (via `audit_scan` REACT gate + `audit_compiler_readiness`)
+
+```
+audit_scan                              # includes REACT gate: hook-in-condition, useEffect-async,
+                                        # dangerously-set-html, index-as-key, nested-component-def
+audit_compiler_readiness                # React Compiler (v1.0) adoption score — flags bailout
+                                        # patterns before migration, counts redundant memo to remove
+```
+
+Set CI to fail on: any `dangerously-set-html`, any Rule of Hooks violation, any `useEffect-missing-cleanup` in new code.
+
+### Common queries — "how do I..."
+
+| Question | Command |
+|----------|---------|
+| Find all components | `search_symbols(kind="component")` |
+| Find all custom hooks | `search_symbols(kind="hook")` |
+| Why is my app re-rendering? | `analyze_renders` — ranks components by risk |
+| Is my code React Compiler ready? | `audit_compiler_readiness` — scans 7 bailout patterns |
+| Who uses AuthContext? | `analyze_context_graph` — lists all consumers |
+| Rule of Hooks violations? | `search_patterns("hook-in-condition")` |
+| Memory leaks in useEffect? | `search_patterns("useEffect-missing-cleanup")` |
+| Missing TanStack invalidation? | `search_patterns("tanstack-missing-invalidation")` |
+| Should this class be a function component? | `search_patterns("prefer-function-component")` |
+| XSS risks from dangerouslySetInnerHTML? | `search_patterns("dangerously-set-html")` |
+
 ## Supported languages
 
-TypeScript, JavaScript (JSX/TSX), Python, Go, Rust, Java, Ruby, PHP, Markdown, CSS, Prisma, Astro.
+TypeScript, JavaScript (JSX/TSX), Python, Go, Rust, **Kotlin**, Java, Ruby, PHP, Markdown, CSS, Prisma, **Astro**.
+
+**React/JSX/TSX** has first-class support across 4 waves + Tier 3 polish: `component` and `hook` SymbolKind values, JSX-aware call graph (all graph tools see `<Component>` usage as call edges), 20 React anti-patterns including multiline `hook-in-condition` and bug-free `nested-component-def` detection, `trace_component_tree` (BFS JSX composition tree), `analyze_hooks` (hook inventory + Rule of Hooks violation detection), `analyze_renders` (re-render risk with children-aware threshold + markdown output), `buildContextGraph` (createContext → Provider → useContext consumer mapping), React complexity metrics (hook_count, state_count, effect_count, jsx_depth), enriched `get_context_bundle` (hooks_used, child_components, parent_components, wrapper pattern incl. forwardRef generics, props_type), `filter_react_hooks` option on `trace_call_chain`, audit_scan REACT gate, React-aware review_diff (skips React patterns on non-.tsx diffs), generate_report React section (component/hook stats, top hooks), React/Next.js/Remix route entry point detection (prevents dead code false positives), shadcn/ui + Tailwind + form library detection in ReactConventions, `@/` alias resolution, RSC boundary detection (`"use client"`/`"use server"`), and build tool detection (Vite, CRA, webpack, Parcel, esbuild, Rspack, Rsbuild, Turbopack). Auto-loaded on React projects (package.json + .tsx files).
+
+**Astro** has deep framework intelligence — the first and only static code intelligence for Astro in the MCP ecosystem. 4 dedicated tools: `astro_analyze_islands` (detect all `client:*`/`server:defer` directives, group by framework, track server islands), `astro_hydration_audit` (12 anti-pattern detectors AH01-AH12 with A/B/C/D scoring — catches `client:load` on Astro components, islands in loops, missing framework hints, below-fold eager hydration, and more), `astro_route_map` (file-based routing analysis with dynamic params, route conflicts, rendering mode per page, endpoint method detection), `astro_config_analyze` (tree-sitter AST walker for `astro.config.mjs` — extracts output mode, adapter, integrations, i18n, redirects with `config_resolution` honesty field). Also: 6 Astro anti-patterns in `search_patterns`, Astro-aware `trace_route`, `analyze_project` returns full `astro_conventions`, `.astro` extension normalization in import graph, framework detection for dead-code analysis, `.mdx` file indexing. Template parser (`parseAstroTemplate`) extracts islands, slots, component usages, and directives from HTML template section with balanced-brace tracking, conditional/loop detection, and landmark section awareness.
+
+Kotlin support includes full tree-sitter parsing with a dedicated extractor for functions, classes (data/sealed/enum/abstract/annotation), interfaces, objects (singleton + companion), properties (val/var/const), type aliases, extension functions, suspend functions, generics, KDoc comments, and JUnit test detection (@Test, @BeforeEach, @AfterEach, @BeforeAll, @AfterAll). Route tracing supports Ktor DSL and Spring Boot Kotlin. Six Kotlin anti-patterns are built-in.
+| PHP/Yii2 support | src/parser/extractors/php.ts (+ PHPDoc @property/@method synthesis), src/tools/php-tools.ts (6 tools: resolve_php_namespace, trace_php_event, find_php_views, resolve_php_service, php_security_scan, php_project_audit), src/tools/project-tools.ts (Yii2Conventions), src/tools/route-tools.ts (findYii2Handlers, findLaravelHandlers), src/tools/pattern-tools.ts (8 PHP anti-patterns), src/tools/graph-tools.ts (PHP method call detection), src/utils/import-graph.ts (PHP require/include + PSR-4 cross-file edges via resolvePhpNamespace), src/utils/walk.ts (BACKUP_FILE_PATTERNS auto-exclusion), src/parser/parser-manager.ts (error recovery try/catch), src/lsp/lsp-servers.ts (Intelephense), scripts/download-wasm.ts (tree-sitter-php@0.23.12) |
 
 ## Development
 
@@ -502,7 +692,7 @@ cd codesift-mcp
 npm install
 npm run download-wasm   # Download tree-sitter WASM grammars
 npm run build           # TypeScript compilation
-npm test                # Run tests (Vitest, 944+ tests)
+npm test                # Run tests (Vitest, 2900+ tests)
 npm run test:coverage   # Coverage report
 npm run lint            # Type check (tsc --noEmit)
 ```
@@ -555,7 +745,7 @@ If using `npx -y codesift-mcp` (the default in MCP config), the latest version i
 ### Checklist before publishing
 
 - [ ] `npm run build` — 0 TypeScript errors
-- [ ] `npm test` — 944+ tests pass
+- [ ] `npm test` — 2900+ tests pass
 - [ ] `rules/codesift.md` updated if hints or tools changed
 - [ ] `src/instructions.ts` updated if rules changed (compact version)
 - [ ] `README.md` updated if features added
@@ -570,7 +760,7 @@ BSL-1.1
 <!-- Evidence Map
 | Section | Source file(s) |
 |---------|---------------|
-| Tool count (66) | src/register-tools.ts (64 in TOOL_DEFINITIONS + discover_tools + describe_tools) |
+| Tool count (146) | src/register-tools.ts (TOOL_DEFINITIONS array, 51 in CORE_TOOL_NAMES, 95 discoverable) |
 | Quick install | package.json:bin (line 8-11) |
 | Quick start | src/cli/commands.ts |
 | Benchmark | benchmarks/ directory, previously measured |
@@ -585,7 +775,9 @@ BSL-1.1
 | Glob support | src/utils/glob.ts (picomatch) |
 | LSP bridge | src/lsp/lsp-client.ts, src/lsp/lsp-manager.ts, src/lsp/lsp-servers.ts, src/lsp/lsp-tools.ts |
 | Secret scanning | src/tools/secret-tools.ts, @sanity-labs/secret-scan (package.json) |
-| Languages | src/parser/parser-manager.ts, src/parser/extractors/ |
+| Languages | src/parser/parser-manager.ts, src/parser/extractors/ (incl. kotlin.ts) |
+| Kotlin support | kotlin.ts, graph-tools KEYWORD_SET, complexity when/?.let, test-file Test.kt, lsp-tools .kt, import-graph FQN, route-tools Ktor/Spring, pattern-tools 6 anti-patterns |
+| PHP/Yii2 support | src/parser/extractors/php.ts (+ PHPDoc @property/@method synthesis), src/tools/php-tools.ts (6 tools: resolve_php_namespace, trace_php_event, find_php_views, resolve_php_service, php_security_scan, php_project_audit), src/tools/project-tools.ts (Yii2Conventions), src/tools/route-tools.ts (findYii2Handlers, findLaravelHandlers), src/tools/pattern-tools.ts (8 PHP anti-patterns), src/tools/graph-tools.ts (PHP method call detection), src/utils/import-graph.ts (PHP require/include + PSR-4 cross-file edges via resolvePhpNamespace), src/utils/walk.ts (BACKUP_FILE_PATTERNS auto-exclusion), src/parser/parser-manager.ts (error recovery try/catch), src/lsp/lsp-servers.ts (Intelephense), scripts/download-wasm.ts (tree-sitter-php@0.23.12) |
 | Development | package.json:scripts (line 19-28) |
 | Git URL | package.json:repository (line 62-64) |
 -->

package/dist/cache/hono-cache.d.ts

@@ -0,0 +1,50 @@
+/**
+ * HonoCache — in-memory LRU cache for HonoAppModel.
+ *
+ * Design decisions (spec D4 + adversarial review fixes):
+ * - True LRU: delete+set on hit to maintain insertion-order-based recency
+ * - Deep freeze on insert: prevent tool-cross-mutation of shared model
+ * - Concurrent build protection: in-flight promise deduplication
+ * - Path canonicalization in invalidate() for consistent matching
+ * - Session-scoped (no persistence): cleared on process exit
+ *
+ * Spec: docs/specs/2026-04-10-hono-framework-intelligence-spec.md
+ * Plan: docs/specs/2026-04-10-hono-framework-intelligence-plan.md (Task 10)
+ */
+import type { HonoAppModel } from "../parser/extractors/hono-model.js";
+interface Extractor {
+    parse(entryFile: string): Promise<HonoAppModel>;
+}
+export declare class HonoCache {
+    private entries;
+    private building;
+    private maxEntries;
+    constructor(maxEntries?: number);
+    /**
+     * Get the HonoAppModel for a repo. Builds on miss, returns cached on hit.
+     * Concurrent calls during cold start share the same in-flight promise.
+     * Returned model is deeply frozen — do NOT attempt to mutate.
+     */
+    get(repo: string, entryFile: string, extractor: Extractor): Promise<HonoAppModel>;
+    /**
+     * Synchronous peek — returns the cached model without building.
+     * Returns null on miss. Does NOT reorder LRU (peek is passive).
+     * Used by findDeadCode and other hot paths that cannot await.
+     */
+    peek(repo: string): HonoAppModel | null;
+    /**
+     * Invalidate any cache entry whose files_used contains the given path.
+     * Canonicalizes via realpath before comparison for symlink/extension safety.
+     */
+    invalidate(absolutePath: string): void;
+    /**
+     * Clear cache entries. If repo is provided, only that repo's entries.
+     * Otherwise clears all.
+     */
+    clear(repo?: string): void;
+    private enforceLRU;
+}
+/** Singleton instance for the application. */
+export declare const honoCache: HonoCache;
+export {};
+//# sourceMappingURL=hono-cache.d.ts.map

package/dist/cache/hono-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono-cache.d.ts","sourceRoot":"","sources":["../../src/cache/hono-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AASvE,UAAU,SAAS;IACjB,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CACjD;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,QAAQ,CAA4C;IAC5D,OAAO,CAAC,UAAU,CAAS;gBAEf,UAAU,SAAsB;IAI5C;;;;OAIG;IACG,GAAG,CACP,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,YAAY,CAAC;IAgCxB;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAOvC;;;OAGG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAYtC;;;OAGG;IACH,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAY1B,OAAO,CAAC,UAAU;CASnB;AA2BD,8CAA8C;AAC9C,eAAO,MAAM,SAAS,WAAkB,CAAC"}

package/dist/cache/hono-cache.js

@@ -0,0 +1,132 @@
+/**
+ * HonoCache — in-memory LRU cache for HonoAppModel.
+ *
+ * Design decisions (spec D4 + adversarial review fixes):
+ * - True LRU: delete+set on hit to maintain insertion-order-based recency
+ * - Deep freeze on insert: prevent tool-cross-mutation of shared model
+ * - Concurrent build protection: in-flight promise deduplication
+ * - Path canonicalization in invalidate() for consistent matching
+ * - Session-scoped (no persistence): cleared on process exit
+ *
+ * Spec: docs/specs/2026-04-10-hono-framework-intelligence-spec.md
+ * Plan: docs/specs/2026-04-10-hono-framework-intelligence-plan.md (Task 10)
+ */
+import { existsSync, realpathSync } from "node:fs";
+const DEFAULT_MAX_ENTRIES = 10;
+export class HonoCache {
+    entries = new Map();
+    building = new Map();
+    maxEntries;
+    constructor(maxEntries = DEFAULT_MAX_ENTRIES) {
+        this.maxEntries = maxEntries;
+    }
+    /**
+     * Get the HonoAppModel for a repo. Builds on miss, returns cached on hit.
+     * Concurrent calls during cold start share the same in-flight promise.
+     * Returned model is deeply frozen — do NOT attempt to mutate.
+     */
+    async get(repo, entryFile, extractor) {
+        const key = `${repo}:${entryFile}`;
+        // Cache hit: move to end (true LRU) and return
+        const cached = this.entries.get(key);
+        if (cached) {
+            this.entries.delete(key);
+            this.entries.set(key, cached);
+            return cached.model;
+        }
+        // Concurrent build protection: reuse in-flight promise
+        const inflight = this.building.get(key);
+        if (inflight)
+            return inflight;
+        // Build new model
+        const promise = extractor
+            .parse(entryFile)
+            .then((model) => {
+            const frozen = deepFreeze(model);
+            this.entries.set(key, { model: frozen, repo });
+            this.enforceLRU();
+            return frozen;
+        })
+            .finally(() => {
+            this.building.delete(key);
+        });
+        this.building.set(key, promise);
+        return promise;
+    }
+    /**
+     * Synchronous peek — returns the cached model without building.
+     * Returns null on miss. Does NOT reorder LRU (peek is passive).
+     * Used by findDeadCode and other hot paths that cannot await.
+     */
+    peek(repo) {
+        for (const entry of this.entries.values()) {
+            if (entry.repo === repo)
+                return entry.model;
+        }
+        return null;
+    }
+    /**
+     * Invalidate any cache entry whose files_used contains the given path.
+     * Canonicalizes via realpath before comparison for symlink/extension safety.
+     */
+    invalidate(absolutePath) {
+        const canonical = canonicalize(absolutePath);
+        for (const [key, entry] of this.entries) {
+            const match = entry.model.files_used.some((f) => f === canonical || f === absolutePath);
+            if (match) {
+                this.entries.delete(key);
+            }
+        }
+    }
+    /**
+     * Clear cache entries. If repo is provided, only that repo's entries.
+     * Otherwise clears all.
+     */
+    clear(repo) {
+        if (!repo) {
+            this.entries.clear();
+            return;
+        }
+        for (const [key, entry] of this.entries) {
+            if (entry.repo === repo) {
+                this.entries.delete(key);
+            }
+        }
+    }
+    enforceLRU() {
+        while (this.entries.size > this.maxEntries) {
+            // Map.keys() returns in insertion order — first key is LRU
+            const oldest = this.entries.keys().next().value;
+            if (oldest !== undefined) {
+                this.entries.delete(oldest);
+            }
+        }
+    }
+}
+function canonicalize(filePath) {
+    try {
+        if (existsSync(filePath)) {
+            return realpathSync.native(filePath);
+        }
+    }
+    catch {
+        // Fall through
+    }
+    return filePath;
+}
+/**
+ * Recursively freeze an object and all its nested objects/arrays.
+ * Prevents tool-cross-mutation when multiple tools share the cached model.
+ */
+function deepFreeze(obj) {
+    Object.freeze(obj);
+    for (const value of Object.values(obj)) {
+        if (value && typeof value === "object" && !Object.isFrozen(value)) {
+            deepFreeze(value);
+        }
+    }
+    return obj;
+}
+/** Singleton instance for the application. */
+export const honoCache = new HonoCache();
+//# sourceMappingURL=hono-cache.js.map

package/dist/cache/hono-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono-cache.js","sourceRoot":"","sources":["../../src/cache/hono-cache.ts"],"names":[],"mappings":"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"}

package/dist/cli/help.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/cli/help.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,SAAS,64GAkErB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkZ/C,CAAC"}
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/cli/help.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,SAAS,64GAkErB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAoZ/C,CAAC"}

package/dist/cli/help.js

@@ -408,15 +408,16 @@ Configure codesift-mcp as an MCP server in an AI coding tool.
 By default, installs the MCP server config, rules file, and hooks (where supported).
 
 Platforms:
-  codex     Add to ~/.codex/config.toml + AGENTS.md rules (OpenAI Codex CLI & IDE)
-  claude    Add to ~/.claude/settings.json + rules + hooks (Claude Code)
-  cursor    Add to ~/.cursor/mcp.json + .cursor/rules/codesift.mdc (Cursor IDE)
-  gemini    Add to ~/.gemini/settings.json + GEMINI.md rules (Gemini CLI)
+  codex         Add to ~/.codex/config.toml + AGENTS.md rules (OpenAI Codex CLI & IDE)
+  claude        Add to ~/.claude/settings.json + rules + hooks (Claude Code)
+  cursor        Add to ~/.cursor/mcp.json + .cursor/rules/codesift.mdc (Cursor IDE)
+  gemini        Add to ~/.gemini/settings.json + GEMINI.md rules (Gemini CLI)
+  antigravity   Add to ~/.gemini/antigravity/mcp_config.json (Google Antigravity)
   all       Configure all platforms at once
 
 Options:
   --json        Output result as JSON instead of human-readable text
-  --hooks       (claude only) Install PreToolUse + PostToolUse hooks (default: on for claude)
+  --hooks       Install hooks where supported (default: on)
   --no-hooks    Skip hook installation
   --rules       Install platform rules file (default: on)
   --no-rules    Skip rules file installation
@@ -426,7 +427,7 @@ What it does:
   - Creates the config file if it doesn't exist
   - Adds the codesift MCP server entry if not already present
   - Installs the CodeSift rules file for the platform (use --no-rules to skip)
-  - Installs Claude Code hooks for claude platform (use --no-hooks to skip)
+  - Installs hooks for supported platforms (currently Claude Code, Codex, Gemini)
   - Skips if already configured (safe to run multiple times)
 
 Examples:
@@ -437,6 +438,7 @@ Examples:
   codesift setup claude --force
   codesift setup cursor
   codesift setup gemini
+  codesift setup antigravity
   codesift setup all`,
 };
 //# sourceMappingURL=help.js.map

package/dist/cli/help.js.map

@@ -1 +1 @@
-{"version":3,"file":"help.js","sourceRoot":"","sources":["../../src/cli/help.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,gBAAgB;AAChB,8EAA8E;AAE9E,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkExB,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAA2B;IAClD,KAAK,EAAE;;;;;;;;;;iEAUwD;IAE/D,YAAY,EAAE;;;;;;;;;6DAS6C;IAE3D,qBAAqB,EAAE;;;;;;;;;wEAS+C;IAEtE,KAAK,EAAE;;6CAEoC;IAE3C,UAAU,EAAE;;;;;0DAK4C;IAExD,MAAM,EAAE;;;;;;;;;;;;qEAY2D;IAEnE,OAAO,EAAE;;;;;;;;;;;;;mEAawD;IAEjE,IAAI,EAAE;;;;;;;;;;;;+DAYuD;IAE7D,OAAO,EAAE;;;;;;qDAM0C;IAEnD,cAAc,EAAE;;;;;kCAKgB;IAEhC,MAAM,EAAE;;;;;;qCAM2B;IAEnC,eAAe,EAAE;;;;;;iDAM8B;IAE/C,IAAI,EAAE;;;;;;;;;iEASyD;IAE/D,IAAI,EAAE;;;;;;;;;;8DAUsD;IAE5D,KAAK,EAAE;;;;;;;;;;;;;6DAaoD;IAE3D,MAAM,EAAE;;;;;;;;;;mDAUyC;IAEjD,OAAO,EAAE;;;;;;;;;6DASkD;IAE3D,eAAe,EAAE;;;;;;;;;mDASgC;IAEjD,IAAI,EAAE;;;;;;;;;mDAS2C;IAEjD,OAAO,EAAE;;;;;;;;;mDASwC;IAEjD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;+GAoBmG;IAE7G,KAAK,EAAE;;mDAE0C;IAEjD,oBAAoB,EAAE;;;;;;;;sCAQc;IAEpC,UAAU,EAAE;;;;;;;;;;;0DAW4C;IAExD,WAAW,EAAE;;;;;;;;;iEASkD;IAE/D,QAAQ,EAAE;;;;;;;;;;kEAUsD;IAEhE,WAAW,EAAE;;;;;;;;;;kEAUmD;IAEhE,QAAQ,EAAE;;;;;;;;;;;;;;2DAc+C;IAEzD,aAAa,EAAE;;;;;;;;;;;yDAWwC;IAEvD,eAAe,EAAE;;;;;;;;;;;yEAWsD;IAEvE,eAAe,EAAE;;;;;;;;;;;;uEAYoD;IAErE,gBAAgB,EAAE;;;;;;;;;;yEAUqD;IAEvE,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCY;CACpB,CAAC"}
+{"version":3,"file":"help.js","sourceRoot":"","sources":["../../src/cli/help.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,gBAAgB;AAChB,8EAA8E;AAE9E,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkExB,CAAC;AAEF,MAAM,CAAC,MAAM,YAAY,GAA2B;IAClD,KAAK,EAAE;;;;;;;;;;iEAUwD;IAE/D,YAAY,EAAE;;;;;;;;;6DAS6C;IAE3D,qBAAqB,EAAE;;;;;;;;;wEAS+C;IAEtE,KAAK,EAAE;;6CAEoC;IAE3C,UAAU,EAAE;;;;;0DAK4C;IAExD,MAAM,EAAE;;;;;;;;;;;;qEAY2D;IAEnE,OAAO,EAAE;;;;;;;;;;;;;mEAawD;IAEjE,IAAI,EAAE;;;;;;;;;;;;+DAYuD;IAE7D,OAAO,EAAE;;;;;;qDAM0C;IAEnD,cAAc,EAAE;;;;;kCAKgB;IAEhC,MAAM,EAAE;;;;;;qCAM2B;IAEnC,eAAe,EAAE;;;;;;iDAM8B;IAE/C,IAAI,EAAE;;;;;;;;;iEASyD;IAE/D,IAAI,EAAE;;;;;;;;;;8DAUsD;IAE5D,KAAK,EAAE;;;;;;;;;;;;;6DAaoD;IAE3D,MAAM,EAAE;;;;;;;;;;mDAUyC;IAEjD,OAAO,EAAE;;;;;;;;;6DASkD;IAE3D,eAAe,EAAE;;;;;;;;;mDASgC;IAEjD,IAAI,EAAE;;;;;;;;;mDAS2C;IAEjD,OAAO,EAAE;;;;;;;;;mDASwC;IAEjD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;+GAoBmG;IAE7G,KAAK,EAAE;;mDAE0C;IAEjD,oBAAoB,EAAE;;;;;;;;sCAQc;IAEpC,UAAU,EAAE;;;;;;;;;;;0DAW4C;IAExD,WAAW,EAAE;;;;;;;;;iEASkD;IAE/D,QAAQ,EAAE;;;;;;;;;;kEAUsD;IAEhE,WAAW,EAAE;;;;;;;;;;kEAUmD;IAEhE,QAAQ,EAAE;;;;;;;;;;;;;;2DAc+C;IAEzD,aAAa,EAAE;;;;;;;;;;;yDAWwC;IAEvD,eAAe,EAAE;;;;;;;;;;;yEAWsD;IAEvE,eAAe,EAAE;;;;;;;;;;;;uEAYoD;IAErE,gBAAgB,EAAE;;;;;;;;;;yEAUqD;IAEvE,KAAK,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAqCY;CACpB,CAAC"}

package/dist/cli/platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/cli/platform.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5F;;;GAGG;AACH,wBAAgB,cAAc,IAAI,YAAY,CAK7C;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAe7E"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/cli/platform.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5F;;;GAGG;AACH,wBAAgB,cAAc,IAAI,YAAY,CAK7C;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAQ7E"}