squackit 0.3.3__tar.gz → 0.4.0__tar.gz

{squackit-0.3.3 → squackit-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squackit
-Version: 0.3.3
+Version: 0.4.0
 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,7 +16,7 @@ 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.7.0
+Requires-Dist: ast-pluckit>=0.9.0
 Requires-Dist: click>=8.0
 Requires-Dist: fastmcp>=3.0
 Provides-Extra: docs

{squackit-0.3.3 → squackit-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "squackit"
-version = "0.3.3"
+version = "0.4.0"
 description = "Semi-QUalified Agent Companion Kit — the stateful intelligence + MCP server layer for fledgling-equipped agents."
 readme = "README.md"
 license = "Apache-2.0"
@@ -17,7 +17,7 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
 ]
 dependencies = [
-    "ast-pluckit>=0.7.0",
+    "ast-pluckit>=0.9.0",
     "click>=8.0",
     "fastmcp>=3.0",
 ]

{squackit-0.3.3 → squackit-0.4.0}/squackit/__init__.py

@@ -1,3 +1,3 @@
 """squackit: Semi-QUalified Agent Companion Kit — the stateful intelligence + MCP server layer for fledgling-equipped agents."""
 
-__version__ = "0.3.3"
+__version__ = "0.4.0"

{squackit-0.3.3 → squackit-0.4.0}/squackit/cli.py

@@ -95,10 +95,12 @@ class ToolGroup(click.Group):
 def _get_registry():
     """Lazily build the tool registry."""
     from pluckit import Plucker
-    from squackit.tools import PLUCKIT_TOOLS
-    p = Plucker()
+    from pluckit.pluckins.viewer import AstViewer
+    from squackit.tools import PLUCKIT_TOOLS, collect_pluckin_tools
+    p = Plucker(plugins=[AstViewer])
     con = p.connection
-    return build_tool_registry(con._tools, extra_tools=PLUCKIT_TOOLS), con
+    extra = list(PLUCKIT_TOOLS) + collect_pluckin_tools(p)
+    return build_tool_registry(con._tools, extra_tools=extra), con
 
 
 def _format_result(result, presentation, json_output):
@@ -286,18 +288,29 @@ def pluck(click_ctx, argv):
         squackit pluck "src/api.py" find .fn#handler view
         squackit pluck "**/*.py" find .fn names -- find .class names
 
+    Mutations (rename, replaceWith, wrap, etc.) are blocked by default.
+    Pass --write to allow them. Example:
+
+        squackit pluck --write "src/api.py" find .fn#old rename new
+
     See pluckit documentation for full chain grammar.
     """
     from pluckit import Chain
     from squackit.formatting import _format_markdown_table, format_json
+    from squackit.tools import _chain_mutation_ops
 
     if not argv:
         click.echo(click_ctx.get_help())
         return
 
+    # Extract squackit-level --write flag before passing to pluckit
+    argv_list = list(argv)
+    write_mode = "--write" in argv_list
+    if write_mode:
+        argv_list = [a for a in argv_list if a != "--write"]
+
     try:
-        chain = Chain.from_argv(list(argv))
-        result = chain.evaluate()
+        chain = Chain.from_argv(argv_list)
     except SystemExit:
         raise
     except Exception as e:
@@ -305,6 +318,23 @@ def pluck(click_ctx, argv):
         click_ctx.exit(1)
         return
 
+    mutations = _chain_mutation_ops(chain)
+    if mutations and not write_mode:
+        click.echo(
+            f"Error: chain contains mutation operations: {', '.join(mutations)}\n"
+            f"Pass --write to allow mutations (they modify source files).",
+            err=True,
+        )
+        click_ctx.exit(1)
+        return
+
+    try:
+        result = chain.evaluate()
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        click_ctx.exit(1)
+        return
+
     json_output = click_ctx.obj.get("json", False) if click_ctx.obj else False
     data = result.get("data")
     result_type = result.get("type")

{squackit-0.3.3 → squackit-0.4.0}/squackit/server.py

@@ -62,8 +62,13 @@ def create_server(
         A FastMCP server instance ready to .run().
     """
     from fastmcp import FastMCP
+    from pluckit.pluckins.viewer import AstViewer
 
-    con = Plucker(repo=root, profile=profile, modules=modules, init=init).connection
+    plucker = Plucker(
+        repo=root, profile=profile, modules=modules, init=init,
+        plugins=[AstViewer],
+    )
+    con = plucker.connection
     mcp = FastMCP(name)
 
     # Infer smart defaults, merge with config file overrides
@@ -78,8 +83,9 @@ def create_server(
     mcp.access_log = access_log
 
     # Register each macro as an MCP tool
-    from squackit.tools import PLUCKIT_TOOLS
-    registry = build_tool_registry(con._tools, extra_tools=PLUCKIT_TOOLS)
+    from squackit.tools import PLUCKIT_TOOLS, collect_pluckin_tools
+    extra = list(PLUCKIT_TOOLS) + collect_pluckin_tools(plucker)
+    registry = build_tool_registry(con._tools, extra_tools=extra)
     for presentation in registry.values():
         _register_tool(mcp, con, presentation, defaults, cache, access_log)
 

{squackit-0.3.3 → squackit-0.4.0}/squackit/tools.py

@@ -15,7 +15,7 @@ from squackit.tool_config import ToolPresentation
 def _make_plucker(source: str):
     """Create a Plucker with AstViewer for tool execution."""
     from pluckit import Plucker
-    from pluckit.plugins.viewer import AstViewer
+    from pluckit.pluckins.viewer import AstViewer
     return Plucker(code=source, plugins=[AstViewer])
 
 
@@ -54,18 +54,60 @@ def complexity_executor(*, source: str, selector: str):
     return rel
 
 
-def pluck_executor(*, argv: str):
+def _chain_mutation_ops(chain) -> list[str]:
+    """Return the list of mutation op names present in the chain (in order)."""
+    from pluckit.chain import Chain as _Chain
+    return [step.op for step in chain.steps if step.op in _Chain._MUTATION_OPS]
+
+
+def collect_pluckin_tools(plucker) -> list:
+    """Collect squackit tools from a Plucker's registered pluckins.
+
+    Pluckins that want to contribute squackit tools expose a
+    ``squackit_tools()`` method returning a list of ToolPresentation
+    objects. This function walks the Plucker's pluckin registry and
+    collects tools from any pluckin that implements the method.
+
+    Plugin authors can add squackit integration without depending on
+    squackit at import time — the import lives inside the method body
+    and only fires when squackit actually calls it.
+    """
+    tools: list = []
+    registry = getattr(plucker, "_registry", None)
+    if registry is None:
+        return tools
+    pluckins = getattr(registry, "pluckins", None)
+    if pluckins is None:
+        return tools
+    for pluckin in pluckins:
+        fn = getattr(pluckin, "squackit_tools", None)
+        if callable(fn):
+            try:
+                tools.extend(fn())
+            except Exception:
+                # A broken pluckin shouldn't break the whole registry.
+                # Squackit's server/CLI will surface the error contextually.
+                pass
+    return tools
+
+
+def pluck_executor(*, argv: str, allow_mutations: str | bool = False):
     """Execute a pluckit chain from a whitespace-separated command string.
 
     Accepts the same grammar as `squackit pluck` on the CLI:
         "source_pattern [method [arg]]... [terminal]"
 
+    **Mutation safety:** chains containing mutation operations (rename,
+    replaceWith, wrap, remove, etc.) are blocked by default. Pass
+    ``allow_mutations=true`` to opt in. Agents should only enable this
+    when the user has explicitly authorized code changes.
+
     Returns a JSON-serialized chain result: {chain, type, data}.
 
     Examples:
         pluck(argv="**/*.py find .fn names")
         pluck(argv="--plugin AstViewer src/api.py find .fn#handler view")
-        pluck(argv="**/*.py find .fn names reset find .class names")
+        pluck(argv="**/*.py find .fn#old rename new_name", allow_mutations=True)
     """
     import shlex
     import json
@@ -76,6 +118,23 @@ def pluck_executor(*, argv: str):
         return json.dumps({"error": "Empty argv"}, indent=2)
 
     chain = Chain.from_argv(tokens)
+
+    # Coerce string "true"/"false" from MCP clients to bool
+    if isinstance(allow_mutations, str):
+        allow = allow_mutations.lower() in ("true", "1", "yes")
+    else:
+        allow = bool(allow_mutations)
+
+    mutations = _chain_mutation_ops(chain)
+    if mutations and not allow:
+        return json.dumps({
+            "error": "blocked: chain contains mutation operations",
+            "mutations": mutations,
+            "hint": "Set allow_mutations=true to enable. Mutations modify "
+                    "source files — ensure the user has authorized changes.",
+            "chain": chain.to_dict(),
+        }, indent=2)
+
     result = chain.evaluate()
     return json.dumps(result, indent=2, default=str)
 
@@ -128,7 +187,7 @@ COMPLEXITY_TOOL = ToolPresentation(
 PLUCK_TOOL = ToolPresentation(
     info=ToolInfo(
         macro_name="pluck",
-        params=["argv"],
+        params=["argv", "allow_mutations"],
         description=(
             "Execute a pluckit chain query. Pass a whitespace-separated "
             "command: 'source_pattern [method [arg]]... [terminal]'. "
@@ -136,7 +195,8 @@ PLUCK_TOOL = ToolPresentation(
             "Use 'reset' to start a new chain from the source. "
             "Example: '**/*.py find .fn containing cache names'. "
             "Use '--plugin AstViewer' prefix for view terminals. "
-            "Returns JSON: {chain, type, data}."
+            "Mutations (rename, replaceWith, wrap, etc.) are blocked "
+            "unless allow_mutations=true. Returns JSON: {chain, type, data}."
         ),
         required=["argv"],
     ),

{squackit-0.3.3 → squackit-0.4.0}/tests/test_cli_tools.py

@@ -139,3 +139,20 @@ class TestPluckCommand:
         assert result.exit_code == 0, result.output
         # Should show class names (last chain) not fn names
         assert "ToolGroup" in result.output or "LazyToolGroup" in result.output
+
+    def test_pluck_mutation_blocked_by_default(self):
+        result = runner.invoke(cli, ["pluck", "squackit/cli.py",
+                                      "find", ".fn#nonexistent", "rename", "foo"])
+        assert result.exit_code != 0
+        assert "mutation" in result.output.lower()
+        assert "rename" in result.output
+
+    def test_pluck_mutation_allowed_with_write(self):
+        # Target nonexistent function so no actual mutation occurs,
+        # but block check should pass
+        result = runner.invoke(cli, ["pluck", "--write", "squackit/cli.py",
+                                      "find", ".fn#__definitely_not_a_function__",
+                                      "rename", "bar"])
+        # Should not be blocked by mutation check; may succeed or fail for
+        # other reasons, but the mutation message should not appear
+        assert "chain contains mutation operations" not in result.output

{squackit-0.3.3 → squackit-0.4.0}/tests/test_smoke.py

@@ -3,7 +3,7 @@
 
 def test_import_squackit():
     import squackit
-    assert squackit.__version__ == "0.3.3"
+    assert squackit.__version__ == "0.4.0"
 
 
 def test_fledgling_available():

squackit-0.4.0/tests/test_tools.py

@@ -0,0 +1,282 @@
+# tests/test_tools.py
+"""Tests for squackit.tools -- pluckit-backed tool executors."""
+
+import pytest
+from squackit.tools import (
+    PLUCKIT_TOOLS,
+    view_executor,
+    find_executor,
+    find_names_executor,
+    complexity_executor,
+    pluck_executor,
+)
+
+
+class TestViewExecutor:
+
+    def test_returns_view_object(self):
+        from pluckit.pluckins.viewer import View
+        result = view_executor(source="squackit/**/*.py", selector=".fn")
+        assert isinstance(result, View)
+
+    def test_view_has_markdown(self):
+        result = view_executor(source="squackit/cli.py", selector=".fn#cli")
+        assert "def cli" in result.markdown
+
+    def test_view_has_blocks(self):
+        result = view_executor(source="squackit/**/*.py", selector=".fn")
+        assert len(result.blocks) > 0
+
+
+class TestFindExecutor:
+
+    def test_returns_relation(self):
+        result = find_executor(source="squackit/**/*.py", selector=".fn")
+        assert hasattr(result, "columns")
+        assert hasattr(result, "fetchall")
+
+    def test_relation_has_expected_columns(self):
+        result = find_executor(source="squackit/**/*.py", selector=".fn")
+        assert "name" in result.columns
+        assert "file_path" in result.columns
+        assert "start_line" in result.columns
+
+    def test_finds_known_function(self):
+        result = find_executor(source="squackit/cli.py", selector=".fn#cli")
+        rows = result.fetchall()
+        assert len(rows) >= 1
+
+
+class TestFindNamesExecutor:
+
+    def test_returns_list_of_strings(self):
+        result = find_names_executor(source="squackit/**/*.py", selector=".fn")
+        assert isinstance(result, list)
+        assert all(isinstance(n, str) for n in result)
+
+    def test_finds_known_function(self):
+        result = find_names_executor(source="squackit/cli.py", selector=".fn")
+        assert "cli" in result
+
+
+class TestComplexityExecutor:
+
+    def test_returns_relation(self):
+        result = complexity_executor(source="squackit/**/*.py", selector=".fn")
+        assert hasattr(result, "columns")
+        assert "complexity" in result.columns
+
+    def test_ordered_by_complexity_desc(self):
+        result = complexity_executor(source="squackit/**/*.py", selector=".fn")
+        rows = result.fetchall()
+        cx_idx = result.columns.index("complexity")
+        complexities = [r[cx_idx] for r in rows]
+        assert complexities == sorted(complexities, reverse=True)
+
+
+class TestPluckitToolsList:
+
+    def test_five_tools_defined(self):
+        assert len(PLUCKIT_TOOLS) == 5
+
+    def test_all_have_executors(self):
+        for tp in PLUCKIT_TOOLS:
+            assert tp.executor is not None
+
+    def test_tool_names(self):
+        names = {tp.name for tp in PLUCKIT_TOOLS}
+        assert names == {"view", "find", "find_names", "complexity", "pluck"}
+
+    def test_selector_tools_require_source_and_selector(self):
+        for tp in PLUCKIT_TOOLS:
+            if tp.name == "pluck":
+                continue
+            assert "source" in tp.required
+            assert "selector" in tp.required
+
+    def test_pluck_requires_argv(self):
+        pluck = next(tp for tp in PLUCKIT_TOOLS if tp.name == "pluck")
+        assert "argv" in pluck.required
+
+
+class TestPluckExecutor:
+
+    def test_returns_json_string(self):
+        import json
+        result = pluck_executor(argv="squackit/cli.py find .fn names")
+        parsed = json.loads(result)
+        assert "chain" in parsed
+        assert "type" in parsed
+        assert "data" in parsed
+
+    def test_find_names(self):
+        import json
+        result = pluck_executor(argv="squackit/cli.py find .fn names")
+        parsed = json.loads(result)
+        assert parsed["type"] == "names"
+        assert isinstance(parsed["data"], list)
+        assert "cli" in parsed["data"]
+
+    def test_count(self):
+        import json
+        result = pluck_executor(argv="squackit/cli.py find .fn count")
+        parsed = json.loads(result)
+        assert parsed["type"] == "count"
+        assert isinstance(parsed["data"], int)
+        assert parsed["data"] > 0
+
+    def test_view_with_plugin(self):
+        import json
+        result = pluck_executor(
+            argv="--plugin AstViewer squackit/cli.py find .fn#cli view"
+        )
+        parsed = json.loads(result)
+        assert parsed["type"] == "view"
+        # data is a dict with blocks
+        assert "blocks" in parsed["data"]
+
+    def test_empty_argv_returns_error(self):
+        import json
+        result = pluck_executor(argv="")
+        parsed = json.loads(result)
+        assert "error" in parsed
+
+
+class TestPluckMutationSafety:
+
+    def test_mutation_blocked_by_default(self):
+        import json
+        # rename is a mutation op
+        result = pluck_executor(argv="squackit/cli.py find .fn#nonexistent rename foo")
+        parsed = json.loads(result)
+        assert "error" in parsed
+        assert "blocked" in parsed["error"]
+        assert "rename" in parsed["mutations"]
+
+    def test_mutation_blocked_reports_all_ops(self):
+        import json
+        result = pluck_executor(
+            argv="squackit/cli.py find .fn#x rename new wrap before after"
+        )
+        parsed = json.loads(result)
+        assert "error" in parsed
+        assert "rename" in parsed["mutations"]
+        assert "wrap" in parsed["mutations"]
+
+    def test_mutation_allowed_with_flag_string(self):
+        import json
+        # Target a nonexistent fn so no actual mutation happens, but the
+        # block check should pass and evaluation should proceed
+        result = pluck_executor(
+            argv="squackit/cli.py find .fn#__definitely_not_a_function__ rename bar",
+            allow_mutations="true",
+        )
+        parsed = json.loads(result)
+        # Should NOT be blocked — may have a different error or succeed
+        assert parsed.get("error", "").startswith("blocked") is False
+
+    def test_mutation_allowed_with_flag_bool(self):
+        import json
+        result = pluck_executor(
+            argv="squackit/cli.py find .fn#__definitely_not_a_function__ rename bar",
+            allow_mutations=True,
+        )
+        parsed = json.loads(result)
+        assert parsed.get("error", "").startswith("blocked") is False
+
+    def test_non_mutation_chain_runs_normally(self):
+        import json
+        # No mutation ops — should run regardless of allow_mutations
+        result = pluck_executor(argv="squackit/cli.py find .fn names")
+        parsed = json.loads(result)
+        assert "error" not in parsed
+        assert parsed["type"] == "names"
+
+
+class TestChainMutationOps:
+
+    def test_detects_rename(self):
+        from pluckit import Chain
+        from squackit.tools import _chain_mutation_ops
+        chain = Chain.from_argv(["squackit/cli.py", "find", ".fn", "rename", "new"])
+        assert _chain_mutation_ops(chain) == ["rename"]
+
+    def test_detects_multiple(self):
+        from pluckit import Chain
+        from squackit.tools import _chain_mutation_ops
+        chain = Chain.from_argv([
+            "squackit/cli.py", "find", ".fn", "rename", "new",
+            "wrap", "before", "after",
+        ])
+        assert _chain_mutation_ops(chain) == ["rename", "wrap"]
+
+    def test_no_mutations_returns_empty(self):
+        from pluckit import Chain
+        from squackit.tools import _chain_mutation_ops
+        chain = Chain.from_argv(["squackit/cli.py", "find", ".fn", "names"])
+        assert _chain_mutation_ops(chain) == []
+
+
+class TestCollectPluckinTools:
+    """collect_pluckin_tools walks registered pluckins and calls squackit_tools()."""
+
+    def test_empty_registry_returns_empty(self):
+        from pluckit import Plucker
+        from squackit.tools import collect_pluckin_tools
+        p = Plucker()  # no plugins
+        assert collect_pluckin_tools(p) == []
+
+    def test_pluckin_without_squackit_tools_skipped(self):
+        from pluckit import Plucker
+        from pluckit.pluckins.viewer import AstViewer
+        from squackit.tools import collect_pluckin_tools
+        # AstViewer doesn't implement squackit_tools — should be skipped silently
+        p = Plucker(plugins=[AstViewer])
+        assert collect_pluckin_tools(p) == []
+
+    def test_pluckin_with_squackit_tools_collected(self):
+        from pluckit import Plucker
+        from pluckit.pluckins.base import Pluckin
+        from fledgling.tools import ToolInfo
+        from squackit.tool_config import ToolPresentation
+        from squackit.tools import collect_pluckin_tools
+
+        def exec_fn(*, x: str):
+            return [x]
+
+        sentinel = ToolPresentation(
+            info=ToolInfo(
+                macro_name="_test_sentinel",
+                params=["x"],
+                description="test tool",
+                required=["x"],
+            ),
+            executor=exec_fn,
+        )
+
+        class MyPluckin(Pluckin):
+            name = "MyPluckin"
+            methods = {}
+
+            def squackit_tools(self):
+                return [sentinel]
+
+        p = Plucker(plugins=[MyPluckin])
+        tools = collect_pluckin_tools(p)
+        assert sentinel in tools
+
+    def test_broken_squackit_tools_does_not_crash(self):
+        from pluckit import Plucker
+        from pluckit.pluckins.base import Pluckin
+        from squackit.tools import collect_pluckin_tools
+
+        class BrokenPluckin(Pluckin):
+            name = "BrokenPluckin"
+            methods = {}
+
+            def squackit_tools(self):
+                raise RuntimeError("intentional")
+
+        p = Plucker(plugins=[BrokenPluckin])
+        # Should return empty, not crash
+        assert collect_pluckin_tools(p) == []

squackit-0.3.3/tests/test_tools.py

@@ -1,142 +0,0 @@
-# tests/test_tools.py
-"""Tests for squackit.tools -- pluckit-backed tool executors."""
-
-import pytest
-from squackit.tools import (
-    PLUCKIT_TOOLS,
-    view_executor,
-    find_executor,
-    find_names_executor,
-    complexity_executor,
-    pluck_executor,
-)
-
-
-class TestViewExecutor:
-
-    def test_returns_view_object(self):
-        from pluckit.plugins.viewer import View
-        result = view_executor(source="squackit/**/*.py", selector=".fn")
-        assert isinstance(result, View)
-
-    def test_view_has_markdown(self):
-        result = view_executor(source="squackit/cli.py", selector=".fn#cli")
-        assert "def cli" in result.markdown
-
-    def test_view_has_blocks(self):
-        result = view_executor(source="squackit/**/*.py", selector=".fn")
-        assert len(result.blocks) > 0
-
-
-class TestFindExecutor:
-
-    def test_returns_relation(self):
-        result = find_executor(source="squackit/**/*.py", selector=".fn")
-        assert hasattr(result, "columns")
-        assert hasattr(result, "fetchall")
-
-    def test_relation_has_expected_columns(self):
-        result = find_executor(source="squackit/**/*.py", selector=".fn")
-        assert "name" in result.columns
-        assert "file_path" in result.columns
-        assert "start_line" in result.columns
-
-    def test_finds_known_function(self):
-        result = find_executor(source="squackit/cli.py", selector=".fn#cli")
-        rows = result.fetchall()
-        assert len(rows) >= 1
-
-
-class TestFindNamesExecutor:
-
-    def test_returns_list_of_strings(self):
-        result = find_names_executor(source="squackit/**/*.py", selector=".fn")
-        assert isinstance(result, list)
-        assert all(isinstance(n, str) for n in result)
-
-    def test_finds_known_function(self):
-        result = find_names_executor(source="squackit/cli.py", selector=".fn")
-        assert "cli" in result
-
-
-class TestComplexityExecutor:
-
-    def test_returns_relation(self):
-        result = complexity_executor(source="squackit/**/*.py", selector=".fn")
-        assert hasattr(result, "columns")
-        assert "complexity" in result.columns
-
-    def test_ordered_by_complexity_desc(self):
-        result = complexity_executor(source="squackit/**/*.py", selector=".fn")
-        rows = result.fetchall()
-        cx_idx = result.columns.index("complexity")
-        complexities = [r[cx_idx] for r in rows]
-        assert complexities == sorted(complexities, reverse=True)
-
-
-class TestPluckitToolsList:
-
-    def test_five_tools_defined(self):
-        assert len(PLUCKIT_TOOLS) == 5
-
-    def test_all_have_executors(self):
-        for tp in PLUCKIT_TOOLS:
-            assert tp.executor is not None
-
-    def test_tool_names(self):
-        names = {tp.name for tp in PLUCKIT_TOOLS}
-        assert names == {"view", "find", "find_names", "complexity", "pluck"}
-
-    def test_selector_tools_require_source_and_selector(self):
-        for tp in PLUCKIT_TOOLS:
-            if tp.name == "pluck":
-                continue
-            assert "source" in tp.required
-            assert "selector" in tp.required
-
-    def test_pluck_requires_argv(self):
-        pluck = next(tp for tp in PLUCKIT_TOOLS if tp.name == "pluck")
-        assert "argv" in pluck.required
-
-
-class TestPluckExecutor:
-
-    def test_returns_json_string(self):
-        import json
-        result = pluck_executor(argv="squackit/cli.py find .fn names")
-        parsed = json.loads(result)
-        assert "chain" in parsed
-        assert "type" in parsed
-        assert "data" in parsed
-
-    def test_find_names(self):
-        import json
-        result = pluck_executor(argv="squackit/cli.py find .fn names")
-        parsed = json.loads(result)
-        assert parsed["type"] == "names"
-        assert isinstance(parsed["data"], list)
-        assert "cli" in parsed["data"]
-
-    def test_count(self):
-        import json
-        result = pluck_executor(argv="squackit/cli.py find .fn count")
-        parsed = json.loads(result)
-        assert parsed["type"] == "count"
-        assert isinstance(parsed["data"], int)
-        assert parsed["data"] > 0
-
-    def test_view_with_plugin(self):
-        import json
-        result = pluck_executor(
-            argv="--plugin AstViewer squackit/cli.py find .fn#cli view"
-        )
-        parsed = json.loads(result)
-        assert parsed["type"] == "view"
-        # data is a dict with blocks
-        assert "blocks" in parsed["data"]
-
-    def test_empty_argv_returns_error(self):
-        import json
-        result = pluck_executor(argv="")
-        parsed = json.loads(result)
-        assert "error" in parsed