squackit 0.8.0__tar.gz → 0.8.2__tar.gz

{squackit-0.8.0 → squackit-0.8.2}/CHANGELOG.md

@@ -1,5 +1,94 @@
 # Changelog
 
+## 0.8.2
+
+### Fixed — AST tools could not read a source outside the working directory
+
+`find` / `view` / `find_names` / `complexity` build their own connection with
+no root, so fledgling's sandbox confined them to the process working
+directory. An absolute source anywhere else — `find(source="/srv/code/x/**/*.py")`
+— raised a permission error. The connection is now rooted at the source's own
+directory, which is the scope the caller named. Relative sources are untouched:
+they already resolve against the working directory, and re-rooting them would
+double-prefix the path.
+
+Each rooted plucker gets its own AST cache file, keyed by root. DuckDB's
+filesystem allow-list belongs to the database *instance*, not the connection,
+and every connection to one file shares an instance — so a single shared cache
+meant the first lockdown won for the life of the process and later roots were
+silently ignored. The cache lives in the temp directory rather than inside the
+root, since a served corpus is mounted read-only.
+
+### Fixed — de-vendoring aborted the transaction and blamed the next query
+
+When a glob's tree had no `.git`/`.gitmodules` ancestor, the walk up degraded
+to `/` and `_submodule_prefixes('')` read the filesystem root — refused under
+the sandbox. The failure was swallowed by design (de-vendoring is an
+optimization, not a correctness gate), but the aborted DuckDB transaction was
+not rolled back, so the *next* statement failed with "Current transaction is
+aborted" — pointing at the AST cache, which had done nothing wrong. Submodule
+exclusion is now skipped when there is no repository to read, and the fallback
+rolls back so the connection stays usable.
+
+### Fixed — `read_source` output was double-spaced
+
+Rows carry each line's own trailing newline, and the text renderer joined them
+with another, so every second line was blank. That also broke head/tail
+truncation, whose omission message is inserted by row index.
+
+## 0.8.1
+
+### Fixed — every code query returned "not found" under fledgling >= 0.13
+
+fledgling 0.13 added `sandbox: bool = True` to `connect()`, restricting the
+connection's filesystem allow-list to the project root. squackit's inferred
+default patterns were relative (`**/*.py`), and DuckDB resolves a relative
+glob against the process working directory — not against the root. A server's
+cwd is never the corpus it serves, so the glob landed outside the allow-list
+and the query raised:
+
+    Permission Error: Cannot access file "**/*.py"
+                      - file system operations are disabled by configuration
+
+`investigate` catches query failures and reports them as a miss, so the
+visible symptom was:
+
+    No definition found for 'parse_config'. Try a broader pattern or check spelling.
+
+for every symbol, in a project where those symbols existed — while the server
+reported all of its tools healthy. A missing-result message is
+indistinguishable from an empty corpus, which is what made this quiet.
+
+Patterns are now anchored at the project root wherever they reach DuckDB:
+
+- `ProjectDefaults` carries `root` and exposes `code_glob` / `doc_glob`;
+  `TOOL_DEFAULTS` names those rather than the raw pattern fields.
+- `scoped_code_pattern` / `scoped_doc_pattern` anchor their results.
+- Caller-supplied *relative* patterns are anchored too, so `docs/**/*.md`
+  means "docs in this project" rather than a permission error.
+- Absolute patterns are passed through untouched.
+
+The raw `code_pattern` / `doc_pattern` fields stay relative — `prompts.py`
+shows them to users, where an absolute corpus path is noise.
+
+### Changed — unscoped `investigate` falls back to the served root, not cwd
+
+`resolve_scope_path` gained a `default` argument, giving the chain
+`explicit path -> runtime.active_root -> served project root -> cwd`.
+Previously an unscoped call scoped to the process working directory, which
+was a workable stand-in only when the tool ran from inside the repo. For a
+served corpus it searched an unrelated directory, and under the sandbox it
+failed outright. Cross-project isolation is unchanged: results still come
+from one project, now named explicitly instead of inferred from cwd.
+
+### Changed — dependency bounds relaxed to `<1.0`
+
+The `fledgling-mcp>=0.12,<0.13` bound excluded 0.13.1, which is where
+fledgling relaxed its own exact `duckdb==1.5.2` pin to a range. Against a
+`duckdb==1.5.5` requirement pip did not report a conflict — it backtracked
+to squackit 0.7.0 and installed that, reporting success while shipping code
+two releases old.
+
 ## 0.8.0
 
 ### Added — source text from `find`, and a cache instead of re-parsing

{squackit-0.8.0 → squackit-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: squackit
-Version: 0.8.0
+Version: 0.8.2
 Summary: Semi-QUalified Agent Companion Kit — the stateful intelligence + MCP server layer for fledgling-equipped agents.
 Project-URL: Homepage, https://github.com/teaguesterling/squackit
 Project-URL: Documentation, https://squackit.readthedocs.io
@@ -16,10 +16,10 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
-Requires-Dist: ast-pluckit<0.16,>=0.15
+Requires-Dist: ast-pluckit<1.0,>=0.15
 Requires-Dist: click>=8.0
 Requires-Dist: fastmcp>=3.0
-Requires-Dist: fledgling-mcp<0.13,>=0.12
+Requires-Dist: fledgling-mcp<1.0,>=0.12
 Provides-Extra: docs
 Requires-Dist: mkdocs-exclude>=1.0; extra == 'docs'
 Requires-Dist: mkdocs-material>=9.5; extra == 'docs'

{squackit-0.8.0 → squackit-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "squackit"
-version = "0.8.0"
+version = "0.8.2"
 description = "Semi-QUalified Agent Companion Kit — the stateful intelligence + MCP server layer for fledgling-equipped agents."
 readme = "README.md"
 license = "Apache-2.0"
@@ -17,8 +17,14 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
 ]
 dependencies = [
-    "ast-pluckit>=0.15,<0.16",
-    "fledgling-mcp>=0.12,<0.13",
+    # Upper bounds relaxed to <1.0. The tight `<0.13` on fledgling-mcp excluded
+    # 0.13.1, which is where fledgling relaxed its own `duckdb==1.5.2` exact pin
+    # to a range. Anything needing a specific DuckDB (e.g. matching a bundled
+    # extension set) then conflicted, and pip resolved it by SILENTLY
+    # BACKTRACKING to squackit 0.7.0 rather than failing — reporting success
+    # while installing code two releases old.
+    "ast-pluckit>=0.15,<1.0",
+    "fledgling-mcp>=0.12,<1.0",
     "click>=8.0",
     "fastmcp>=3.0",
 ]

{squackit-0.8.0 → squackit-0.8.2}/squackit/defaults.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import logging
 import subprocess
 import tomllib
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, fields
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -22,7 +22,21 @@ if TYPE_CHECKING:
 
 @dataclass
 class ProjectDefaults:
-    """Inferred at server startup, cached for the session."""
+    """Inferred at server startup, cached for the session.
+
+    Patterns are stored RELATIVE (``**/*.py``) because they are shown to
+    users — prompts.py interpolates ``code_pattern`` into tool guidance,
+    where an absolute corpus path is noise. Anything handed to DuckDB
+    must instead go through the anchored accessors below.
+
+    WHY ANCHORING IS MANDATORY: a fledgling connection is sandboxed by
+    default (fledgling >= 0.13), which limits the filesystem allow-list to
+    ``root``. DuckDB resolves a relative glob against the process CWD, not
+    against ``root``. A server's CWD is never the corpus it serves, so an
+    un-anchored default pattern lands outside the allow-list and the query
+    fails with a permission error — which callers upstack turn into "no
+    results". See tests/test_sandbox_anchoring.py.
+    """
 
     code_pattern: str = "**/*"
     doc_pattern: str = "**/*.md"
@@ -30,11 +44,40 @@ class ProjectDefaults:
     from_rev: str = "HEAD~1"
     to_rev: str = "HEAD"
     languages: list[str] = field(default_factory=list)
+    root: str | None = None
+
+    def anchor(self, pattern: str | Path) -> str:
+        """Resolve *pattern* against the project root.
+
+        An absolute pattern is returned unchanged: a user who configured
+        one meant it, and silently re-rooting it would be surprising.
+        With no root known, the pattern is returned as-is, preserving the
+        pre-sandbox behaviour for callers that construct defaults directly.
+        """
+        p = Path(pattern)
+        if self.root is None or p.is_absolute():
+            return str(pattern)
+        return str(Path(self.root) / p)
+
+    @property
+    def code_glob(self) -> str:
+        """``code_pattern`` anchored at root — use this for queries."""
+        return self.anchor(self.code_pattern)
+
+    @property
+    def doc_glob(self) -> str:
+        """``doc_pattern`` anchored at root — use this for queries."""
+        return self.anchor(self.doc_pattern)
 
     def scoped_code_pattern(self, path: str | Path) -> str:
-        """Scope the code pattern to a subdirectory path."""
+        """Scope the code pattern to a subdirectory path, anchored at root."""
         filename_glob = self.code_pattern.rsplit("/", 1)[-1]
-        return str(Path(path) / "**" / filename_glob)
+        return self.anchor(Path(path) / "**" / filename_glob)
+
+    def scoped_doc_pattern(self, path: str | Path) -> str:
+        """Scope the doc pattern to a subdirectory path, anchored at root."""
+        filename_glob = self.doc_pattern.rsplit("/", 1)[-1]
+        return self.anchor(Path(path) / "**" / filename_glob)
 
 
 def apply_defaults(
@@ -50,9 +93,18 @@ def apply_defaults(
     if not mapping:
         return dict(kwargs)
     result = dict(kwargs)
-    for param, field_name in mapping.items():
+    for param, attr_name in mapping.items():
         if result.get(param) is None:
-            result[param] = getattr(defaults, field_name)
+            result[param] = getattr(defaults, attr_name)
+        elif attr_name in _PATTERN_ATTRS:
+            # An EXPLICIT pattern gets anchored too. A caller passing
+            # `docs/**/*.md` means "docs under this project", but DuckDB
+            # resolves it against the process cwd — outside the sandbox's
+            # allow-list — so it raised a permission error instead of
+            # returning rows. Relative means relative-to-root everywhere,
+            # for defaults and explicit arguments alike. Absolute patterns
+            # are passed through untouched by anchor().
+            result[param] = defaults.anchor(result[param])
     return result
 
 
@@ -70,14 +122,23 @@ def load_config(root: str | Path) -> dict[str, str]:
     return dict(data.get("defaults", {}))
 
 
-# Tool name → {param_name: defaults_field_name}
+# Attributes in TOOL_DEFAULTS that hold filesystem globs. Values for these
+# params are root-anchored whether they came from the defaults or the caller.
+_PATTERN_ATTRS = {"code_glob", "doc_glob"}
+
+# Tool name → {param_name: defaults_attribute_name}
+#
+# These name the ANCHORED accessors (code_glob / doc_glob), not the raw
+# pattern fields. A value substituted here goes straight to DuckDB, so it
+# has to be resolvable from the sandbox's allow-list rather than from the
+# process CWD. The raw code_pattern/doc_pattern fields remain for display.
 TOOL_DEFAULTS: dict[str, dict[str, str]] = {
-    "find_definitions":         {"file_pattern": "code_pattern"},
-    "find_in_ast":              {"file_pattern": "code_pattern"},
-    "code_structure":           {"file_pattern": "code_pattern"},
-    "complexity_hotspots":      {"file_pattern": "code_pattern"},
-    "changed_function_summary": {"file_pattern": "code_pattern"},
-    "doc_outline":              {"file_pattern": "doc_pattern"},
+    "find_definitions":         {"file_pattern": "code_glob"},
+    "find_in_ast":              {"file_pattern": "code_glob"},
+    "code_structure":           {"file_pattern": "code_glob"},
+    "complexity_hotspots":      {"file_pattern": "code_glob"},
+    "changed_function_summary": {"file_pattern": "code_glob"},
+    "doc_outline":              {"file_pattern": "doc_glob"},
     "file_changes":             {"from_rev": "from_rev", "to_rev": "to_rev"},
     "file_diff":                {"from_rev": "from_rev", "to_rev": "to_rev"},
     "structural_diff":          {"from_rev": "from_rev", "to_rev": "to_rev"},
@@ -216,10 +277,17 @@ def infer_defaults(
         doc_pattern=doc_pattern,
         main_branch=main_branch,
         languages=languages,
+        root=str(root) if root is not None else None,
     )
 
+    # Only real dataclass fields are settable. code_glob/doc_glob are
+    # read-only properties, so a config file naming one would otherwise
+    # raise AttributeError at startup instead of being ignored.
+    settable = {f.name for f in fields(defaults)}
     for key, value in overrides.items():
-        if hasattr(defaults, key):
+        if key in settable:
             setattr(defaults, key, value)
+        else:
+            log.warning("ignoring unknown defaults override %r", key)
 
     return defaults

{squackit-0.8.0 → squackit-0.8.2}/squackit/runtime.py

@@ -136,19 +136,33 @@ def reset_runtime() -> SquackitRuntimeConfig:
     return _runtime
 
 
-def resolve_scope_path(explicit_path: str | None = None) -> str:
+def resolve_scope_path(
+    explicit_path: str | None = None,
+    default: str | None = None,
+) -> str:
     """Resolve a scope path with the runtime config fallback chain.
 
-    Precedence: explicit_path -> runtime.active_root -> process cwd.
+    Precedence: explicit_path -> runtime.active_root -> *default* -> cwd.
+
     Used by tools that scope queries to a directory (investigate, etc.)
     so a single `config(set={"active_root": X})` call configures the whole
     session.
+
+    *default* is the served project root. It sits ahead of cwd because a
+    server's cwd is not the corpus it serves: falling through to cwd scoped
+    every unscoped query to an unrelated directory, and — once fledgling
+    began sandboxing connections to the project root — put the resulting
+    glob outside the filesystem allow-list, so the query failed outright
+    rather than merely searching the wrong tree. cwd stays as the last
+    resort for callers with no known root.
     """
     if explicit_path is not None:
         return explicit_path
     runtime_root = _runtime.active_root
     if runtime_root is not None:
         return runtime_root
+    if default is not None:
+        return default
     return os.getcwd()
 
 

{squackit-0.8.0 → squackit-0.8.2}/squackit/server.py

@@ -296,7 +296,12 @@ def _register_executor_tool(mcp, presentation: ToolPresentation):
             if is_text:
                 lines = []
                 for row in rows:
-                    parts = [str(v) for v in row if v is not None]
+                    # Strip each value's own line terminator: this branch joins
+                    # rows with "\n" itself, so a source line that already ends
+                    # in one renders double-spaced, every second line blank.
+                    # Only \r and \n come off — leading indentation is content,
+                    # and so is any trailing space a line genuinely carries.
+                    parts = [str(v).rstrip("\r\n") for v in row if v is not None]
                     lines.append("  ".join(parts))
                 if omission:
                     lines.append(omission)
@@ -594,16 +599,29 @@ def _register_tool(
 
         # Format output
         if is_text:
+            def _cell(value) -> str:
+                """Render one value as a line fragment.
+
+                Drops the value's own line terminator: this branch joins rows
+                with "\\n" itself, and `read_source` returns each line's content
+                WITH its trailing newline. Keeping both renders the file
+                double-spaced — every second line blank — which also breaks
+                head/tail truncation's line accounting, since the omission
+                message is inserted by row index. Only \\r and \\n come off;
+                leading indentation is content and must survive.
+                """
+                return str(value).rstrip("\r\n") if value is not None else ""
+
             if len(cols) == 1:
-                lines = [str(r[0]) for r in rows]
+                lines = [_cell(r[0]) for r in rows]
             elif "line_number" in cols and "content" in cols:
                 ln_idx = cols.index("line_number")
                 ct_idx = cols.index("content")
-                lines = [f"{r[ln_idx]:4d}  {r[ct_idx]}" for r in rows]
+                lines = [f"{r[ln_idx]:4d}  {_cell(r[ct_idx])}" for r in rows]
             else:
                 lines = []
                 for row in rows:
-                    parts = [str(v) for v in row if v is not None]
+                    parts = [_cell(v) for v in row if v is not None]
                     lines.append("  ".join(parts))
             if omission:
                 lines.insert(_HEAD_TAIL, omission)

{squackit-0.8.0 → squackit-0.8.2}/squackit/tools.py

@@ -8,7 +8,10 @@ fledgling macro tools. They take priority over fledgling equivalents
 
 from __future__ import annotations
 
+import hashlib
 import os
+import re
+import tempfile
 
 from fledgling.tools import ToolInfo
 from squackit.tool_config import ToolPresentation
@@ -79,27 +82,41 @@ def _filtered_source(plucker, source: str, peek: str = DEFAULT_PEEK) -> str:
         # prefix (the path before the first wildcard) and walk up to the nearest
         # .gitmodules / .git. The denylist is absolute-pattern based, no root needed.
         prefix = resolved.split("*", 1)[0]
-        root = prefix if prefix.endswith("/") else os.path.dirname(prefix)
-        while root and root != "/":
-            if os.path.exists(os.path.join(root, ".gitmodules")) or os.path.exists(
-                os.path.join(root, ".git")
+        candidate = prefix if prefix.endswith("/") else os.path.dirname(prefix)
+        # Walk up to the repository that owns these files. If there ISN'T one,
+        # leave root empty and skip submodule exclusion entirely: there are no
+        # submodules to exclude, and the walk otherwise degrades to "/", whose
+        # rstrip("/") is the empty string. `_submodule_prefixes('')` then reads
+        # the filesystem root — which a sandboxed connection refuses, aborting
+        # the transaction and taking down every later query on this connection.
+        root = ""
+        while candidate and candidate != "/":
+            if os.path.exists(os.path.join(candidate, ".gitmodules")) or os.path.exists(
+                os.path.join(candidate, ".git")
             ):
+                root = candidate
                 break
-            root = os.path.dirname(root)
+            candidate = os.path.dirname(candidate)
         rq = resolved.replace("'", "''")
-        rootq = root.rstrip("/").replace("'", "''")
 
         total = db.sql(f"SELECT count(*) FROM glob('{rq}')").fetchone()[0]
         if total <= 1:
             return source
 
+        submodule_clause = ""
+        if root:
+            rootq = root.rstrip("/").replace("'", "''")
+            submodule_clause = (
+                f"AND NOT EXISTS (SELECT 1 FROM _submodule_prefixes('{rootq}') s "
+                f"WHERE file LIKE s.prefix || '%') "
+            )
+
         kept = [
             r[0]
             for r in db.sql(
                 f"SELECT file FROM glob('{rq}') "
                 f"WHERE NOT _is_vendored_path(file) "
-                f"AND NOT EXISTS (SELECT 1 FROM _submodule_prefixes('{rootq}') s "
-                f"WHERE file LIKE s.prefix || '%') "
+                f"{submodule_clause}"
                 f"ORDER BY file"
             ).fetchall()
         ]
@@ -115,9 +132,81 @@ def _filtered_source(plucker, source: str, peek: str = DEFAULT_PEEK) -> str:
     except Exception:
         # Ignore-policy macros unavailable / SQL error — fall back to the raw
         # glob. Unfiltered (flooded) results beat a broken tool.
+        #
+        # ROLL BACK FIRST. A failed statement leaves the DuckDB transaction in
+        # an aborted state, so swallowing the error without clearing it poisons
+        # every later query on this connection with "Current transaction is
+        # aborted (please ROLLBACK)" — including the AST cache lookup that runs
+        # moments later. The caller then sees a transaction error from a
+        # statement that never failed, pointing at the wrong subsystem entirely.
+        # Degrading gracefully means the connection is still usable afterwards,
+        # which is the whole promise of this except clause.
+        try:
+            db = plucker._ctx.db
+            if db is not None:
+                db.execute("ROLLBACK")
+        except Exception:
+            pass  # no transaction open, or the connection is beyond saving
         return source
 
 
+def _source_root(source: str) -> str | None:
+    """The directory that must be readable for *source* to resolve.
+
+    A fledgling connection is sandboxed to its root (fledgling >= 0.13), so a
+    Plucker built without one is confined to the process working directory and
+    cannot read a source anywhere else: ``find(source="/srv/code/x/**/*.py")``
+    raised a permission error instead of returning results. These tools take
+    their target as an argument, so the target is the scope — rooting the
+    connection at the source's own directory keeps the sandbox meaningful while
+    letting an explicit path resolve.
+
+    Returns None when there is nothing to root at (a bare table/view name, or a
+    directory that does not exist), leaving pluckit's default behaviour alone.
+    """
+    if not source:
+        return None
+    # A bare identifier is a DuckDB table/view name, not a path.
+    if not any(sep in source for sep in ("/", os.sep)):
+        return None
+    # RELATIVE sources are already handled: they resolve against the working
+    # directory, which is what an un-rooted Plucker sandboxes to. Re-rooting
+    # them would be actively wrong — _filtered_source joins a relative source
+    # onto the connection's repo, so pointing that repo at the source's own
+    # directory turns `squackit/**/*.py` into `.../squackit/squackit/**/*.py`
+    # and the tool finds nothing.
+    if not os.path.isabs(source):
+        return None
+    head = re.split(r"[*?\[]", source, maxsplit=1)[0]
+    directory = head if head.endswith(("/", os.sep)) else os.path.dirname(head)
+    if not directory:
+        return None
+    directory = os.path.abspath(directory)
+    return directory if os.path.isdir(directory) else None
+
+
+def _cache_path(root: str | None) -> str:
+    """Where the AST cache database lives for a Plucker rooted at *root*.
+
+    DuckDB's filesystem allow-list is a property of the database INSTANCE, not
+    of the connection, and every connection to the same file shares one
+    instance. A single shared cache file therefore means the FIRST lockdown
+    wins for the life of the process: a plucker rooted at /srv/code/x reuses
+    the instance already locked to the working directory and is refused access
+    to its own source, with no indication that its root was ignored.
+
+    So a rooted plucker gets its own cache file, keyed by the root. It goes in
+    the temp directory rather than inside the root: a served corpus is mounted
+    read-only, and writing a database into a tree we were only asked to read is
+    rude even where it succeeds. Keying by root keeps the cache reusable across
+    processes, which is the point of persisting it at all.
+    """
+    if root is None:
+        return os.path.join(os.getcwd(), ".pluckit.duckdb")
+    digest = hashlib.sha256(os.path.abspath(root).encode()).hexdigest()[:16]
+    return os.path.join(tempfile.gettempdir(), f"squackit-ast-{digest}.duckdb")
+
+
 def _make_plucker(source: str, peek: str = DEFAULT_PEEK):
     """Create a Plucker with AstViewer and Search for tool execution.
 
@@ -135,7 +224,21 @@ def _make_plucker(source: str, peek: str = DEFAULT_PEEK):
     # parses with ``peek := 'none'`` and can only ever return NULL. Enabling the
     # cache moves the un-filtered path onto ``ast_select_from`` too, so both
     # paths return source text. It also stops re-parsing on every call.
-    p = Plucker(plugins=[AstViewer, Search], cache=True, peek=peek)
+    #
+    # The cache path is passed EXPLICITLY rather than left to `cache=True`.
+    # pluckit derives the default cache file from the repo (`<repo>/.pluckit.duckdb`),
+    # so rooting the connection at the source would also move the cache into the
+    # tree being analysed — which for a served corpus is a read-only mount, and
+    # for anyone else means writing a database into a repo they only asked us to
+    # read. Keeping it under the working directory preserves the location this
+    # had before the connection gained a root.
+    root = _source_root(source)
+    p = Plucker(
+        plugins=[AstViewer, Search],
+        cache=_cache_path(root),
+        peek=peek,
+        repo=root,
+    )
     p._code_source = _filtered_source(p, source, peek)
     return p
 

{squackit-0.8.0 → squackit-0.8.2}/squackit/workflows.py

@@ -95,8 +95,8 @@ def _sorted_table(con, macro_name, kwargs, sort_col, max_rows, descending=True):
 def explore(con, defaults, path=None):
     """First-contact codebase briefing."""
     # Scope patterns to path if provided
-    code_pattern = defaults.scoped_code_pattern(path) if path else defaults.code_pattern
-    doc_pattern = str(Path(path) / "**" / "*.md") if path else defaults.doc_pattern
+    code_pattern = defaults.scoped_code_pattern(path) if path else defaults.code_glob
+    doc_pattern = defaults.scoped_doc_pattern(path) if path else defaults.doc_glob
 
     sections = []
 
@@ -149,7 +149,9 @@ def investigate(con, defaults, name, file_pattern=None, path=None):
         # Precedence: explicit path -> runtime.active_root -> process cwd.
         # Runtime fallback lets a session set active_root once via
         # `config(set={"active_root": X})` instead of passing path= per call.
-        file_pattern = defaults.scoped_code_pattern(resolve_scope_path(path))
+        file_pattern = defaults.scoped_code_pattern(
+            resolve_scope_path(path, default=defaults.root)
+        )
 
     # 1. Find definitions matching the name. Fetch substring candidates, then
     #    prefer EXACT name matches: a deep-dive on `ensure_loaded` must not drag
@@ -269,7 +271,7 @@ def review(con, defaults, from_rev=None, to_rev=None, file_pattern=None):
     """Code review prep for a revision range."""
     from_rev = from_rev or defaults.from_rev
     to_rev = to_rev or defaults.to_rev
-    file_pattern = file_pattern or defaults.code_pattern
+    file_pattern = file_pattern or defaults.code_glob
 
     sections = []
 
@@ -349,7 +351,7 @@ def review(con, defaults, from_rev=None, to_rev=None, file_pattern=None):
 
 def search(con, defaults, query, file_pattern=None):
     """Multi-source search across code, docs, and git."""
-    file_pattern = file_pattern or defaults.code_pattern
+    file_pattern = file_pattern or defaults.code_glob
 
     sections = []
 
@@ -371,7 +373,7 @@ def search(con, defaults, query, file_pattern=None):
     # 3. Documentation sections matching the query
     sections.append(_section("Documentation", lambda: _table(
         con, "doc_outline",
-        {"file_pattern": defaults.doc_pattern, "search": query},
+        {"file_pattern": defaults.doc_glob, "search": query},
         max_rows=10,
     )))
 

{squackit-0.8.0 → squackit-0.8.2}/tests/test_defaults.py

@@ -46,11 +46,14 @@ class TestToolDefaults:
         for tool in code_tools:
             assert tool in TOOL_DEFAULTS
             assert "file_pattern" in TOOL_DEFAULTS[tool]
-            assert TOOL_DEFAULTS[tool]["file_pattern"] == "code_pattern"
+            # The ANCHORED accessor, not the raw pattern: a substituted value
+            # goes straight to DuckDB, which resolves a relative glob against
+            # the process cwd rather than the sandboxed project root.
+            assert TOOL_DEFAULTS[tool]["file_pattern"] == "code_glob"
 
     def test_doc_tools_mapped(self):
         assert "doc_outline" in TOOL_DEFAULTS
-        assert TOOL_DEFAULTS["doc_outline"]["file_pattern"] == "doc_pattern"
+        assert TOOL_DEFAULTS["doc_outline"]["file_pattern"] == "doc_glob"
 
     def test_git_tools_mapped(self):
         git_tools = ["file_changes", "file_diff", "structural_diff"]
@@ -60,12 +63,20 @@ class TestToolDefaults:
             assert TOOL_DEFAULTS[tool]["to_rev"] == "to_rev"
 
     def test_all_field_names_are_valid(self):
-        """Every value in TOOL_DEFAULTS must name a real ProjectDefaults field."""
-        valid_fields = {f.name for f in fields(ProjectDefaults)}
+        """Every value in TOOL_DEFAULTS must name something apply_defaults can
+        actually read off ProjectDefaults.
+
+        Checks attributes rather than dataclass fields: the pattern entries
+        name read-only properties (code_glob / doc_glob), which apply_defaults
+        reaches via getattr just the same. The point of the test is that a
+        typo here fails loudly at import rather than substituting None into a
+        query, and that survives the field-vs-property distinction.
+        """
+        probe = ProjectDefaults()
         for tool, mapping in TOOL_DEFAULTS.items():
-            for _param, field_name in mapping.items():
-                assert field_name in valid_fields, (
-                    f"{tool}: '{field_name}' is not a ProjectDefaults field"
+            for _param, attr_name in mapping.items():
+                assert hasattr(probe, attr_name), (
+                    f"{tool}: '{attr_name}' is not a ProjectDefaults attribute"
                 )
 
 
@@ -185,8 +196,16 @@ class TestInferDefaults:
     def con(self):
         return create_connection(repo=str(PROJECT_ROOT))
 
+    @requires_fledgling_source
     def test_code_pattern_is_python(self, con):
-        """This repo is primarily Python, so code_pattern should be **/*.py."""
+        """This repo is primarily Python, so code_pattern should be **/*.py.
+
+        Needs a source checkout, like its doc_pattern sibling below: an
+        installed fledgling wheel bundles sql/ as package data, so SQL
+        outnumbers Python in that layout and the inferred pattern is
+        legitimately **/*.sql. Asserting against the wheel fails on the
+        content of the dog-food corpus, not on the inference logic.
+        """
         defaults = infer_defaults(con, root=str(PROJECT_ROOT))
         assert "py" in defaults.code_pattern