Merge pull request #22 from VioletCranberry/feat/dockerfile-symbols-context

feat: add symbol extraction, context expansion and richer metadata fo…

Author: VioletCranberry

CLAUDE.md

@@ -76,9 +76,9 @@ uv run cocosearch mcp --project-from-cwd
 - **`validation.py`** — Input validation guards: `validate_index_name()` (SQL injection protection for dynamic table names), `validate_query()` (resource exhaustion protection, max 10,000 chars)
 - **`mcp/server.py`** — MCP server exposing tools (search_code, analyze_query, index_codebase, etc.) + web dashboard with HTTP API (`/api/stats`, `/api/reindex`, `/api/search`, `/api/project`, `/api/projects`, `/api/index`, `/api/stop-indexing`, `/api/delete-index`, `/api/list`, `/api/analyze`, `/api/languages`, `/api/grammars`, `/api/open-in-editor`, `/api/file-content`, `/health`, `/api/heartbeat` SSE, `/api/ai-chat/*` AI chat)
 - **`mcp/project_detection.py`** — Auto-detect project from MCP Roots or CWD
-- **`indexer/`** — CocoIndex pipeline: file filtering (`file_filter.py`), Tree-sitter symbol extraction (15 languages via `.scm` queries in `indexer/queries/`), Ollama embedding, tsvector generation, parse health tracking, schema migration, preflight validation (`preflight.py`), progress reporting (`progress.py`)
+- **`indexer/`** — CocoIndex pipeline: file filtering (`file_filter.py`), Tree-sitter symbol extraction (16 languages via `.scm` queries in `indexer/queries/`), Ollama embedding, tsvector generation, parse health tracking, schema migration, preflight validation (`preflight.py`), progress reporting (`progress.py`)
 - **`indexer/flow.py`** — CocoIndex flow definition (the indexing pipeline)
-- **`search/`** — Hybrid search engine: RRF fusion of vector + keyword results, two-level LRU query cache (`cache.py` — exact + semantic similarity at cosine > 0.92), context expansion via Tree-sitter boundaries for 8 languages (`context_expander.py`, exports `CONTEXT_EXPANSION_LANGUAGES`), symbol/language filtering (`filters.py`), auto-detection of code identifiers for hybrid mode (`query_analyzer.py`), interactive REPL (`repl.py`), result formatting (`formatter.py`), pipeline analysis with stage-by-stage diagnostics (`analyze.py`)
+- **`search/`** — Hybrid search engine: RRF fusion of vector + keyword results, two-level LRU query cache (`cache.py` — exact + semantic similarity at cosine > 0.92), context expansion via Tree-sitter boundaries for 9 languages (`context_expander.py`, exports `CONTEXT_EXPANSION_LANGUAGES`), symbol/language filtering (`filters.py`), auto-detection of code identifiers for hybrid mode (`query_analyzer.py`), interactive REPL (`repl.py`), result formatting (`formatter.py`), pipeline analysis with stage-by-stage diagnostics (`analyze.py`)
 - **`search/db.py`** — PostgreSQL connection pool (singleton) and query execution
 - **`config/`** — YAML config with 4-level precedence resolution (CLI > env > file > defaults), `${VAR}` substitution (`env_substitution.py`), Pydantic schema validation (`schema.py` with `extra="forbid"`, `strict=True`), user-friendly error formatting with fuzzy field suggestions (`errors.py`), env var validation (`env_validation.py`)
 - **`management/`** — Index lifecycle: discovery (`discovery.py`), stats (`stats.py`), clearing (`clear.py`), git-based naming (`git.py`), metadata with collision detection and status tracking (`metadata.py`), project root detection (`context.py`)

README.md

@@ -58,7 +58,7 @@
 
 Coco[-S]earch is a local-first hybrid semantic code search tool. It combines vector similarity and keyword matching (via RRF fusion) to find code by meaning, not just text. Powered by [CocoIndex](https://github.com/cocoindex-io/cocoindex) for indexing, [Tree-sitter](https://tree-sitter.github.io/tree-sitter/) for syntax-aware chunking and symbol extraction, [PostgreSQL](https://www.postgresql.org/) with [pgvector](https://github.com/pgvector/pgvector) for storage, and [Ollama](https://ollama.com/) for local embeddings. No external APIs — everything runs on your machine.
 
-Available as a WEB dashboard, CLI, MCP server, or interactive REPL. Incremental indexing, `.gitignore`-aware. Supports 31+ languages with symbol-level filtering for 14+, plus domain-specific grammars for structured config files.
+Available as a WEB dashboard, CLI, MCP server, or interactive REPL. Incremental indexing, `.gitignore`-aware. Supports 31+ languages with symbol-level filtering for 15+, plus domain-specific grammars for structured config files.
 
 <details>
 <summary>Screenshots</summary>
@@ -114,9 +114,9 @@ This project was originally built for personal use — a solo experiment in loca
 
 - 🔍 **Hybrid search** -- combines semantic similarity (pgvector cosine) and keyword matching (PostgreSQL tsvector) via Reciprocal Rank Fusion. Auto-detects code identifiers (camelCase, snake_case, PascalCase) and enables hybrid mode automatically — or force it with `--hybrid`. Definition symbols (functions, classes) get a 2x score boost. RRF constant k=60.
 
-- 🏷️ **Symbol filtering** -- narrow results to `function`, `class`, `method`, or `interface` with `--symbol-type`; match symbol names with glob patterns (`User*`, `*Handler`) via `--symbol-name`. Supported for 14 languages with Tree-sitter `.scm` queries. Filters apply before RRF fusion for better ranking quality.
+- 🏷️ **Symbol filtering** -- narrow results to `function`, `class`, `method`, or `interface` with `--symbol-type`; match symbol names with glob patterns (`User*`, `*Handler`) via `--symbol-name`. Supported for 15 languages with Tree-sitter `.scm` queries. Filters apply before RRF fusion for better ranking quality.
 
-- 📐 **Context expansion** -- results automatically expand to enclosing function/class boundaries using Tree-sitter AST traversal, so you see complete units of code instead of arbitrary line ranges. Supports Python, JavaScript, TypeScript, Go, Rust, and Scala. Hard-capped at 50 lines per result, centered on the match. Disable with `--no-smart` or set explicit line counts with `-B`/`-A`/`-C`.
+- 📐 **Context expansion** -- results automatically expand to enclosing function/class boundaries using Tree-sitter AST traversal, so you see complete units of code instead of arbitrary line ranges. Supports Python, JavaScript, TypeScript, Go, Rust, Scala, HCL/Terraform, and Dockerfile. Hard-capped at 50 lines per result, centered on the match. Disable with `--no-smart` or set explicit line counts with `-B`/`-A`/`-C`.
 
 - ⚡ **Query caching** -- two-level LRU cache (500 entries, 24h TTL): exact-match via SHA-256 hash of all search parameters, plus semantic fallback that finds paraphrased queries by cosine similarity (threshold 0.92, scanning last 50 entries). Cache auto-invalidates on reindex. Bypass with `--no-cache`.
 
@@ -462,7 +462,7 @@ CocoSearch indexes 31 programming languages. Symbol-aware languages support `--s
 │ XML        │ .xml                        │    ✗    │    ✗    │
 │ YAML       │ .yaml, .yml                 │    ✗    │    ✗    │
 │ Bash       │ .sh, .bash, .zsh            │    ✓    │    ✗    │
-│ Dockerfile │ Dockerfile                  │    ✗    │    ✗    │
+│ Dockerfile │ Dockerfile                  │    ✓    │    ✓    │
 │ HCL        │ .hcl                        │    ✓    │    ✓    │
 └────────────┴─────────────────────────────┴─────────┴─────────┘
 ```
@@ -478,7 +478,7 @@ Chunking strategy depends on the language:
 
 In short: CocoIndex's Tree-sitter tells you _where to cut_; the `.scm` files tell you _what's inside each piece_.
 
-Independently of chunking, CocoSearch runs its own Tree-sitter queries (`.scm` files in `src/cocosearch/indexer/queries/`) to extract symbol metadata — function, class, method, and interface names and signatures. This powers `--symbol-type` and `--symbol-name` filtering. Symbol extraction is available for 14 languages.
+Independently of chunking, CocoSearch runs its own Tree-sitter queries (`.scm` files in `src/cocosearch/indexer/queries/`) to extract symbol metadata — function, class, method, and interface names and signatures. This powers `--symbol-type` and `--symbol-name` filtering. Symbol extraction is available for 15 languages.
 
 See [Adding Languages](./docs/adding-languages.md) for details on how these tiers work and how to add new languages or grammars.
 

src/cocosearch/handlers/dockerfile.py

@@ -53,19 +53,43 @@ class DockerfileHandler:
         r"(?:\s+[Aa][Ss]\s+(\S+))?",  # optional AS stage_name (case-insensitive AS)
     )
 
+    # COPY --from=<stage>
+    _COPY_FROM_RE = re.compile(r"^COPY\s+--from=(\S+)")
+
+    # ARG <name>[=<default>]
+    _ARG_RE = re.compile(r"^ARG\s+([A-Za-z_][A-Za-z0-9_]*)")
+
+    # ENV <key>=<value> or ENV <key> <value>
+    _ENV_RE = re.compile(r"^ENV\s+([A-Za-z_][A-Za-z0-9_]*)")
+
+    # EXPOSE <port>
+    _EXPOSE_RE = re.compile(r"^EXPOSE\s+(\S+)")
+
+    # WORKDIR <path>
+    _WORKDIR_RE = re.compile(r"^WORKDIR\s+(\S+)")
+
+    # LABEL <key>=<value> or LABEL <key> <value>
+    _LABEL_RE = re.compile(r"^LABEL\s+([A-Za-z_][A-Za-z0-9_./-]*)")
+
     def extract_metadata(self, text: str) -> dict:
         """Extract metadata from Dockerfile chunk.
 
-        Matches Dockerfile instructions. For FROM instructions, extracts stage name
-        (AS clause) or image reference for the hierarchy.
+        Matches Dockerfile instructions. Extracts hierarchy metadata for:
+        - FROM: "stage:<name>" or "image:<ref>"
+        - COPY --from: "from:<stage>"
+        - ARG: "arg:<name>"
+        - ENV: "env:<key>"
+        - EXPOSE: "port:<port>"
+        - WORKDIR: "workdir:<path>"
+        - LABEL: "label:<key>"
 
         Args:
             text: The chunk text content.
 
         Returns:
             Dict with metadata fields:
             - block_type: Dockerfile instruction (e.g., "FROM", "RUN")
-            - hierarchy: For FROM: "stage:name" or "image:ref"; empty for others
+            - hierarchy: Instruction-specific hierarchy or empty string
             - language_id: "dockerfile"
 
         Example:
@@ -82,27 +106,58 @@ def extract_metadata(self, text: str) -> dict:
             return {"block_type": "", "hierarchy": "", "language_id": "dockerfile"}
 
         instruction = match.group(1)
+        hierarchy = self._extract_hierarchy(instruction, stripped)
+
+        return {
+            "block_type": instruction,
+            "hierarchy": hierarchy,
+            "language_id": "dockerfile",
+        }
+
+    def _extract_hierarchy(self, instruction: str, stripped: str) -> str:
+        """Extract hierarchy string for a Dockerfile instruction.
+
+        Args:
+            instruction: The instruction keyword (e.g., "FROM", "ARG").
+            stripped: The comment-stripped chunk text.
 
+        Returns:
+            Hierarchy string or empty string if not applicable.
+        """
         if instruction == "FROM":
             from_match = self._FROM_RE.match(stripped)
             if from_match:
                 stage_name = from_match.group(2)
                 if stage_name:
-                    hierarchy = f"stage:{stage_name}"
-                else:
-                    image_ref = from_match.group(1)
-                    hierarchy = f"image:{image_ref}"
-            else:
-                hierarchy = ""
-        else:
-            # Non-FROM instructions get empty hierarchy in v1.2
-            hierarchy = ""
+                    return f"stage:{stage_name}"
+                return f"image:{from_match.group(1)}"
+            return ""
 
-        return {
-            "block_type": instruction,
-            "hierarchy": hierarchy,
-            "language_id": "dockerfile",
-        }
+        if instruction == "COPY":
+            m = self._COPY_FROM_RE.match(stripped)
+            return f"from:{m.group(1)}" if m else ""
+
+        if instruction == "ARG":
+            m = self._ARG_RE.match(stripped)
+            return f"arg:{m.group(1)}" if m else ""
+
+        if instruction == "ENV":
+            m = self._ENV_RE.match(stripped)
+            return f"env:{m.group(1)}" if m else ""
+
+        if instruction == "EXPOSE":
+            m = self._EXPOSE_RE.match(stripped)
+            return f"port:{m.group(1)}" if m else ""
+
+        if instruction == "WORKDIR":
+            m = self._WORKDIR_RE.match(stripped)
+            return f"workdir:{m.group(1)}" if m else ""
+
+        if instruction == "LABEL":
+            m = self._LABEL_RE.match(stripped)
+            return f"label:{m.group(1)}" if m else ""
+
+        return ""
 
     def _strip_comments(self, text: str) -> str:
         """Strip leading comments from chunk text.

src/cocosearch/indexer/queries/dockerfile.scm

@@ -0,0 +1,9 @@
+;; @doc Dockerfile symbol extraction: build stages (FROM ... AS) and build arguments (ARG)
+
+;; Build stages: FROM ... AS <alias>
+(from_instruction
+  as: (image_alias) @name) @definition.class
+
+;; Build arguments: ARG <name>[=<default>]
+(arg_instruction
+  name: (unquoted_string) @name) @definition.variable

src/cocosearch/indexer/symbols.py

@@ -100,6 +100,8 @@ class SymbolMetadata:
     # CSS
     "css": "css",
     "scss": "css",
+    # Dockerfile
+    "dockerfile": "dockerfile",
 }
 
 # ============================================================================

src/cocosearch/search/context_expander.py

@@ -53,6 +53,7 @@
     },
     "hcl": {"block"},
     "terraform": {"block"},
+    "dockerfile": {"from_instruction"},
 }
 
 # Languages that support smart context expansion (derived from DEFINITION_NODE_TYPES)
@@ -82,6 +83,8 @@
     ".tf": "terraform",
     ".hcl": "hcl",
     ".tfvars": "terraform",
+    # Dockerfile
+    ".dockerfile": "dockerfile",
 }
 
 

src/cocosearch/search/query.py

@@ -109,6 +109,7 @@ class SearchResult:
     "bash",
     "scala",
     "css",
+    "dockerfile",
 }
 
 # Handler language canonical names mapped to language_id values in the database

tests/unit/handlers/test_dockerfile.py

@@ -120,21 +120,58 @@ def test_run_instruction_empty_hierarchy(self):
         assert m["language_id"] == "dockerfile"
 
     def test_copy_instruction_empty_hierarchy(self):
-        """COPY instruction produces empty hierarchy."""
+        """COPY without --from produces empty hierarchy."""
         handler = DockerfileHandler()
         m = handler.extract_metadata("COPY . /app")
         assert m["block_type"] == "COPY"
         assert m["hierarchy"] == ""
         assert m["language_id"] == "dockerfile"
 
-    def test_env_instruction_empty_hierarchy(self):
-        """ENV instruction produces empty hierarchy."""
+    def test_copy_from_produces_hierarchy(self):
+        """COPY --from produces from:<stage> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata("COPY --from=builder /app /app")
+        assert m["block_type"] == "COPY"
+        assert m["hierarchy"] == "from:builder"
+        assert m["language_id"] == "dockerfile"
+
+    def test_copy_from_numeric_stage(self):
+        """COPY --from with numeric stage produces from:<number> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata("COPY --from=0 /app /app")
+        assert m["block_type"] == "COPY"
+        assert m["hierarchy"] == "from:0"
+
+    def test_arg_produces_hierarchy(self):
+        """ARG instruction produces arg:<name> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata("ARG VERSION=dev")
+        assert m["block_type"] == "ARG"
+        assert m["hierarchy"] == "arg:VERSION"
+        assert m["language_id"] == "dockerfile"
+
+    def test_arg_without_default(self):
+        """ARG without default value produces arg:<name> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata("ARG COMMIT_SHA")
+        assert m["block_type"] == "ARG"
+        assert m["hierarchy"] == "arg:COMMIT_SHA"
+
+    def test_env_produces_hierarchy(self):
+        """ENV instruction produces env:<key> hierarchy."""
         handler = DockerfileHandler()
         m = handler.extract_metadata("ENV NODE_ENV=production")
         assert m["block_type"] == "ENV"
-        assert m["hierarchy"] == ""
+        assert m["hierarchy"] == "env:NODE_ENV"
         assert m["language_id"] == "dockerfile"
 
+    def test_env_space_separated(self):
+        """ENV with space-separated key/value produces env:<key> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata("ENV PATH /usr/local/bin")
+        assert m["block_type"] == "ENV"
+        assert m["hierarchy"] == "env:PATH"
+
     def test_add_instruction_empty_hierarchy(self):
         """ADD instruction produces empty hierarchy."""
         handler = DockerfileHandler()
@@ -143,14 +180,46 @@ def test_add_instruction_empty_hierarchy(self):
         assert m["hierarchy"] == ""
         assert m["language_id"] == "dockerfile"
 
-    def test_expose_instruction_empty_hierarchy(self):
-        """EXPOSE instruction produces empty hierarchy."""
+    def test_expose_produces_hierarchy(self):
+        """EXPOSE instruction produces port:<port> hierarchy."""
         handler = DockerfileHandler()
         m = handler.extract_metadata("EXPOSE 8080")
         assert m["block_type"] == "EXPOSE"
-        assert m["hierarchy"] == ""
+        assert m["hierarchy"] == "port:8080"
+        assert m["language_id"] == "dockerfile"
+
+    def test_expose_with_protocol(self):
+        """EXPOSE with protocol produces port:<port/proto> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata("EXPOSE 8080/tcp")
+        assert m["block_type"] == "EXPOSE"
+        assert m["hierarchy"] == "port:8080/tcp"
+
+    def test_workdir_produces_hierarchy(self):
+        """WORKDIR instruction produces workdir:<path> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata("WORKDIR /app")
+        assert m["block_type"] == "WORKDIR"
+        assert m["hierarchy"] == "workdir:/app"
         assert m["language_id"] == "dockerfile"
 
+    def test_label_produces_hierarchy(self):
+        """LABEL instruction produces label:<key> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata('LABEL maintainer="me"')
+        assert m["block_type"] == "LABEL"
+        assert m["hierarchy"] == "label:maintainer"
+        assert m["language_id"] == "dockerfile"
+
+    def test_label_dotted_key(self):
+        """LABEL with dotted key produces label:<key> hierarchy."""
+        handler = DockerfileHandler()
+        m = handler.extract_metadata(
+            'LABEL org.opencontainers.image.title="CocoSearch"'
+        )
+        assert m["block_type"] == "LABEL"
+        assert m["hierarchy"] == "label:org.opencontainers.image.title"
+
     def test_comment_before_instruction(self):
         """Comment line before instruction is correctly skipped."""
         handler = DockerfileHandler()