diff --git a/.claude/skills/agent-eval/corpus.json b/.claude/skills/agent-eval/corpus.json
index 2cfedac4f..b7893a000 100644
--- a/.claude/skills/agent-eval/corpus.json
+++ b/.claude/skills/agent-eval/corpus.json
@@ -94,5 +94,10 @@
     { "name": "react-native-segmented-control", "repo": "https://github.com/react-native-segmented-control/segmented-control", "size": "Small", "files": "~25", "question": "How does JSX `<SegmentedControl onChange={cb}/>` reach the native onChange handler on iOS/Android?" },
     { "name": "react-native-screens", "repo": "https://github.com/software-mansion/react-native-screens", "size": "Medium", "files": "~1200", "question": "How does JSX `<ScreenStack>` reach the native RNSScreenStackView component?" },
     { "name": "react-native-skia", "repo": "https://github.com/Shopify/react-native-skia", "size": "Large", "files": "~1000", "question": "How does a `<SkiaPictureView/>` JSX usage reach the iOS / Android native renderer?" }
+  ],
+  "Astro": [
+    { "name": "astro-paper", "repo": "https://github.com/satnaing/astro-paper", "size": "Small", "files": "~175", "question": "How does a blog post's frontmatter data flow from the content collection to the SEO and layout components?" },
+    { "name": "astrowind", "repo": "https://github.com/onwidget/astrowind", "size": "Medium", "files": "~176", "question": "How does the Hero component receive and pass its props down to child components?" },
+    { "name": "astro-docs", "repo": "https://github.com/withastro/docs", "size": "Large", "files": "~3191", "question": "How does the navigation sidebar get populated from the content collections and page metadata?" }
   ]
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 09fbad95a..895f81211 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### New Features
 
+- CodeGraph now indexes **Astro** (`.astro`) — components, functions, interfaces, and imports from the frontmatter block, plus component reference edges from the template. Works with `astro-paper`, `astrowind`, and the official Astro docs.
 - `codegraph init` now builds the initial index by default — you no longer need the `-i`/`--index` flag (it's still accepted, so existing commands and scripts keep working). (#483)
 - Go: Gin middleware chains now connect end-to-end in `codegraph_trace` and `codegraph_explore` — following a request reaches the middleware and route handlers registered via `.Use()` / `.GET()` instead of dead-ending where the framework dispatches the chain dynamically.
 - `codegraph_explore` now sizes its response to the *answer* instead of the file count: it shows the mechanism and the exact methods you asked about in full — even when they're buried deep in a large file — while collapsing the redundant interchangeable implementations of an interface (an HTTP interceptor chain, a query-compiler family) down to signatures. Fewer tokens for a more complete answer, so on the flows that used to occasionally cost more than plain grep/read it's now clearly cheaper — and the win holds across small, medium, and large codebases. Distinct, non-interchangeable code is shown in full as before. Disable with `CODEGRAPH_ADAPTIVE_EXPLORE=0`.
diff --git a/README.md b/README.md
index acdb726bf..4240d4f7e 100644
--- a/README.md
+++ b/README.md
@@ -204,7 +204,7 @@ CodeGraph cuts **cost, tokens, tool calls, and time on every repo** — across s
 | **Full-Text Search** | Find code by name instantly across your entire codebase, powered by FTS5 |
 | **Impact Analysis** | Trace callers, callees, and the full impact radius of any symbol before making changes |
 | **Always Fresh** | File watcher uses native OS events (FSEvents/inotify/ReadDirectoryChangesW) with debounced auto-sync — the graph stays current as you code, zero config |
-| **20+ Languages** | TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Objective-C, Swift, Kotlin, Dart, Lua, Luau, Svelte, Liquid, Pascal/Delphi |
+| **21+ Languages** | TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Objective-C, Swift, Kotlin, Dart, Lua, Luau, Astro, Svelte, Liquid, Pascal/Delphi |
 | **Framework-aware Routes** | Recognizes web-framework routing files and links URL patterns to their handlers across 14 frameworks |
 | **Mixed iOS / React Native / Expo** | Closes cross-language flows that static parsing misses: Swift ↔ ObjC bridging, React Native legacy bridge + TurboModules + Fabric view components, native → JS event emitters, Expo Modules |
 | **100% Local** | No data leaves your machine. No API keys. No external services. SQLite database only |
@@ -592,6 +592,7 @@ is written):
 | Kotlin | `.kt`, `.kts` | Full support |
 | Scala | `.scala`, `.sc` | Full support (classes, traits, methods, type aliases, Scala 3 enums) |
 | Dart | `.dart` | Full support |
+| Astro | `.astro` | Full support (frontmatter TypeScript extraction, component nodes, template call/component edges) |
 | Svelte | `.svelte` | Full support (script extraction, Svelte 5 runes, SvelteKit routes) |
 | Vue | `.vue` | Full support (script + script-setup extraction, Nuxt page/API/middleware routes) |
 | Liquid | `.liquid` | Full support |
diff --git a/__tests__/extraction.test.ts b/__tests__/extraction.test.ts
index b497af6a9..92f70b32c 100644
--- a/__tests__/extraction.test.ts
+++ b/__tests__/extraction.test.ts
@@ -4387,3 +4387,120 @@ void helperFunction(int count) {
     expect(getSupportedLanguages()).toContain('objc');
   });
 });
+
+describe('Astro Extraction', () => {
+  it('should detect Astro files', () => {
+    expect(detectLanguage('src/pages/index.astro')).toBe('astro');
+    expect(detectLanguage('components/Header.astro')).toBe('astro');
+    expect(isLanguageSupported('astro')).toBe(true);
+    expect(getSupportedLanguages()).toContain('astro');
+  });
+
+  it('should extract a component node for every .astro file', () => {
+    const code = `---
+const { title } = Astro.props;
+---
+<h1>{title}</h1>
+`;
+    const result = extractFromSource('Heading.astro', code);
+    const componentNode = result.nodes.find((n) => n.kind === 'component');
+    expect(componentNode).toBeDefined();
+    expect(componentNode?.name).toBe('Heading');
+    expect(componentNode?.language).toBe('astro');
+    expect(componentNode?.isExported).toBe(true);
+  });
+
+  it('should extract functions from the frontmatter block', () => {
+    const code = `---
+import Layout from './Layout.astro';
+
+interface Props {
+  title: string;
+}
+
+function formatDate(date: Date): string {
+  return date.toLocaleDateString();
+}
+
+const { title } = Astro.props;
+---
+<Layout title={title}>
+  <p>{formatDate(new Date())}</p>
+</Layout>
+`;
+    const result = extractFromSource('Page.astro', code);
+
+    const componentNode = result.nodes.find((n) => n.kind === 'component');
+    expect(componentNode).toBeDefined();
+    expect(componentNode?.name).toBe('Page');
+
+    const funcNode = result.nodes.find((n) => n.kind === 'function' && n.name === 'formatDate');
+    expect(funcNode).toBeDefined();
+    expect(funcNode?.language).toBe('astro');
+  });
+
+  it('should extract imports from the frontmatter block', () => {
+    const code = `---
+import Header from '../components/Header.astro';
+import { getCollection } from 'astro:content';
+---
+<Header />
+`;
+    const result = extractFromSource('Blog.astro', code);
+
+    const importNodes = result.nodes.filter((n) => n.kind === 'import');
+    expect(importNodes.length).toBeGreaterThanOrEqual(1);
+
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'imports');
+    expect(refs.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('should capture child component references from the template', () => {
+    const code = `---
+import Header from './Header.astro';
+import Footer from './Footer.astro';
+---
+<html>
+  <body>
+    <Header />
+    <main><slot /></main>
+    <Footer />
+  </body>
+</html>
+`;
+    const result = extractFromSource('Layout.astro', code);
+
+    const refs = result.unresolvedReferences.filter((r) => r.referenceKind === 'references');
+    const refNames = refs.map((r) => r.referenceName);
+    expect(refNames).toContain('Header');
+    expect(refNames).toContain('Footer');
+  });
+
+  it('should mark all extracted symbols as astro language', () => {
+    const code = `---
+function helper() { return 42; }
+const x = 1;
+---
+<p>{helper()}</p>
+`;
+    const result = extractFromSource('Component.astro', code);
+    const nonFileNodes = result.nodes.filter((n) => n.kind !== 'file');
+    for (const node of nonFileNodes) {
+      expect(node.language).toBe('astro');
+    }
+  });
+
+  it('should handle .astro files with no frontmatter', () => {
+    const code = `<html>
+  <body>
+    <h1>Hello</h1>
+  </body>
+</html>
+`;
+    const result = extractFromSource('Static.astro', code);
+    const componentNode = result.nodes.find((n) => n.kind === 'component');
+    expect(componentNode).toBeDefined();
+    expect(componentNode?.name).toBe('Static');
+    expect(result.errors).toHaveLength(0);
+  });
+});
diff --git a/package-lock.json b/package-lock.json
index e418a36e5..9809977a7 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1460,7 +1460,6 @@
       "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "esbuild": "^0.21.3",
         "postcss": "^8.4.43",
diff --git a/src/extraction/astro-extractor.ts b/src/extraction/astro-extractor.ts
new file mode 100644
index 000000000..c1b81787d
--- /dev/null
+++ b/src/extraction/astro-extractor.ts
@@ -0,0 +1,221 @@
+import { Node, Edge, ExtractionResult, ExtractionError, UnresolvedReference, Language } from '../types';
+import { generateNodeId } from './tree-sitter-helpers';
+import { TreeSitterExtractor } from './tree-sitter';
+import { isLanguageSupported } from './grammars';
+
+/**
+ * AstroExtractor - Extracts code relationships from Astro component files (.astro)
+ *
+ * Astro files are multi-language: a TypeScript frontmatter block (delimited by
+ * `---`) followed by an HTML template. Rather than relying on the Astro
+ * tree-sitter grammar (which treats the frontmatter as a raw text blob), we
+ * extract the frontmatter content and delegate it to the TypeScript
+ * TreeSitterExtractor, then scan the template for component usages and
+ * expression call references.
+ *
+ * Every .astro file produces a `component` node (Astro components are always
+ * importable as named exports).
+ */
+export class AstroExtractor {
+  private filePath: string;
+  private source: string;
+  private nodes: Node[] = [];
+  private edges: Edge[] = [];
+  private unresolvedReferences: UnresolvedReference[] = [];
+  private errors: ExtractionError[] = [];
+
+  constructor(filePath: string, source: string) {
+    this.filePath = filePath;
+    this.source = source;
+  }
+
+  extract(): ExtractionResult {
+    const startTime = Date.now();
+    try {
+      const componentNode = this.createComponentNode();
+      const frontmatter = this.extractFrontmatter();
+      if (frontmatter) {
+        this.processFrontmatter(frontmatter, componentNode.id);
+      }
+      this.extractTemplateCalls(componentNode.id, frontmatter);
+      this.extractTemplateComponents(componentNode.id, frontmatter);
+    } catch (error) {
+      this.errors.push({
+        message: `Astro extraction error: ${error instanceof Error ? error.message : String(error)}`,
+        severity: 'error',
+        code: 'parse_error',
+      });
+    }
+    return {
+      nodes: this.nodes,
+      edges: this.edges,
+      unresolvedReferences: this.unresolvedReferences,
+      errors: this.errors,
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  private createComponentNode(): Node {
+    const lines = this.source.split('\n');
+    const fileName = this.filePath.split(/[/\\]/).pop() || this.filePath;
+    const componentName = fileName.replace(/\.astro$/, '');
+    const id = generateNodeId(this.filePath, 'component', componentName, 1);
+    const node: Node = {
+      id,
+      kind: 'component',
+      name: componentName,
+      qualifiedName: `${this.filePath}::${componentName}`,
+      filePath: this.filePath,
+      language: 'astro',
+      startLine: 1,
+      endLine: lines.length,
+      startColumn: 0,
+      endColumn: lines[lines.length - 1]?.length || 0,
+      isExported: true,
+      updatedAt: Date.now(),
+    };
+    this.nodes.push(node);
+    return node;
+  }
+
+  /**
+   * Extract the frontmatter block content and its line offset within the file.
+   * Frontmatter is the TypeScript/JavaScript code between the opening and
+   * closing `---` fence lines at the top of the file.
+   */
+  private extractFrontmatter(): { content: string; startLine: number } | null {
+    // Must start with `---` (optional trailing whitespace, then newline)
+    const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(\r?\n|$)/.exec(this.source);
+    if (!match) return null;
+    const content = match[1] ?? '';
+    // `---` is line 1 (1-indexed); content starts on line 2
+    const startLine = 1;
+    return { content, startLine };
+  }
+
+  /**
+   * Re-parse frontmatter as TypeScript and incorporate the extracted symbols,
+   * offsetting all line numbers by the frontmatter's position in the file.
+   */
+  private processFrontmatter(
+    frontmatter: { content: string; startLine: number },
+    componentNodeId: string
+  ): void {
+    const lang: Language = 'typescript';
+    if (!isLanguageSupported(lang)) {
+      this.errors.push({
+        message: 'TypeScript parser not available; cannot parse Astro frontmatter',
+        severity: 'warning',
+      });
+      return;
+    }
+
+    const extractor = new TreeSitterExtractor(this.filePath, frontmatter.content, lang);
+    const result = extractor.extract();
+
+    for (const node of result.nodes) {
+      node.startLine += frontmatter.startLine;
+      node.endLine += frontmatter.startLine;
+      node.language = 'astro';
+      this.nodes.push(node);
+      this.edges.push({ source: componentNodeId, target: node.id, kind: 'contains' });
+    }
+    for (const edge of result.edges) {
+      if (edge.line) edge.line += frontmatter.startLine;
+      this.edges.push(edge);
+    }
+    for (const ref of result.unresolvedReferences) {
+      ref.line += frontmatter.startLine;
+      ref.filePath = this.filePath;
+      ref.language = 'astro';
+      this.unresolvedReferences.push(ref);
+    }
+    for (const error of result.errors) {
+      if (error.line) error.line += frontmatter.startLine;
+      this.errors.push(error);
+    }
+  }
+
+  /**
+   * Extract function calls from Astro template expressions (`{expr(...)}`)
+   * outside the frontmatter block.
+   */
+  private extractTemplateCalls(
+    componentNodeId: string,
+    frontmatter: { content: string; startLine: number } | null
+  ): void {
+    const frontmatterEndLine = frontmatter
+      ? frontmatter.startLine + frontmatter.content.split('\n').length + 1
+      : 0;
+
+    const lines = this.source.split('\n');
+    const exprRegex = /\{([^}]+)\}/g;
+
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+      if (lineIdx < frontmatterEndLine) continue;
+      const line = lines[lineIdx]!;
+      let exprMatch;
+      exprRegex.lastIndex = 0;
+      while ((exprMatch = exprRegex.exec(line)) !== null) {
+        const expr = exprMatch[1]!;
+        const callRegex = /\b([a-zA-Z_$][\w$.]*)\s*\(/g;
+        let callMatch;
+        while ((callMatch = callRegex.exec(expr)) !== null) {
+          const calleeName = callMatch[1]!;
+          // Skip common non-function identifiers
+          if (
+            calleeName === 'if' || calleeName === 'else' || calleeName === 'for' ||
+            calleeName === 'while' || calleeName === 'switch' || calleeName === 'return'
+          ) continue;
+          this.unresolvedReferences.push({
+            fromNodeId: componentNodeId,
+            referenceName: calleeName,
+            referenceKind: 'calls',
+            line: lineIdx + 1,
+            column: exprMatch.index + callMatch.index,
+            filePath: this.filePath,
+            language: 'astro',
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Extract component usages from the Astro template.
+   *
+   * PascalCase tags (<Header />, <BlogPost>, etc.) and client directive
+   * components represent component instantiations — creates `references`
+   * edges from this component to the imported child component.
+   */
+  private extractTemplateComponents(
+    componentNodeId: string,
+    frontmatter: { content: string; startLine: number } | null
+  ): void {
+    const frontmatterEndLine = frontmatter
+      ? frontmatter.startLine + frontmatter.content.split('\n').length + 1
+      : 0;
+
+    const lines = this.source.split('\n');
+    const componentTagRegex = /<([A-Z][a-zA-Z0-9_$]*)\b/g;
+
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+      if (lineIdx < frontmatterEndLine) continue;
+      const line = lines[lineIdx]!;
+      let match;
+      componentTagRegex.lastIndex = 0;
+      while ((match = componentTagRegex.exec(line)) !== null) {
+        const componentName = match[1]!;
+        this.unresolvedReferences.push({
+          fromNodeId: componentNodeId,
+          referenceName: componentName,
+          referenceKind: 'references',
+          line: lineIdx + 1,
+          column: match.index + 1,
+          filePath: this.filePath,
+          language: 'astro',
+        });
+      }
+    }
+  }
+}
diff --git a/src/extraction/grammars.ts b/src/extraction/grammars.ts
index c9a2bcb37..a18013e29 100644
--- a/src/extraction/grammars.ts
+++ b/src/extraction/grammars.ts
@@ -10,7 +10,7 @@ import * as path from 'path';
 import { Parser, Language as WasmLanguage } from 'web-tree-sitter';
 import { Language } from '../types';
 
-export type GrammarLanguage = Exclude<Language, 'svelte' | 'vue' | 'liquid' | 'yaml' | 'twig' | 'xml' | 'properties' | 'unknown'>;
+export type GrammarLanguage = Exclude<Language, 'astro' | 'svelte' | 'vue' | 'liquid' | 'yaml' | 'twig' | 'xml' | 'properties' | 'unknown'>;
 
 /**
  * WASM filename map — maps each language to its .wasm grammar file
@@ -80,6 +80,7 @@ export const EXTENSION_MAP: Record<string, Language> = {
   '.kt': 'kotlin',
   '.kts': 'kotlin',
   '.dart': 'dart',
+  '.astro': 'astro',
   '.liquid': 'liquid',
   '.svelte': 'svelte',
   '.vue': 'vue',
@@ -269,6 +270,7 @@ function looksLikeObjc(source: string): boolean {
  * Returns true if the grammar exists, even if not yet loaded.
  */
 export function isLanguageSupported(language: Language): boolean {
+  if (language === 'astro') return true; // custom extractor (frontmatter delegation to TypeScript)
   if (language === 'svelte') return true; // custom extractor (script block delegation)
   if (language === 'vue') return true; // custom extractor (script block delegation)
   if (language === 'liquid') return true; // custom regex extractor
@@ -284,7 +286,7 @@ export function isLanguageSupported(language: Language): boolean {
  * Check if a grammar has been loaded and is ready for parsing.
  */
 export function isGrammarLoaded(language: Language): boolean {
-  if (language === 'svelte' || language === 'vue' || language === 'liquid') return true;
+  if (language === 'astro' || language === 'svelte' || language === 'vue' || language === 'liquid') return true;
   if (language === 'yaml' || language === 'twig') return true; // no WASM grammar needed
   if (language === 'xml' || language === 'properties') return true; // no WASM grammar needed
   return languageCache.has(language);
@@ -307,7 +309,7 @@ export function isFileLevelOnlyLanguage(language: Language): boolean {
  * Get all supported languages (those with grammar definitions).
  */
 export function getSupportedLanguages(): Language[] {
-  return [...(Object.keys(WASM_GRAMMAR_FILES) as GrammarLanguage[]), 'svelte', 'vue', 'liquid'];
+  return [...(Object.keys(WASM_GRAMMAR_FILES) as GrammarLanguage[]), 'astro', 'svelte', 'vue', 'liquid'];
 }
 
 /**
@@ -370,6 +372,7 @@ export function getLanguageDisplayName(language: Language): string {
     swift: 'Swift',
     kotlin: 'Kotlin',
     dart: 'Dart',
+    astro: 'Astro',
     svelte: 'Svelte',
     vue: 'Vue',
     liquid: 'Liquid',
diff --git a/src/extraction/tree-sitter.ts b/src/extraction/tree-sitter.ts
index f576839fa..7ad16b005 100644
--- a/src/extraction/tree-sitter.ts
+++ b/src/extraction/tree-sitter.ts
@@ -20,6 +20,7 @@ import { generateNodeId, getNodeText, getChildByField, getPrecedingDocstring } f
 import type { LanguageExtractor, ExtractorContext } from './tree-sitter-types';
 import { EXTRACTORS } from './languages';
 import { LiquidExtractor } from './liquid-extractor';
+import { AstroExtractor } from './astro-extractor';
 import { SvelteExtractor } from './svelte-extractor';
 import { DfmExtractor } from './dfm-extractor';
 import { VueExtractor } from './vue-extractor';
@@ -3055,8 +3056,12 @@ export function extractFromSource(
 
   let result: ExtractionResult;
 
+  // Use custom extractor for Astro
+  if (detectedLanguage === 'astro') {
+    const extractor = new AstroExtractor(filePath, source);
+    result = extractor.extract();
   // Use custom extractor for Svelte
-  if (detectedLanguage === 'svelte') {
+  } else if (detectedLanguage === 'svelte') {
     const extractor = new SvelteExtractor(filePath, source);
     result = extractor.extract();
   } else if (detectedLanguage === 'vue') {
diff --git a/src/extraction/wasm/tree-sitter-astro.wasm b/src/extraction/wasm/tree-sitter-astro.wasm
new file mode 100755
index 000000000..f5eefe4ba
Binary files /dev/null and b/src/extraction/wasm/tree-sitter-astro.wasm differ
diff --git a/src/types.ts b/src/types.ts
index 0cfaf0bba..fb4e44446 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -80,6 +80,7 @@ export const LANGUAGES = [
   'swift',
   'kotlin',
   'dart',
+  'astro',
   'svelte',
   'vue',
   'liquid',