Add landing page + Starlight docs site (#375)

* udpated matrix

* feat(site): add landing page + Starlight docs site

Astro + Starlight site in site/ — a flat/paper editorial landing page
plus 18 docs pages seeded from the README. Monochrome theme, hairline
rules, square corners, live GitHub star count, light default + dark
toggle. Deploys to GitHub Pages via .github/workflows/deploy-site.yml.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

site/src/content/docs/core-concepts/how-it-works.md

@@ -0,0 +1,32 @@
+---
+title: How It Works
+description: The extraction, storage, resolution, and auto-sync pipeline.
+---
+
+CodeGraph turns source code into a queryable graph in four stages.
+
+```
+files → Extraction (tree-sitter) → DB (nodes/edges/files)
+            ↓
+      Resolution (imports, name-matching, framework patterns)
+            ↓
+      Graph queries (callers, callees, impact)
+            ↓
+      Context building (markdown / JSON for AI consumption)
+```
+
+## 1. Extraction
+
+[tree-sitter](https://tree-sitter.github.io/) parses source into ASTs. Language-specific queries extract **nodes** (functions, classes, methods, types…) and **edges** (calls, imports, extends, implements). Heavy parsing runs off the main thread.
+
+## 2. Storage
+
+Everything goes into a local SQLite database (`.codegraph/codegraph.db`) with FTS5 full-text search. CodeGraph uses native `better-sqlite3` when available and transparently falls back to a WASM backend; `codegraph status` shows which is live.
+
+## 3. Resolution
+
+After extraction, references are resolved: function calls → definitions, imports → source files, class inheritance, and framework-specific patterns. Some dynamic-dispatch boundaries (callbacks, observers, React re-render, JSX children) are bridged by synthesizers so flows connect end-to-end. See [Resolution & Frameworks](/codegraph/core-concepts/resolution/).
+
+## 4. Auto-sync
+
+The MCP server watches your project using native OS file events (FSEvents / inotify / ReadDirectoryChangesW). Changes are debounced, filtered to source files, and incrementally synced — the graph stays fresh as you code, with no configuration.

site/src/content/docs/core-concepts/knowledge-graph.md

@@ -0,0 +1,27 @@
+---
+title: The Knowledge Graph
+description: The node and edge kinds the graph is built from.
+---
+
+CodeGraph stores three things: **nodes** (symbols and files), **edges** (relationships between them), and **files**. Every node and edge carries an exact `kind`, drawn from a fixed vocabulary so queries are consistent across languages.
+
+## Node kinds
+
+`file`, `module`, `class`, `struct`, `interface`, `trait`, `protocol`, `function`, `method`, `property`, `field`, `variable`, `constant`, `enum`, `enum_member`, `type_alias`, `namespace`, `parameter`, `import`, `export`, `route`, `component`.
+
+## Edge kinds
+
+`contains`, `calls`, `imports`, `exports`, `extends`, `implements`, `references`, `type_of`, `returns`, `instantiates`, `overrides`, `decorates`.
+
+## Provenance
+
+Most edges come straight from the AST. A few — at dynamic-dispatch boundaries that static parsing can't follow — are **synthesized** and marked with `provenance: 'heuristic'` plus the wiring site that created them. These are surfaced inline in `trace`, the `node` trail, and `context` call-paths, so an agent can see exactly where a connection came from.
+
+## Querying it
+
+- **Search** symbols by name (FTS5).
+- **Callers / callees** walk the call graph one hop at a time.
+- **Impact** computes the transitive radius affected by a change.
+- **Trace** returns a whole call path between two symbols in one call.
+
+See the [CLI](/codegraph/reference/cli/) and [MCP Server](/codegraph/reference/mcp-server/) references for how to run these.

site/src/content/docs/core-concepts/resolution.md

@@ -0,0 +1,30 @@
+---
+title: Resolution & Frameworks
+description: How CodeGraph connects references and links routes to handlers.
+---
+
+Extraction produces nodes and raw edges; **resolution** turns names into real connections.
+
+## Reference resolution
+
+After parsing, CodeGraph resolves:
+
+- **Imports** → the source files they point at (including tsconfig path aliases and cargo workspace members).
+- **Calls** → their definitions, by import resolution and name matching.
+- **Inheritance** → `extends` / `implements` between types.
+
+## Framework awareness
+
+CodeGraph recognizes web-framework routing files and emits `route` nodes linked by `references` edges to their handler classes or functions — so querying the callers of a view or controller surfaces the URL pattern that binds it. See [Framework Routes](/codegraph/guides/framework-routes/) for the full list of recognized frameworks.
+
+## Dynamic-dispatch coverage
+
+Static parsing misses computed and indirect calls, so flows can break at dynamic dispatch. CodeGraph bridges several of these boundaries with synthesizers so a flow connects end-to-end:
+
+- Callback / observer registration
+- `EventEmitter` channels
+- React re-render (`setState` → `render`)
+- JSX child (`render` → child component)
+- Django ORM descriptors
+
+Every synthesized edge is marked `provenance: 'heuristic'` with the site that wired it, and is shown inline wherever a path crosses it.