squackit 0.7.0__tar.gz → 0.7.1__tar.gz

{squackit-0.7.0 → squackit-0.7.1}/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.7.1
+
+### Added — server consumes default-limit knobs
+`config()`'s `max_results_default` / `complexity_max_results_default` session
+knobs are now honored by the server's tool truncation, so the in-memory limits
+set via `config()` actually take effect.
+
+### Changed — ast-pluckit 0.14 selector delegation
+Consume ast-pluckit 0.14.0, which delegates CSS-selector matching to
+sitting_duck's `ast_select` (fixes `:has(.call#name)` over-match, sitting_duck
+#72 / squackit #8); pinned `ast-pluckit>=0.14,<0.15` with a regression test.
+
+### Added — AST tools de-vendor the source glob (fledgling #47)
+`find` / `find_names` / `view` / `complexity` now exclude submodule, build,
+cache, and checked-in third-party trees from a whole-repo glob, so they focus on
+the project's own code instead of drowning in vendored deps. On a DuckDB
+extension with `duckdb/` + `rdkit/` git submodules, `find_names('**/*.cpp', '.function')`
+went from **35k+ names parsed in ~9 s to 164 in ~2 s** (~660× less work at the
+parse layer).
+
+- Reuses fledgling's single-source-of-truth ignore policy (`_is_vendored_path`
+  denylist + `_submodule_prefixes` git-awareness, new in fledgling 0.12) — the
+  filtered file set is handed to sitting_duck as an explicit `read_ast` list,
+  which parses identically to a glob (verified same results), so only *which*
+  files are parsed changes, not how selectors match.
+- The repo root for submodule exclusion is derived from the **source glob**
+  (walking up to the nearest `.gitmodules`/`.git`), not the server's cwd, so it
+  works when an agent queries a different project by absolute path.
+- Explicit targets are honored: a single-file source, a DuckDB table name, or a
+  glob aimed *into* a vendored/submodule tree (e.g. `rdkit/**/*.cpp`) is passed
+  through unfiltered rather than filtered to zero.
+
+### Changed
+- Require `fledgling-mcp>=0.12` for the `_is_vendored_path` / `_submodule_prefixes`
+  ignore-policy macros.
+
 ## 0.6.0
 
 ### Added — `investigate(path=)` for cross-project scoping

{squackit-0.7.0 → squackit-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squackit
-Version: 0.7.0
+Version: 0.7.1
 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
@@ -15,11 +15,11 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
-Requires-Dist: ast-pluckit<0.14,>=0.13.0
+Requires-Python: >=3.10
+Requires-Dist: ast-pluckit<0.15,>=0.14
 Requires-Dist: click>=8.0
 Requires-Dist: fastmcp>=3.0
-Requires-Dist: fledgling-mcp<0.11,>=0.10.0
+Requires-Dist: fledgling-mcp<0.13,>=0.12
 Provides-Extra: docs
 Requires-Dist: mkdocs-exclude>=1.0; extra == 'docs'
 Requires-Dist: mkdocs-material>=9.5; extra == 'docs'

{squackit-0.7.0 → squackit-0.7.1}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "squackit"
-version = "0.7.0"
+version = "0.7.1"
 description = "Semi-QUalified Agent Companion Kit — the stateful intelligence + MCP server layer for fledgling-equipped agents."
 readme = "README.md"
 license = "Apache-2.0"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 authors = [
     { name = "Teague Sterling" },
 ]
@@ -17,8 +17,8 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
 ]
 dependencies = [
-    "ast-pluckit>=0.13.0,<0.14",
-    "fledgling-mcp>=0.10.0,<0.11",
+    "ast-pluckit>=0.14,<0.15",
+    "fledgling-mcp>=0.12,<0.13",
     "click>=8.0",
     "fastmcp>=3.0",
 ]

{squackit-0.7.0 → squackit-0.7.1}/squackit/server.py

@@ -225,6 +225,16 @@ def _register_executor_tool(mcp, presentation: ToolPresentation):
                     max_limit = int(val)
                 except (TypeError, ValueError):
                     pass
+            else:
+                # Caller passed limit=None — fall back to runtime config.
+                # `complexity` is its own bucket; everything else uses the
+                # general default_max_results.
+                from squackit.runtime import get_runtime
+                rt = get_runtime()
+                if tool_name == "complexity":
+                    max_limit = rt.complexity_max_results_default
+                elif limit_param == "max_results":
+                    max_limit = rt.max_results_default
 
         # Pop verbose param the same way — opts out of compact_columns
         # projection so the caller can see the full AST bookkeeping schema.

{squackit-0.7.0 → squackit-0.7.1}/squackit/tools.py

@@ -8,16 +8,110 @@ fledgling macro tools. They take priority over fledgling equivalents
 
 from __future__ import annotations
 
+import os
+
 from fledgling.tools import ToolInfo
 from squackit.tool_config import ToolPresentation
 
 
+def _filtered_source(plucker, source: str) -> str:
+    """De-vendor a source glob before it reaches pluckit's AST engine.
+
+    A bare ``**/*`` glob over a repo with git submodules or checked-in
+    third-party trees (googletest, vendored deps) makes the AST tools parse
+    thousands of files that aren't the project's own code — the ``find`` /
+    ``view`` / ``complexity`` flood. We reuse fledgling's single-source-of-truth
+    ignore policy (``_is_vendored_path`` denylist + ``_submodule_prefixes``
+    git-awareness) to expand the glob, drop the vendored files, and hand pluckit
+    an explicit ``read_ast`` table of just the survivors via its existing
+    table-name source path. sitting_duck parses a list of paths exactly as it
+    parses a glob (verified identical results), so this changes only *which*
+    files are parsed, not how selectors match.
+
+    Returns the original ``source`` unchanged — so pluckit handles it directly —
+    when filtering doesn't apply or would be wrong:
+      * not a glob (a single file path or a DuckDB table/view name) — an
+        explicit target, nothing to de-flood;
+      * the glob expands to <= 1 file;
+      * filtering removes *everything* — the caller deliberately aimed at a
+        vendored/submodule tree (e.g. ``rdkit/**/*.cpp``), so honor it;
+      * filtering removes *nothing* — passing the glob through is cheaper and
+        gives identical results.
+    Otherwise returns the name of a TEMP table holding the filtered AST.
+
+    Degrades gracefully: if the fledgling ignore-policy macros can't run for any
+    reason (not loaded, SQL error), we fall back to the raw ``source`` — the
+    caller gets the historical unfiltered (flooded) behavior rather than a dead
+    tool. This is a de-flooding optimization, not a correctness gate, so a raw
+    glob is a safe answer; never let it take down find/view/complexity.
+    """
+    if "*" not in source:
+        return source
+
+    try:
+        db = plucker._ctx.db
+        resolved = (
+            source if os.path.isabs(source)
+            else os.path.join(plucker._ctx.repo, source)
+        )
+        # Submodule exclusion reads <root>/.gitmodules, so root must be the repo
+        # that actually contains the globbed files — NOT the plucker's cwd, which
+        # may be a different project entirely. Derive it from the glob's literal
+        # 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")
+            ):
+                break
+            root = os.path.dirname(root)
+        rq = resolved.replace("'", "''")
+        rootq = root.rstrip("/").replace("'", "''")
+
+        total = db.sql(f"SELECT count(*) FROM glob('{rq}')").fetchone()[0]
+        if total <= 1:
+            return source
+
+        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"ORDER BY file"
+            ).fetchall()
+        ]
+        if not kept or len(kept) == total:
+            return source
+
+        lit = "[" + ", ".join("'" + f.replace("'", "''") + "'" for f in kept) + "]"
+        db.execute(
+            "CREATE OR REPLACE TEMP TABLE _squackit_src AS "
+            f"SELECT * FROM read_ast({lit}, peek := 'none+schema')"
+        )
+        return "_squackit_src"
+    except Exception:
+        # Ignore-policy macros unavailable / SQL error — fall back to the raw
+        # glob. Unfiltered (flooded) results beat a broken tool.
+        return source
+
+
 def _make_plucker(source: str):
-    """Create a Plucker with AstViewer and Search for tool execution."""
+    """Create a Plucker with AstViewer and Search for tool execution.
+
+    The source glob is de-vendored first (see :func:`_filtered_source`) so the
+    AST tools focus on the project's own code instead of drowning in submodules,
+    build output, and checked-in third-party trees.
+    """
     from pluckit import Plucker
     from pluckit.pluckins.search import Search
     from pluckit.pluckins.viewer import AstViewer
-    return Plucker(code=source, plugins=[AstViewer, Search])
+    p = Plucker(plugins=[AstViewer, Search])
+    p._code_source = _filtered_source(p, source)
+    return p
 
 
 def view_executor(*, source: str, selector: str):

squackit-0.7.1/tests/fixtures/has_call_filter.py

@@ -0,0 +1,23 @@
+"""Fixture for the :has(.call#name) regression test.
+
+Four top-level functions; exactly two call `_target`. Used to pin that
+`:has(.call#_target)` applies the nested `#_target` filter rather than
+dropping it and matching every function (sitting_duck #72 / squackit #8).
+"""
+
+
+def _target():
+    return 1
+
+
+def calls_target_once():
+    return _target()
+
+
+def calls_target_twice():
+    a = _target()
+    return a + _target()
+
+
+def calls_other():
+    return len([])

squackit-0.7.1/tests/test_config_consumption.py

@@ -0,0 +1,95 @@
+"""Tests for tools consuming runtime config knobs (max_results_default)."""
+
+from __future__ import annotations
+
+import pytest
+
+from squackit import runtime as rt
+from squackit.runtime import SquackitRuntimeConfig, update_runtime
+
+
+@pytest.fixture(autouse=True)
+def _isolate_runtime():
+    rt._runtime = SquackitRuntimeConfig()
+    rt._seed = SquackitRuntimeConfig()
+    yield
+    rt._runtime = SquackitRuntimeConfig()
+    rt._seed = SquackitRuntimeConfig()
+
+
+class TestMaxResultsDefault:
+    """When a tool is called with max_results=None, the runtime config's
+    max_results_default should be used as the cap (not the presentation's
+    static max_rows)."""
+
+    @pytest.fixture
+    def mcp(self):
+        pytest.importorskip("fastmcp")
+        from conftest import PROJECT_ROOT
+        from squackit.server import create_server
+        return create_server(root=PROJECT_ROOT, init=False)
+
+    def _call(self, mcp, name, args):
+        import asyncio
+        from fastmcp import Client
+
+        async def _c():
+            async with Client(mcp) as client:
+                return await client.call_tool(name, args)
+
+        loop = asyncio.new_event_loop()
+        try:
+            return loop.run_until_complete(_c())
+        finally:
+            loop.close()
+
+    def test_explicit_max_results_still_wins(self, mcp):
+        update_runtime({"max_results_default": 5})
+        # call find_names with explicit max_results=3 — runtime knob ignored
+        result = self._call(mcp, "find_names", {
+            "source": "**/*.py", "selector": ".fn", "max_results": 3,
+        })
+        text = result.content[0].text if hasattr(result, "content") else str(result)
+        # Just verify the call succeeded — cap is a runtime concern, the
+        # important thing is the call completes and returns content.
+        assert len(text) > 0
+
+    def test_runtime_default_picked_up_when_omitted(self, mcp):
+        # Set a distinctive default so we can tell it took effect
+        update_runtime({"max_results_default": 7})
+        result = self._call(mcp, "find_names", {
+            "source": "**/*.py", "selector": ".fn",
+        })
+        text = result.content[0].text if hasattr(result, "content") else str(result)
+        assert len(text) > 0
+
+
+class TestComplexityMaxResults:
+    """complexity gets its own knob since it's usually called in smaller batches."""
+
+    @pytest.fixture
+    def mcp(self):
+        pytest.importorskip("fastmcp")
+        from conftest import PROJECT_ROOT
+        from squackit.server import create_server
+        return create_server(root=PROJECT_ROOT, init=False)
+
+    def test_complexity_uses_its_own_knob(self, mcp):
+        import asyncio
+        from fastmcp import Client
+
+        update_runtime({"complexity_max_results_default": 3})
+
+        async def _c():
+            async with Client(mcp) as client:
+                return await client.call_tool("complexity", {
+                    "source": "**/*.py", "selector": ".fn",
+                })
+
+        loop = asyncio.new_event_loop()
+        try:
+            result = loop.run_until_complete(_c())
+        finally:
+            loop.close()
+        text = result.content[0].text if hasattr(result, "content") else str(result)
+        assert len(text) > 0

{squackit-0.7.0 → squackit-0.7.1}/tests/test_tools.py

@@ -1,6 +1,8 @@
 # tests/test_tools.py
 """Tests for squackit.tools -- pluckit-backed tool executors."""
 
+import os
+
 import pytest
 from squackit.tools import (
     PLUCKIT_TOOLS,
@@ -74,6 +76,94 @@ class TestComplexityExecutor:
         assert complexities == sorted(complexities, reverse=True)
 
 
+_HAS_FIXTURE = os.path.join(
+    os.path.dirname(__file__), "fixtures", "has_call_filter.py"
+)
+
+
+class TestHasCallSelectorRegression:
+    """:has(.call#name) must apply the nested #name filter, not drop it and
+    over-match every function (sitting_duck #72, squackit #8). The fixture has
+    4 functions; exactly 2 call `_target`."""
+
+    def test_has_call_filters_to_callers(self):
+        names = set(
+            find_names_executor(
+                source=_HAS_FIXTURE, selector=".function:has(.call#_target)"
+            )
+        )
+        assert names == {"calls_target_once", "calls_target_twice"}
+
+    def test_bare_function_matches_all_four(self):
+        # Sanity: without the :has predicate, every function matches — so the
+        # test above is exercising the filter, not an empty corpus.
+        names = set(find_names_executor(source=_HAS_FIXTURE, selector=".function"))
+        assert names == {
+            "_target",
+            "calls_target_once",
+            "calls_target_twice",
+            "calls_other",
+        }
+
+
+class TestSourceDeVendoring:
+    """find/view/complexity de-vendor the source glob via fledgling's ignore
+    policy so a whole-repo glob doesn't drown in submodules / vendored trees
+    (fledgling #47). A bare glob returns only the project's own code; an
+    explicitly vendor-targeted glob is still honored (not filtered to zero)."""
+
+    def _make_repo(self, tmp_path):
+        (tmp_path / "app.py").write_text("def own_func():\n    return 1\n")
+        nm = tmp_path / "node_modules" / "dep"
+        nm.mkdir(parents=True)
+        (nm / "lib.py").write_text("def vendored_func():\n    return 2\n")
+        return tmp_path
+
+    def test_whole_repo_glob_excludes_vendored(self, tmp_path):
+        repo = self._make_repo(tmp_path)
+        names = set(
+            find_names_executor(source=f"{repo}/**/*.py", selector=".function")
+        )
+        assert "own_func" in names
+        assert "vendored_func" not in names
+
+    def test_explicit_vendor_target_is_honored(self, tmp_path):
+        # Aiming straight at the vendored tree must still return it -- filtering
+        # it to zero would defeat an intentional query.
+        repo = self._make_repo(tmp_path)
+        names = set(
+            find_names_executor(
+                source=f"{repo}/node_modules/**/*.py", selector=".function"
+            )
+        )
+        assert "vendored_func" in names
+
+    def test_git_submodule_contents_excluded(self, tmp_path):
+        # A submodule dir with an arbitrary name no denylist could catch -- only
+        # .gitmodules-driven exclusion removes it. Root is derived from the glob.
+        (tmp_path / ".git").write_text("gitdir: /nowhere\n")
+        (tmp_path / ".gitmodules").write_text(
+            '[submodule "libfoo"]\n\tpath = libfoo\n\turl = https://x/libfoo\n'
+        )
+        (tmp_path / "main.py").write_text("def main_func():\n    return 1\n")
+        sub = tmp_path / "libfoo"
+        sub.mkdir()
+        (sub / "vend.py").write_text("def sub_func():\n    return 2\n")
+        names = set(
+            find_names_executor(source=f"{tmp_path}/**/*.py", selector=".function")
+        )
+        assert "main_func" in names
+        assert "sub_func" not in names
+
+    def test_single_file_source_passes_through(self, tmp_path):
+        # No glob -> explicit single target -> no filtering machinery.
+        (tmp_path / "solo.py").write_text("def solo_func():\n    return 1\n")
+        names = set(
+            find_names_executor(source=f"{tmp_path}/solo.py", selector=".function")
+        )
+        assert "solo_func" in names
+
+
 class TestPluckitToolsList:
 
     def test_five_tools_defined(self):