Feedback from jgravelle

Feedback #1: Rebase required

  "Large PRs need to be rebased onto current main before merging."

  How addressed: The fork's main was force-reset to match jgravelle/jcodemunch-mcp:main at 971ae14. The
  feat/dbt-sql-support branch (SQL language support) was cherry-picked cleanly onto upstream main as a separate branch.
  This branch (feat-provider-context-encrichment) is also based on 971ae14.

  ---
  Feedback #2: No opt-out path for context providers

  "discover_providers() runs on every index_folder call... no way to disable this."

  How addressed:

  - src/jcodemunch_mcp/tools/index_folder.py — Added context_providers: bool = True parameter to index_folder(). When
  False, or when JCODEMUNCH_CONTEXT_PROVIDERS=0 is set in the environment, provider discovery is skipped entirely — no
  YAML parsing, no doc block scanning, no overhead. Renamed the internal variable from context_providers to
  active_providers to avoid shadowing the new parameter.
  - CONTEXT_PROVIDERS.md — Added a new "Disabling Context Providers" subsection documenting both the env var and
  per-call parameter, including an MCP server config JSON example.
  - README.md — Added JCODEMUNCH_CONTEXT_PROVIDERS row to the environment variables table.
  - USER_GUIDE.md — Added bullet point for the env var in the Claude Desktop setup section.

  ---
  Feedback #3: detect() sets instance state as a side effect

  "If load() is called without detect(), it raises AttributeError."

  How addressed:

  - src/jcodemunch_mcp/parser/context/dbt.py — Initialized self._dbt_yml_path: Optional[Path] = None in __init__().
  Added a guard at the top of load() that logs a warning and returns early if _dbt_yml_path is None.

  ---
  Feedback #4: File context lookup by stem could false-match

  "A file named schema.sql would match a dbt model named schema."

  How addressed:

  - src/jcodemunch_mcp/parser/context/dbt.py — Added _model_path_prefixes list, populated during load() with the
  relative paths of the project's configured model-paths directories. Added _is_in_model_path() method.
  get_file_context() now returns None immediately for files outside model directories, preventing false matches on files
   like scripts/schema.sql or schema.sql at the project root.
  - tests/test_dbt_provider.py — Added test_get_file_context_outside_model_path test verifying that files outside
  models/ don't match even when the stem matches a model name (schema.sql, my_model.sql, scripts/my_model.sql), while
  files inside models/ still match correctly. Updated test_get_file_context_by_stem to reflect the new path-scoped
  behavior.
  - CONTEXT_PROVIDERS.md — Added a "How It Matches Files" subsection to the dbt Provider docs explaining the stem + path
   scoping strategy with examples. Updated the Terraform example's get_file_context comment to recommend path validation
   before stem matching.

  ---
  Feedback #5: bash.exe.stackdump in .gitignore

  "Windows build artifact, not a project file."

  How addressed:

  - .gitignore — Removed the bash.exe.stackdump line.

  ---
  Feedback #6: SQL_SPEC empty dicts

  "Worth adding a pragma or docstring so future contributors don't try to fix it."

  How addressed: Already addressed in the separate feat/dbt-sql-support branch. The SQL_SPEC in languages.py has a
  multi-line comment explaining that the derekstride grammar has no named field accessors and pointing to
  _parse_sql_symbols() in extractor.py where the actual extraction logic lives. No change needed on this branch.

  ---
  Test results

  - 481 passed, 4 skipped, 0 failures (one new test added)

Author: paperlinguist

.gitignore

@@ -60,4 +60,3 @@ CLAUDE.md
 .vbw-planning
 
 .vbw-planning/
-bash.exe.stackdump

CONTEXT_PROVIDERS.md

@@ -60,6 +60,17 @@ models:
 
 Doc references (`{{ doc('name') }}`) are resolved automatically.
 
+### How It Matches Files
+
+The provider matches indexed files to dbt models by **file stem** (filename without extension), but only for files within the project's configured `model-paths` directories. This prevents false matches — for example, a `scripts/schema.sql` file will not be matched to a dbt model named `schema`, but `models/schema.sql` will.
+
+```
+models/fct_daily_revenue.sql       ✓ matches model "fct_daily_revenue"
+models/staging/fct_daily_revenue.sql  ✓ matches (subdirectories OK)
+scripts/fct_daily_revenue.sql      ✗ outside model-paths
+schema.sql                         ✗ outside model-paths
+```
+
 ### How It Enriches
 
 **Symbol `ecosystem_context`** (injected into AI prompts):
@@ -194,7 +205,8 @@ class TerraformContextProvider(ContextProvider):
         # ... your parsing logic here ...
 
     def get_file_context(self, file_path: str) -> Optional[FileContext]:
-        # Return context if this file has metadata
+        # Validate the file is within your tool's project directories
+        # before matching by stem, to avoid false positives
         module = self._modules.get(Path(file_path).stem)
         if module:
             return FileContext(
@@ -260,6 +272,42 @@ Potential future providers for community contribution:
 
 Context providers require no configuration — they activate automatically when their ecosystem is detected. Provider-specific optional dependencies (like `pyyaml` for dbt) should be installed separately.
 
+### Disabling Context Providers
+
+Context providers can be disabled globally via environment variable or per-call via parameter:
+
+**Environment variable** — disables providers for all `index_folder` calls:
+
+```bash
+JCODEMUNCH_CONTEXT_PROVIDERS=0
+```
+
+In your MCP server config:
+
+```json
+{
+  "mcpServers": {
+    "jcodemunch": {
+      "command": "uvx",
+      "args": ["jcodemunch-mcp"],
+      "env": {
+        "JCODEMUNCH_CONTEXT_PROVIDERS": "0"
+      }
+    }
+  }
+}
+```
+
+**Per-call parameter** — pass `context_providers: false` to `index_folder`:
+
+```python
+index_folder(path="/my/project", context_providers=False)
+```
+
+Either method skips provider discovery entirely — no YAML parsing, no doc block scanning, no enrichment overhead.
+
+### Debugging
+
 To verify which providers activated during indexing, check the `context_enrichment` key in the `index_folder` response or enable debug logging:
 
 ```

README.md

@@ -478,6 +478,7 @@ For **LM Studio**, ensure the Local Server is running (usually on port 1234):
 | `OPENAI_MAX_TOKENS`         | Max output tokens per batch response (default: `500`) | No |
 | `CODE_INDEX_PATH`           | Custom cache path         | No       |
 | `JCODEMUNCH_MAX_INDEX_FILES`| Maximum files to index per repo/folder (default: `10000`) | No |
+| `JCODEMUNCH_CONTEXT_PROVIDERS` | Set to `0` to disable context providers (dbt, etc.) during indexing | No |
 | `JCODEMUNCH_SHARE_SAVINGS`  | Set to `0` to disable anonymous community token savings reporting | No       |
 | `JCODEMUNCH_LOG_LEVEL`      | Log level: `DEBUG`, `INFO`, `WARNING`, `ERROR` (default: `WARNING`) | No       |
 | `JCODEMUNCH_LOG_FILE`       | Path to log file. If unset, logs go to stderr. Use a file to avoid polluting MCP stdio. | No       |

USER_GUIDE.md

@@ -109,6 +109,7 @@ Environment variables are optional:
 * `GOOGLE_API_KEY` enables AI-generated summaries via Gemini Flash (used if `ANTHROPIC_API_KEY` is not set).
 * `GOOGLE_MODEL` overrides the Gemini model (default: `gemini-2.5-flash-lite`).
 * If neither key is set, summaries fall back to docstrings or signatures.
+* `JCODEMUNCH_CONTEXT_PROVIDERS=0` disables context providers (dbt metadata enrichment, etc.) during indexing.
 
 Restart Claude Desktop after saving the config.
 

src/jcodemunch_mcp/parser/context/dbt.py

@@ -172,8 +172,10 @@ class DbtContextProvider(ContextProvider):
     """
 
     def __init__(self):
+        self._dbt_yml_path: Optional[Path] = None
         self._doc_blocks: dict[str, str] = {}
         self._models: dict[str, DbtModelMetadata] = {}
+        self._model_path_prefixes: list[str] = []
 
     @property
     def name(self) -> str:
@@ -184,6 +186,9 @@ def detect(self, folder_path: Path) -> bool:
         return self._dbt_yml_path is not None
 
     def load(self, folder_path: Path) -> None:
+        if self._dbt_yml_path is None:
+            logger.warning("load() called without detect() — skipping")
+            return
         project_root = self._dbt_yml_path.parent
         logger.info("dbt project detected at %s", project_root)
 
@@ -210,13 +215,32 @@ def load(self, folder_path: Path) -> None:
             if md not in docs_dirs:
                 docs_dirs.append(md)
 
+        # Store model path prefixes (relative to indexed folder) for path validation.
+        # Only files under these prefixes are considered dbt models.
+        self._model_path_prefixes = []
+        for md in models_dirs:
+            try:
+                rel = md.resolve().relative_to(folder_path.resolve())
+                # Normalize to forward slashes for cross-platform matching
+                self._model_path_prefixes.append(str(rel).replace("\\", "/") + "/")
+            except ValueError:
+                # Model dir is outside the indexed folder — use absolute as fallback
+                self._model_path_prefixes.append(str(md).replace("\\", "/") + "/")
+
         self._doc_blocks = _parse_doc_blocks(docs_dirs)
         logger.info("Loaded %d dbt doc blocks", len(self._doc_blocks))
 
         self._models = _parse_yml_files(models_dirs, self._doc_blocks)
         logger.info("Loaded metadata for %d dbt models", len(self._models))
 
+    def _is_in_model_path(self, file_path: str) -> bool:
+        """Check if a file is within a dbt model directory."""
+        normalized = file_path.replace("\\", "/")
+        return any(normalized.startswith(prefix) for prefix in self._model_path_prefixes)
+
     def get_file_context(self, file_path: str) -> Optional[FileContext]:
+        if not self._is_in_model_path(file_path):
+            return None
         stem = Path(file_path).stem
         model = self._models.get(stem)
         if model is not None:

src/jcodemunch_mcp/tools/index_folder.py

@@ -310,6 +310,7 @@ def index_folder(
     extra_ignore_patterns: Optional[list[str]] = None,
     follow_symlinks: bool = False,
     incremental: bool = True,
+    context_providers: bool = True,
 ) -> dict:
     """Index a local folder containing source code.
 
@@ -319,6 +320,8 @@ def index_folder(
         storage_path: Custom storage path (default: ~/.code-index/).
         extra_ignore_patterns: Additional gitignore-style patterns to exclude.
         follow_symlinks: Whether to follow symlinks (default False for safety).
+        context_providers: Whether to run context providers (default True).
+            Set to False or set JCODEMUNCH_CONTEXT_PROVIDERS=0 to disable.
         incremental: When True and an existing index exists, only re-index changed files.
 
     Returns:
@@ -352,9 +355,10 @@ def index_folder(
             return {"success": False, "error": "No source files found"}
 
         # Discover context providers (dbt, terraform, etc.)
-        context_providers = discover_providers(folder_path)
-        if context_providers:
-            names = ", ".join(p.name for p in context_providers)
+        _providers_enabled = context_providers and os.environ.get("JCODEMUNCH_CONTEXT_PROVIDERS", "1") != "0"
+        active_providers = discover_providers(folder_path) if _providers_enabled else []
+        if active_providers:
+            names = ", ".join(p.name for p in active_providers)
             logger.info("Active context providers: %s", names)
 
         # Create repo identifier from folder path
@@ -441,16 +445,16 @@ def index_folder(
             )
 
             # Enrich with context providers before summarization
-            if context_providers:
-                enrich_symbols(new_symbols, context_providers)
+            if active_providers:
+                enrich_symbols(new_symbols, active_providers)
 
             new_symbols = summarize_symbols(new_symbols, use_ai=use_ai_summaries)
 
             # Generate file summaries for changed/new files
             incr_symbols_map = defaultdict(list)
             for s in new_symbols:
                 incr_symbols_map[s.file].append(s)
-            incr_file_summaries = _complete_file_summaries(sorted(files_to_parse), incr_symbols_map, context_providers=context_providers)
+            incr_file_summaries = _complete_file_summaries(sorted(files_to_parse), incr_symbols_map, context_providers=active_providers)
             incr_file_languages = _file_languages_for_paths(sorted(files_to_parse), incr_symbols_map)
 
             git_head = _get_git_head(folder_path) or ""
@@ -513,8 +517,8 @@ def index_folder(
         )
 
         # Enrich with context providers before summarization
-        if context_providers and all_symbols:
-            enrich_symbols(all_symbols, context_providers)
+        if active_providers and all_symbols:
+            enrich_symbols(all_symbols, active_providers)
 
         # Generate summaries
         if all_symbols:
@@ -526,7 +530,7 @@ def index_folder(
             file_symbols_map[s.file].append(s)
         file_languages = _file_languages_for_paths(source_file_list, file_symbols_map)
         languages = _language_counts(file_languages)
-        file_summaries = _complete_file_summaries(source_file_list, file_symbols_map, context_providers=context_providers)
+        file_summaries = _complete_file_summaries(source_file_list, file_symbols_map, context_providers=active_providers)
 
         # Save index
         # Track hashes for all discovered source files so incremental change detection
@@ -567,9 +571,9 @@ def index_folder(
         }
 
         # Report context enrichment stats from all active providers
-        if context_providers:
+        if active_providers:
             enrichment = {}
-            for provider in context_providers:
+            for provider in active_providers:
                 enrichment[provider.name] = provider.stats()
             result["context_enrichment"] = enrichment
 

tests/test_dbt_provider.py

@@ -360,7 +360,7 @@ def test_full_lifecycle(self, tmp_path):
         assert "order_id" in ctx.properties
 
     def test_get_file_context_by_stem(self, tmp_path):
-        """Matches by file stem regardless of directory path."""
+        """Matches by file stem within model directories."""
         root = _create_dbt_project(tmp_path)
         models_dir = root / "models"
         models_dir.mkdir()
@@ -374,10 +374,35 @@ def test_get_file_context_by_stem(self, tmp_path):
         provider.detect(root)
         provider.load(root)
 
-        # Different directory prefixes, same stem
+        # Within models directory — matches by stem
         assert provider.get_file_context("models/my_model.sql") is not None
         assert provider.get_file_context("models/staging/my_model.sql") is not None
-        assert provider.get_file_context("my_model.sql") is not None
+
+    def test_get_file_context_outside_model_path(self, tmp_path):
+        """Files outside model directories are not matched, even if stem matches."""
+        root = _create_dbt_project(tmp_path)
+        models_dir = root / "models"
+        models_dir.mkdir()
+        _write_schema_yml(models_dir / "schema.yml", """
+models:
+  - name: my_model
+    description: "Should not match outside models/"
+  - name: schema
+    description: "A model named schema"
+""")
+
+        provider = DbtContextProvider()
+        provider.detect(root)
+        provider.load(root)
+
+        # Outside models/ — should not match
+        assert provider.get_file_context("my_model.sql") is None
+        assert provider.get_file_context("scripts/my_model.sql") is None
+        assert provider.get_file_context("schema.sql") is None
+
+        # Inside models/ — should match
+        assert provider.get_file_context("models/my_model.sql") is not None
+        assert provider.get_file_context("models/schema.sql") is not None
 
     def test_get_file_context_no_match(self, tmp_path):
         root = _create_dbt_project(tmp_path)