pipulate 2.45__tar.gz → 2.47__tar.gz

{pipulate-2.45/pipulate.egg-info → pipulate-2.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipulate
-Version: 2.45
+Version: 2.47
 Summary: AI-readiness for the agentic web — local-first, Nix-reproducible workflows. The successor to AI SEO software.
 Author-email: Mike Levin <pipulate@gmail.com>
 License-Expression: AGPL-3.0-or-later

{pipulate-2.45 → pipulate-2.47}/__init__.py

@@ -12,7 +12,7 @@ Usage:
     pipulate
 """
 
-__version__ = "2.45"
+__version__ = "2.47"
 # APOSTROPHES RESTORED (2026-08-04). They were stripped as a workaround for
 # flake.nix's descMatch regex, whose character class excluded ' from the
 # CAPTURE and truncated the banner to "(So)". That regex was fixed in the same
@@ -23,7 +23,7 @@ __version__ = "2.45"
 # is not a property of the system; the regex is. Blast radius is one banner:
 # nothing but flake.nix reads this name -- version_sync.py syncs __version__
 # and __description__, never this. So'wI' chu' -- "engage the cloaking device."
-__version_description__ = "Shoshinification"
+__version_description__ = "Shoshin Kata Begins"
 # SPDX expression, single source of truth, synced into pyproject.toml by
 # scripts/release/version_sync.py. "-or-later" (not bare AGPL-3.0, which is
 # deprecated SPDX) because the header below grants "any later version".

{pipulate-2.45 → pipulate-2.47}/cli.py

@@ -109,7 +109,13 @@ def discover_tools(show_all=False, tool_name=None):
                 border_style="cyan"
             ))
             
-            for i, tool in enumerate(essential_tools, 1):
+            # The Rule of 7 is a string-literal list, not a registry read, so
+            # a denied tool would still be NAMED here and a model told to run
+            # it would waste a call on "not found". Filter without importing
+            # the registry (that import costs seconds); denied_tools() is cheap.
+            from tools import denied_tools
+            shown = [tool for tool in essential_tools if tool not in denied_tools()]
+            for i, tool in enumerate(shown, 1):
                 console.print(f"  {i}. [bold cyan]{tool}[/bold cyan]")
             
             console.print(f"\n[italic]Use `.venv/bin/python cli.py mcp-discover --all` to see all available tools.[/italic]")
@@ -133,9 +139,17 @@ def discover_tools(show_all=False, tool_name=None):
         console.print(f"❌ [bold red]Error running discovery:[/bold red] {e}")
         sys.exit(1)
 
-async def call_mcp_tool(tool_name: str, tool_args: dict):
-    """Execute an MCP tool with the given arguments."""
-    console.print(Panel(f"🔧 [bold cyan]Executing MCP Tool: {tool_name}[/bold cyan]", border_style="cyan"))
+async def call_mcp_tool(tool_name: str, tool_args: dict, raw: bool = False):
+    """Execute an MCP tool with the given arguments.
+
+    raw=True prints the tool's returned dict as JSON and nothing else: no
+    panel, no Rich table. Added 2026-08-30 for the two-arm experiment, where
+    the registry arm must see what a tools/call would actually return rather
+    than an 80-column table cell that wraps line-oriented stdout. In raw mode
+    the exit code carries the tool's own success field.
+    """
+    if not raw:
+        console.print(Panel(f"🔧 [bold cyan]Executing MCP Tool: {tool_name}[/bold cyan]", border_style="cyan"))
 
     try:
         # Import MCP tools module
@@ -149,10 +163,14 @@ async def call_mcp_tool(tool_name: str, tool_args: dict):
         
         # Execute the tool
         tool_handler = registry[tool_name]
-        console.print(f"⚡ Executing '{tool_name}' with args: {tool_args}")
+        if not raw:
+            console.print(f"⚡ Executing '{tool_name}' with args: {tool_args}")
         
         result = await tool_handler(tool_args)
         
+        if raw:
+            print(json.dumps(result, indent=2, default=str))
+            return bool(result.get("success", True)) if isinstance(result, dict) else True
         # Display results
         console.print(f"✅ [bold green]Tool execution complete![/bold green]")
         
@@ -506,9 +524,13 @@ def main():
                             help='🎯 GOLDEN PATH: A JSON string containing all tool arguments. ' 
                                  'Use this for complex parameters to ensure perfect data transmission.')
 
+    call_parser.add_argument('--raw', action='store_true',
+                             help='Print the tool result as JSON and nothing else; '
+                                  'the exit code carries the tool\'s success field.')
     args = parser.parse_args()
 
-    console.print(Panel("🚀 [bold cyan]Pipulate :: The Local-First AI-Readiness & Automation Workshop[/bold cyan] 🚀", border_style="cyan"))
+    if not getattr(args, 'raw', False):
+        console.print(Panel("🚀 [bold cyan]Pipulate :: The Local-First AI-Readiness & Automation Workshop[/bold cyan] 🚀", border_style="cyan"))
 
     if args.command == 'install':
         if not check_nix_installed():
@@ -556,7 +578,8 @@ def main():
         if args.json_args:
             try:
                 params = json.loads(args.json_args)
-                console.print(f"🎯 [bold green]Golden Path: Using JSON arguments[/bold green]")
+                if not args.raw:
+                    console.print(f"🎯 [bold green]Golden Path: Using JSON arguments[/bold green]")
             except json.JSONDecodeError as e:
                 console.print(f"❌ [bold red]Error: Invalid JSON provided to --json-args.[/bold red]")
                 console.print(f"JSON Error: {e}")
@@ -578,7 +601,7 @@ def main():
         
         # Execute the tool
         try:
-            success = asyncio.run(call_mcp_tool(args.tool_name, params))
+            success = asyncio.run(call_mcp_tool(args.tool_name, params, raw=args.raw))
             if not success:
                 sys.exit(1)
         except KeyboardInterrupt:

{pipulate-2.45 → pipulate-2.47/pipulate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipulate
-Version: 2.45
+Version: 2.47
 Summary: AI-readiness for the agentic web — local-first, Nix-reproducible workflows. The successor to AI SEO software.
 Author-email: Mike Levin <pipulate@gmail.com>
 License-Expression: AGPL-3.0-or-later

{pipulate-2.45 → pipulate-2.47}/pipulate.egg-info/SOURCES.txt

@@ -77,6 +77,7 @@ tests/test_mck_rep2.py
 tools/__init__.py
 tools/advanced_automation_tools.py
 tools/botify_tools.py
+tools/connector_tools.py
 tools/conversation_tools.py
 tools/dom_tools.py
 tools/keychain_tools.py

{pipulate-2.45 → pipulate-2.47}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "pipulate"
 # VERSION NOTE: Synced from pipulate/__init__.py.__version__ via python version_sync.py
-version = "2.45"
+version = "2.47"
 authors = [
   { name="Mike Levin", email="pipulate@gmail.com" },
 ]

{pipulate-2.45 → pipulate-2.47}/server.py

@@ -4138,7 +4138,6 @@ async def reset_python_env(request):
                 await pipulate.stream('📝 **Next Steps Required:**', verbatim=True, role='system')
                 await pipulate.stream('   1. Type `exit` to leave the current nix shell', verbatim=True, role='system')
                 await pipulate.stream('   2. Type `nix develop` to rebuild the environment', verbatim=True, role='system')
-                await pipulate.stream('   3. The fresh environment build will take 2-3 minutes', verbatim=True, role='system')
                 await pipulate.stream('', verbatim=True, role='system')  # Empty line for spacing
                 await pipulate.stream('🚪 Server will exit in 3 seconds...', verbatim=True, role='system')
 

{pipulate-2.45 → pipulate-2.47}/tools/__init__.py

@@ -44,9 +44,41 @@ def get_all_tools():
             except ImportError as e:
                 print(f"Could not import tool module: {module_name} - {e}")
 
+    denied = denied_tools()
+    if denied:
+        return {name: func for name, func in AUTO_REGISTERED_TOOLS.items()
+                if name not in denied}
     return AUTO_REGISTERED_TOOLS
+
+
+def denied_tools():
+    """Names withheld from the registry by PIPULATE_TOOL_DENY (comma-separated).
+
+    THE ESCAPE HATCH, NAMED. execute_shell_command is a registry tool, so any
+    experiment that pits the registry against the shell has a registry arm that
+    can shell out and become the other arm. Withholding is an ENV VAR on
+    purpose: the registry itself never changes, the denial is visible in the
+    harness command that set it, and an empty variable is exactly today.
+    Applied at get_all_tools()'s return because every cli.py path -- call,
+    mcp-discover --all, mcp-discover --tool -- reads that one dict.
+    """
+    raw = os.environ.get("PIPULATE_TOOL_DENY", "")
+    return {name.strip() for name in raw.split(",") if name.strip()}
 # --- END NEW ---
 
+# EARMARK (2026-08-30): TWO REGISTRATION LINEAGES, ONE READER. get_all_tools()
+# serves only @auto_tool functions. tools/advanced_automation_tools.py still
+# defines its own execute_shell_command (undecorated -- receipt: rg -n -B2
+# '^async def execute_shell_command' shows a comment and a blank line above
+# it) and hands it to a register_mcp_tool() that feeds a registry THIS package
+# never reads; tools/mcp_tools.py (42 async defs) and tools/botify_tools.py
+# (six core functions on aiohttp and an ai_dictdb credential path, zero
+# decorators) are the same pre-@auto_tool lineage. cli.py cannot reach any of
+# them. Whether server.py's bracket-command path still can is UNWITNESSED.
+# Gut or migrate: each function either gains @auto_tool plus the current
+# credential path (config.get_botify_token, or the subprocess-the-connector
+# pattern in connector_tools.py) or is deleted, and the botify_exports import
+# below leaves with botify_tools.py. Not this ride.
 __version__ = "1.0.0"
 
 # Import shared constants to eliminate duplication

pipulate-2.47/tools/connector_tools.py

@@ -0,0 +1,98 @@
+"""
+connector_tools.py -- the registry face of scripts/connectors/*.py: one tool
+per connector, SAME argument shape, SAME backend, SAME docstring.
+
+This file exists for the two-arm experiment (shell verb vs registry tool) and
+for nothing else yet. Arm S runs the connector as a command line; Arm R calls
+the tool below through `cli.py call <name> --json-args '{...}'`. Both arrive at
+the identical subprocess, so the only thing the experiment can measure is the
+invocation grammar and the discovery surface, which is the variable under test.
+
+THREE SURFACES, ONE SOURCE. sources_menu.py reads each connector's module
+docstring with ast.get_docstring and prints its first line as the menu row;
+the connector's own --help prints the same docstring (argparse
+description=__doc__); this file reads the same docstring the same way and
+installs it as the tool's __doc__ at import time, which is what
+`cli.py mcp-discover --tool <name>` prints. A description that is better on
+one arm than the other is the confound that would decide the experiment for
+the wrong reason, so no hand-authored description is allowed to exist here.
+
+PARAMS MIRROR ARGPARSE DESTS, deliberately, so the JSON a model must write is
+readable off the same --help text the other arm reads: query (the single
+positional; omit it for the identity walk), org, project, max, check.
+
+KNOWN SEAM: the AST-derived Tool Roster in prompt_foo.py cannot see a __doc__
+assigned at runtime; it shows the literal placeholder on the function. Named
+here rather than papered over with a copied sentence that would drift.
+"""
+import ast
+import asyncio
+import sys
+from pathlib import Path
+
+from tools import auto_tool
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+CONNECTORS = REPO_ROOT / "scripts" / "connectors"
+TIMEOUT = 120
+KEY_TRAILER = (
+    "\n\nRegistry form: --json-args keys mirror the connector's argument names --"
+    " query (the positional; omit for the identity walk), org, project, max, check."
+)
+
+
+def _connector_doc(name):
+    """The connector's module docstring, read the way sources_menu.py reads it."""
+    path = CONNECTORS / f"{name}.py"
+    try:
+        doc = ast.get_docstring(ast.parse(path.read_text(encoding="utf-8")))
+    except (OSError, UnicodeDecodeError, SyntaxError) as exc:
+        return f"(could not read {path}: {exc.__class__.__name__})"
+    return (doc or f"(NO MODULE DOCSTRING in {path})") + KEY_TRAILER
+
+
+async def _run_connector(name, params):
+    """Run scripts/connectors/<name>.py as a subprocess; return its three channels."""
+    if not isinstance(params, dict):
+        return {"success": False, "error": "params must be a JSON object"}
+    argv = [sys.executable, str(CONNECTORS / f"{name}.py")]
+    if params.get("query") is not None:
+        argv.append(str(params["query"]))
+    for flag in ("org", "project"):
+        if params.get(flag):
+            argv += [f"--{flag}", str(params[flag])]
+    if params.get("max") is not None:
+        try:
+            argv += ["--max", str(int(params["max"]))]
+        except (TypeError, ValueError):
+            return {"success": False, "error": "max must be an integer"}
+    if params.get("check"):
+        argv.append("--check")
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *argv, cwd=str(REPO_ROOT),
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+        out, err = await asyncio.wait_for(proc.communicate(), timeout=TIMEOUT)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return {"success": False, "error": f"timed out after {TIMEOUT}s", "argv": argv[1:]}
+    except OSError as exc:
+        return {"success": False, "error": str(exc), "argv": argv[1:]}
+    return {
+        "success": proc.returncode == 0,
+        "argv": argv[1:],
+        "exit_code": proc.returncode,
+        "stdout": out.decode("utf-8", errors="replace"),
+        "stderr": err.decode("utf-8", errors="replace"),
+    }
+
+
+@auto_tool
+async def botify(params: dict) -> dict:
+    """Registry face of scripts/connectors/botify.py; __doc__ is replaced at
+    import with that file's own docstring so both arms read one description."""
+    return await _run_connector("botify", params)
+
+
+botify.__doc__ = _connector_doc("botify")