tide-runtime 0.2.6__tar.gz → 0.2.7__tar.gz

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tide-runtime
-Version: 0.2.6
+Version: 0.2.7
 Summary: Tide runtime policy, approvals, and earned-use ledger for AI agent tools.
 Project-URL: Repository, https://github.com/rippletideco/rippletide-package
 Requires-Python: >=3.8
@@ -19,6 +19,16 @@ tide init --pack support-refunds --environment prod
 `tide init --dry-run --pack <name>` prints the policy before writing it.
 Built-in packs: `baseline`, `support-refunds`, `sql-analyst`, `mcp-baseline`.
 
+To have Tide suggest wrappers for an existing Python agent:
+
+```bash
+tide scan --path . --pack support-refunds
+$EDITOR .tide/tide-plan.json
+tide apply --interactive --write-policy
+```
+
+Use `tide apply --yes --write-policy` to accept the reviewed plan non-interactively.
+
 ```python
 from tide import configure, controlled_tool, record_outcome
 

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/README.md

@@ -11,6 +11,16 @@ tide init --pack support-refunds --environment prod
 `tide init --dry-run --pack <name>` prints the policy before writing it.
 Built-in packs: `baseline`, `support-refunds`, `sql-analyst`, `mcp-baseline`.
 
+To have Tide suggest wrappers for an existing Python agent:
+
+```bash
+tide scan --path . --pack support-refunds
+$EDITOR .tide/tide-plan.json
+tide apply --interactive --write-policy
+```
+
+Use `tide apply --yes --write-policy` to accept the reviewed plan non-interactively.
+
 ```python
 from tide import configure, controlled_tool, record_outcome
 

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tide-runtime"
-version = "0.2.6"
+version = "0.2.7"
 description = "Tide runtime policy, approvals, and earned-use ledger for AI agent tools."
 requires-python = ">=3.8"
 readme = "README.md"

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/tests/test_runtime.py

@@ -2,7 +2,9 @@ import json
 import os
 import shutil
 import sys
+import ast
 import tempfile
+import textwrap
 import threading
 import time
 import unittest
@@ -236,6 +238,117 @@ class TideRuntimeTest(unittest.TestCase):
         self.assertIn("Earned use by tool", out.getvalue())
         self.assertIn("crm.get_lead", out.getvalue())
 
+    def test_cli_scan_generates_wrapper_plan(self):
+        agent = tempfile.mkdtemp(prefix="tide-agent-scan-")
+        self.addCleanup(lambda: shutil.rmtree(agent, ignore_errors=True))
+        with open(os.path.join(agent, "agent.py"), "w", encoding="utf-8") as f:
+            f.write(textwrap.dedent("""
+                from langchain.tools import tool
+
+                @tool
+                def issue_refund(charge_id, amount):
+                    return stripe.refunds.create(charge=charge_id, amount=amount)
+            """).lstrip())
+
+        plan = os.path.join(agent, ".tide", "tide-plan.json")
+        out = StringIO()
+        with redirect_stdout(out):
+            code = tide_cli.main(["scan", "--path", agent, "--pack", "support-refunds", "--plan", plan])
+        self.assertEqual(code, 0)
+        with open(plan, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        action = data["actions"][0]
+        self.assertEqual(action["risk_class"], "money_movement")
+        self.assertEqual(action["policy_decision"], "require_approval")
+        self.assertEqual(action["capture"], ["charge_id", "amount"])
+        self.assertIn("issue_refund", out.getvalue())
+
+    def test_cli_apply_adds_wrapper_import_and_policy(self):
+        agent = tempfile.mkdtemp(prefix="tide-agent-apply-")
+        self.addCleanup(lambda: shutil.rmtree(agent, ignore_errors=True))
+        target = os.path.join(agent, "agent.py")
+        with open(target, "w", encoding="utf-8") as f:
+            f.write(textwrap.dedent("""
+                def send_customer_email(recipient_email, body):
+                    return gmail.send(to=recipient_email, body=body)
+            """).lstrip())
+
+        plan = os.path.join(agent, ".tide", "tide-plan.json")
+        with redirect_stdout(StringIO()):
+            self.assertEqual(tide_cli.main(["scan", "--path", agent, "--pack", "support-refunds", "--plan", plan]), 0)
+            self.assertEqual(tide_cli.main(["apply", "--plan", plan, "--yes", "--write-policy"]), 0)
+        with open(target, "r", encoding="utf-8") as f:
+            source = f.read()
+        self.assertIn("from tide import controlled_tool", source)
+        self.assertIn("@controlled_tool(name='gmail.send', risk_class='customer_visible', capture=['recipient_email'])", source)
+        ast.parse(source)
+        pol = tide_store.load_policy(os.path.join(agent, ".tide", "ledger"))
+        self.assertEqual(pol["pack"], "support-refunds")
+
+    def test_cli_apply_preserves_framework_decorator_order(self):
+        agent = tempfile.mkdtemp(prefix="tide-agent-order-")
+        self.addCleanup(lambda: shutil.rmtree(agent, ignore_errors=True))
+        target = os.path.join(agent, "agent.py")
+        with open(target, "w", encoding="utf-8") as f:
+            f.write(textwrap.dedent("""
+                from langchain.tools import tool
+
+                @tool
+                def update_deal(deal_id, stage):
+                    return hubspot.crm.deals.basic_api.update(deal_id, {"stage": stage})
+            """).lstrip())
+
+        plan = os.path.join(agent, ".tide", "tide-plan.json")
+        with redirect_stdout(StringIO()):
+            self.assertEqual(tide_cli.main(["scan", "--path", agent, "--pack", "baseline", "--plan", plan]), 0)
+            self.assertEqual(tide_cli.main(["apply", "--plan", plan, "--yes"]), 0)
+        with open(target, "r", encoding="utf-8") as f:
+            lines = [line.strip() for line in f.readlines()]
+        self.assertLess(lines.index("@tool"), lines.index("@controlled_tool(name='hubspot.update_deal', risk_class='internal_write', capture=['deal_id'])"))
+        self.assertLess(lines.index("@controlled_tool(name='hubspot.update_deal', risk_class='internal_write', capture=['deal_id'])"), lines.index("def update_deal(deal_id, stage):"))
+
+    def test_cli_scan_reports_already_wrapped(self):
+        agent = tempfile.mkdtemp(prefix="tide-agent-wrapped-")
+        self.addCleanup(lambda: shutil.rmtree(agent, ignore_errors=True))
+        with open(os.path.join(agent, "agent.py"), "w", encoding="utf-8") as f:
+            f.write(textwrap.dedent("""
+                from tide import controlled_tool
+
+                @controlled_tool(name="stripe.refund", risk_class="money_movement")
+                def issue_refund(charge_id):
+                    return stripe.refunds.create(charge=charge_id)
+            """).lstrip())
+
+        plan = os.path.join(agent, ".tide", "tide-plan.json")
+        with redirect_stdout(StringIO()):
+            self.assertEqual(tide_cli.main(["scan", "--path", agent, "--plan", plan]), 0)
+        with open(plan, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        self.assertEqual(data["summary"]["proposed"], 0)
+        self.assertEqual(data["summary"]["already_wrapped"], 1)
+
+    def test_cli_scan_skips_common_helpers(self):
+        agent = tempfile.mkdtemp(prefix="tide-agent-helpers-")
+        self.addCleanup(lambda: shutil.rmtree(agent, ignore_errors=True))
+        with open(os.path.join(agent, "agent.py"), "w", encoding="utf-8") as f:
+            f.write(textwrap.dedent("""
+                def create_sql_agent(db):
+                    return object()
+
+                def summarize_tool_args(args):
+                    return str(args)
+
+                def main():
+                    return create_sql_agent(None)
+            """).lstrip())
+
+        plan = os.path.join(agent, ".tide", "tide-plan.json")
+        with redirect_stdout(StringIO()):
+            self.assertEqual(tide_cli.main(["scan", "--path", agent, "--plan", plan]), 0)
+        with open(plan, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        self.assertEqual(data["summary"]["proposed"], 0)
+
 
 if __name__ == "__main__":
     unittest.main()

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/tide/__init__.py

@@ -26,7 +26,7 @@ import time
 from . import policy as _policy
 from . import store as _store
 
-__version__ = "0.2.6"
+__version__ = "0.2.7"
 
 __all__ = [
     "configure",

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/tide/cli.py

@@ -6,6 +6,7 @@ import os
 import sys
 
 from . import __version__
+from . import instrument
 from . import packs
 from . import store
 
@@ -185,6 +186,43 @@ def _packs(args):
     return 0
 
 
+def _scan(args):
+    plan_path = args.plan
+    plan = instrument.scan(
+        root=args.path,
+        pack=args.pack,
+        plan_path=None if args.no_write else plan_path,
+        environment=args.environment,
+    )
+    if args.format == "json":
+        print(json.dumps(plan, indent=2, sort_keys=True))
+    else:
+        print(instrument.text_summary(plan))
+        if not args.no_write:
+            print("\ntide: wrote plan -> %s" % plan_path)
+            print("tide: review it, then run `tide apply --plan %s --interactive` or `--yes`." % plan_path)
+    return 0
+
+
+def _apply(args):
+    if not args.yes and not args.interactive and not args.id:
+        print("tide: apply needs --interactive, --yes, or --id <action-id>", file=sys.stderr)
+        return 1
+    result = instrument.apply_plan(
+        plan_path=args.plan,
+        yes=args.yes,
+        only_ids=args.id,
+        write_policy=args.write_policy,
+        interactive=args.interactive,
+    )
+    print("tide: applied %d wrapper(s)" % result["applied"])
+    if result["policy_written"]:
+        print("tide: wrote .tide/ledger/policy.json from the plan pack")
+    for item in result["skipped"]:
+        print("tide: skipped %s - %s" % (item.get("id"), item.get("reason")))
+    return 0 if result["applied"] or result["policy_written"] else 1
+
+
 def build_parser():
     parser = argparse.ArgumentParser(description="Tide local policy and approvals for AI agent tools.")
     parser.add_argument("--version", action="version", version="tide-runtime %s" % __version__)
@@ -202,6 +240,32 @@ def build_parser():
     show_packs.add_argument("name", nargs="?", choices=packs.names())
     show_packs.set_defaults(func=_packs)
 
+    scan = sub.add_parser("scan", help="find risky Python tools and write a reviewable wrapper plan")
+    scan.add_argument("--path", default=".")
+    scan.add_argument("--pack", choices=packs.names(), default="baseline")
+    scan.add_argument("--environment", choices=("dev", "prod"), default=None)
+    scan.add_argument("--plan", default=instrument.PLAN_FILE)
+    scan.add_argument("--format", choices=("text", "json"), default="text")
+    scan.add_argument("--no-write", action="store_true")
+    scan.set_defaults(func=_scan)
+
+    plan = sub.add_parser("plan", help="alias for scan")
+    plan.add_argument("--path", default=".")
+    plan.add_argument("--pack", choices=packs.names(), default="baseline")
+    plan.add_argument("--environment", choices=("dev", "prod"), default=None)
+    plan.add_argument("--plan", default=instrument.PLAN_FILE)
+    plan.add_argument("--format", choices=("text", "json"), default="text")
+    plan.add_argument("--no-write", action="store_true")
+    plan.set_defaults(func=_scan)
+
+    apply = sub.add_parser("apply", help="apply wrappers from a Tide plan")
+    apply.add_argument("--plan", default=instrument.PLAN_FILE)
+    apply.add_argument("--interactive", action="store_true")
+    apply.add_argument("--yes", action="store_true")
+    apply.add_argument("--id", action="append", help="apply one action id; can be repeated")
+    apply.add_argument("--write-policy", action="store_true")
+    apply.set_defaults(func=_apply)
+
     approvals = sub.add_parser("approvals", help="list pending approval requests")
     approvals.add_argument("--project", default=DEFAULT_PROJECT)
     approvals.set_defaults(func=_approvals)

tide_runtime-0.2.7/tide/instrument.py

@@ -0,0 +1,468 @@
+"""Scan Python agents and apply Tide wrappers around risky tools."""
+
+import ast
+import json
+import os
+import re
+from datetime import datetime, timezone
+
+from . import packs
+from . import policy
+from . import store
+
+
+PLAN_FILE = os.path.join(".tide", "tide-plan.json")
+
+SKIP_DIRS = {
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tide",
+    ".venv",
+    "__pycache__",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+}
+
+TOOL_DECORATORS = {
+    "tool",
+    "function_tool",
+    "mcp.tool",
+    "server.tool",
+    "app.tool",
+    "agent.tool",
+    "structured_tool",
+    "StructuredTool.from_function",
+}
+
+RISK_RULES = [
+    ("destructive", (
+        "delete", "destroy", "drop", "truncate", "purge", "remove", "rmtree",
+        "rm -rf", "kubectl delete", "terraform destroy",
+    )),
+    ("money_movement", (
+        "refund", "charge", "payment", "payout", "transfer", "pay_invoice",
+        "invoice.pay", "stripe.refund", "stripe.refunds.create",
+    )),
+    ("customer_visible", (
+        "send_email", "email.send", "gmail.send", "reply", "send_message",
+        "post_message", "chat.postmessage", "zendesk.ticket.reply",
+        "intercom.message", "slack.chat.postmessage",
+    )),
+    ("internal_write", (
+        "create", "update", "upsert", "insert", "merge", "write", "patch",
+        "set_", "close_ticket", "stage", "finalize", "commit", "deploy",
+        "hubspot", "salesforce", "zendesk", "jira", "linear",
+    )),
+]
+
+READ_ONLY_HINTS = (
+    "get", "list", "search", "read", "fetch", "lookup", "select", "query",
+)
+
+HELPER_NAME_HINTS = (
+    "agent", "client", "summarize", "summary", "format", "parse", "classify",
+    "schema", "prompt", "config", "factory", "builder",
+)
+
+ACTION_NAME_HINTS = {
+    "destructive": ("delete", "destroy", "drop", "truncate", "purge", "remove"),
+    "money_movement": ("refund", "charge", "payment", "payout", "transfer", "pay"),
+    "customer_visible": ("send", "reply", "message", "email", "notify", "post"),
+    "internal_write": ("create", "update", "upsert", "insert", "write", "patch", "merge", "close", "finalize", "deploy", "set_"),
+}
+
+CAPTURE_HINTS = (
+    "id", "amount", "email", "query", "sql", "charge", "refund", "customer",
+    "ticket", "deal", "lead", "account", "path", "command", "cmd", "recipient",
+)
+
+
+def now_iso():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def relpath(path, root):
+    return os.path.relpath(path, root).replace(os.sep, "/")
+
+
+def walk_python(root):
+    for base, dirs, files in os.walk(root):
+        dirs[:] = [d for d in dirs if d not in SKIP_DIRS]
+        for filename in files:
+            if filename.endswith(".py"):
+                yield os.path.join(base, filename)
+
+
+def expr_name(node):
+    if isinstance(node, ast.Name):
+        return node.id
+    if isinstance(node, ast.Attribute):
+        parent = expr_name(node.value)
+        return (parent + "." if parent else "") + node.attr
+    if isinstance(node, ast.Call):
+        return expr_name(node.func)
+    return ""
+
+
+def decorator_name(node):
+    if isinstance(node, ast.Call):
+        return expr_name(node.func)
+    return expr_name(node)
+
+
+def is_controlled(fn):
+    for dec in fn.decorator_list:
+        name = decorator_name(dec).lower()
+        if name == "controlled_tool" or name.endswith(".controlled_tool"):
+            return True
+    return False
+
+
+def is_tool_decorator(name):
+    lowered = name.lower()
+    if lowered in TOOL_DECORATORS:
+        return True
+    return lowered.endswith(".tool") or lowered.endswith(".as_tool")
+
+
+class FunctionSignals(ast.NodeVisitor):
+    def __init__(self):
+        self.calls = []
+        self.strings = []
+
+    def visit_Call(self, node):
+        name = expr_name(node.func)
+        if name:
+            self.calls.append(name)
+        self.generic_visit(node)
+
+    def visit_Constant(self, node):
+        if isinstance(node.value, str):
+            self.strings.append(node.value[:200])
+
+
+def word_blob(fn, signals):
+    parts = [fn.name]
+    parts.extend(decorator_name(dec) for dec in fn.decorator_list)
+    parts.extend(signals.calls)
+    parts.extend(signals.strings)
+    return " ".join(parts).lower().replace("_", ".")
+
+
+def best_risk(fn, signals):
+    blob = word_blob(fn, signals)
+    reasons = []
+    for risk, hints in RISK_RULES:
+        matched = [hint for hint in hints if hint in blob]
+        if matched:
+            reasons.append("matched %s hint(s): %s" % (risk, ", ".join(matched[:4])))
+            return risk, reasons
+    if any(hint in blob for hint in READ_ONLY_HINTS):
+        return "read_only", ["matched read-only hint"]
+    return "internal_write", ["tool surface without a more specific risk hint"]
+
+
+def confidence(fn, risk_class, has_tool_decorator, reasons):
+    if has_tool_decorator and risk_class not in ("read_only",):
+        return "high"
+    if risk_class in ("destructive", "money_movement", "customer_visible"):
+        return "high"
+    if risk_class == "internal_write":
+        return "medium"
+    if has_tool_decorator:
+        return "medium"
+    return "low"
+
+
+def should_propose(fn, risk_class, has_tool_decorator):
+    if has_tool_decorator:
+        return True
+    name = fn.name.lower()
+    if name.startswith("_") or name == "main":
+        return False
+    if risk_class == "read_only":
+        return False
+    if any(hint in name for hint in HELPER_NAME_HINTS):
+        return False
+    return any(hint in name for hint in ACTION_NAME_HINTS.get(risk_class, ()))
+
+
+def capture_args(fn):
+    args = []
+    arguments = list(fn.args.args)
+    if arguments and arguments[0].arg in ("self", "cls"):
+        arguments = arguments[1:]
+    for arg in arguments + list(fn.args.kwonlyargs):
+        lowered = arg.arg.lower()
+        if any(hint in lowered for hint in CAPTURE_HINTS):
+            args.append(arg.arg)
+    return args[:5]
+
+
+def infer_tool_name(fn, signals):
+    blob = word_blob(fn, signals)
+    if "stripe" in blob and "refund" in blob:
+        return "stripe.refund"
+    if "shopify" in blob and "refund" in blob:
+        return "shopify.refund"
+    if "zendesk" in blob and "reply" in blob:
+        return "zendesk.ticket.reply"
+    if "intercom" in blob and "message" in blob:
+        return "intercom.message.send"
+    if "slack" in blob and "postmessage" in blob:
+        return "slack.chat.postMessage"
+    if "gmail" in blob and "send" in blob:
+        return "gmail.send"
+    if "sql" in blob or "query" in blob:
+        return "sql.query"
+    if "hubspot" in blob:
+        return "hubspot.%s" % fn.name
+    if "salesforce" in blob:
+        return "salesforce.%s" % fn.name
+    return fn.name
+
+
+def decorator_for(action):
+    capture = action.get("capture") or []
+    parts = [
+        "name=%r" % action["tool_name"],
+        "risk_class=%r" % action["risk_class"],
+    ]
+    if capture:
+        parts.append("capture=%r" % capture)
+    return "@controlled_tool(%s)" % ", ".join(parts)
+
+
+def scan_file(path, root, policy_obj):
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            source = f.read()
+        tree = ast.parse(source, filename=path)
+    except (OSError, SyntaxError, UnicodeDecodeError) as exc:
+        return [{
+            "id": None,
+            "status": "manual_review",
+            "language": "python",
+            "file": relpath(path, root),
+            "line": 1,
+            "function": None,
+            "reason": "could not parse file: %s" % exc,
+        }]
+
+    actions = []
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        signals = FunctionSignals()
+        signals.visit(node)
+        has_tool_decorator = any(is_tool_decorator(decorator_name(dec)) for dec in node.decorator_list)
+        if is_controlled(node):
+            actions.append({
+                "id": None,
+                "status": "already_wrapped",
+                "language": "python",
+                "file": relpath(path, root),
+                "line": node.lineno,
+                "function": node.name,
+                "tool_name": infer_tool_name(node, signals),
+            })
+            continue
+        risk_class, reasons = best_risk(node, signals)
+        if not should_propose(node, risk_class, has_tool_decorator):
+            continue
+        env = policy_obj.get("environment") or "prod"
+        decision, decision_reason = policy.decide(policy_obj, infer_tool_name(node, signals), risk_class, env)
+        action = {
+            "id": None,
+            "status": "proposed",
+            "language": "python",
+            "file": relpath(path, root),
+            "line": node.lineno,
+            "function": node.name,
+            "async": isinstance(node, ast.AsyncFunctionDef),
+            "tool_name": infer_tool_name(node, signals),
+            "risk_class": risk_class,
+            "capture": capture_args(node),
+            "confidence": confidence(node, risk_class, has_tool_decorator, reasons),
+            "framework_tool": has_tool_decorator,
+            "reasons": reasons,
+            "policy_decision": decision,
+            "policy_reason": decision_reason,
+        }
+        action["decorator"] = decorator_for(action)
+        action["accepted"] = action["confidence"] in ("high", "medium")
+        actions.append(action)
+    return actions
+
+
+def scan(root=".", pack="baseline", plan_path=None, environment=None):
+    root = os.path.abspath(root)
+    policy_obj = packs.get(pack, environment=environment)
+    actions = []
+    for path in walk_python(root):
+        actions.extend(scan_file(path, root, policy_obj))
+    proposed = [a for a in actions if a.get("status") == "proposed"]
+    for i, action in enumerate(proposed, 1):
+        action["id"] = "wrap-%04d" % i
+    summary = {
+        "files_scanned": sum(1 for _ in walk_python(root)),
+        "proposed": len(proposed),
+        "already_wrapped": len([a for a in actions if a.get("status") == "already_wrapped"]),
+        "manual_review": len([a for a in actions if a.get("status") == "manual_review"]),
+        "high_confidence": len([a for a in proposed if a.get("confidence") == "high"]),
+        "medium_confidence": len([a for a in proposed if a.get("confidence") == "medium"]),
+        "low_confidence": len([a for a in proposed if a.get("confidence") == "low"]),
+    }
+    plan = {
+        "version": 1,
+        "generated_at": now_iso(),
+        "root": root,
+        "pack": pack,
+        "policy": policy_obj,
+        "summary": summary,
+        "actions": actions,
+    }
+    if plan_path:
+        write_plan(plan, plan_path)
+    return plan
+
+
+def write_plan(plan, path):
+    directory = os.path.dirname(path)
+    if directory:
+        os.makedirs(directory, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(plan, f, indent=2, sort_keys=True)
+        f.write("\n")
+
+
+def load_plan(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def add_import(lines):
+    for i, line in enumerate(lines):
+        if re.match(r"\s*from\s+tide\s+import\s+", line):
+            if "controlled_tool" in line:
+                return lines, False
+            stripped = line.rstrip("\n")
+            if "(" in stripped:
+                return lines[:i] + ["from tide import controlled_tool\n"] + lines[i:], True
+            lines[i] = stripped + ", controlled_tool\n"
+            return lines, False
+
+    insert = 0
+    if lines and lines[0].startswith("#!"):
+        insert = 1
+    if len(lines) > insert and "coding" in lines[insert].lower():
+        insert += 1
+    try:
+        tree = ast.parse("".join(lines))
+        if tree.body and isinstance(tree.body[0], ast.Expr) and isinstance(getattr(tree.body[0], "value", None), ast.Constant) and isinstance(tree.body[0].value.value, str):
+            insert = max(insert, tree.body[0].end_lineno or tree.body[0].lineno)
+    except SyntaxError:
+        pass
+    return lines[:insert] + ["from tide import controlled_tool\n"] + lines[insert:], True
+
+
+def function_has_wrapper(lines, line_no):
+    start = max(0, line_no - 8)
+    end = max(0, line_no - 1)
+    return any("@controlled_tool" in line for line in lines[start:end])
+
+
+def apply_plan(plan_path=PLAN_FILE, yes=False, only_ids=None, write_policy=False, interactive=False):
+    plan = load_plan(plan_path)
+    root = plan.get("root") or "."
+    only = set(only_ids or [])
+    proposed = [a for a in plan.get("actions", []) if a.get("status") == "proposed"]
+    selected = []
+    skipped = []
+
+    for action in proposed:
+        if only and action.get("id") not in only:
+            continue
+        if not action.get("accepted", True):
+            skipped.append({"id": action.get("id"), "reason": "accepted=false"})
+            continue
+        if action.get("confidence") == "low" and not yes:
+            skipped.append({"id": action.get("id"), "reason": "low confidence requires --yes or explicit id"})
+            continue
+        if interactive:
+            prompt = "%s %s:%s %s [%s -> %s] apply? [Y/n] " % (
+                action.get("id"), action.get("file"), action.get("line"),
+                action.get("function"), action.get("risk_class"), action.get("policy_decision"),
+            )
+            answer = input(prompt).strip().lower()
+            if answer not in ("", "y", "yes"):
+                skipped.append({"id": action.get("id"), "reason": "declined"})
+                continue
+        selected.append(action)
+
+    by_file = {}
+    for action in selected:
+        by_file.setdefault(action["file"], []).append(action)
+
+    applied = []
+    for rel, actions in by_file.items():
+        path = os.path.join(root, rel)
+        with open(path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+        file_applied = []
+        for action in sorted(actions, key=lambda a: int(a["line"]), reverse=True):
+            line_no = int(action["line"])
+            if function_has_wrapper(lines, line_no):
+                skipped.append({"id": action.get("id"), "reason": "already wrapped"})
+                continue
+            indent = re.match(r"^(\s*)", lines[line_no - 1]).group(1)
+            lines.insert(line_no - 1, indent + action["decorator"] + "\n")
+            file_applied.append(action)
+        if file_applied:
+            lines, _ = add_import(lines)
+            with open(path, "w", encoding="utf-8") as f:
+                f.writelines(lines)
+            applied.extend(file_applied)
+
+    if write_policy:
+        ledger_dir = os.path.join(root, ".tide", "ledger")
+        store.ensure_project(ledger_dir)
+        policy_path = os.path.join(ledger_dir, store.POLICY_FILE)
+        with open(policy_path, "w", encoding="utf-8") as f:
+            json.dump(plan["policy"], f, indent=2, sort_keys=True)
+            f.write("\n")
+
+    result = {
+        "applied": len(applied),
+        "skipped": skipped,
+        "files_changed": sorted({a["file"] for a in applied}),
+        "policy_written": bool(write_policy),
+    }
+    return result
+
+
+def text_summary(plan):
+    lines = []
+    summary = plan["summary"]
+    lines.append("Tide scan: %d proposed wrapper(s), %d already wrapped, %d manual review" % (
+        summary["proposed"], summary["already_wrapped"], summary["manual_review"],
+    ))
+    for action in plan["actions"]:
+        if action.get("status") != "proposed":
+            continue
+        lines.append(
+            "%s  %s:%s  %s -> %s [%s, %s, %s]" % (
+                action["id"], action["file"], action["line"], action["function"],
+                action["tool_name"], action["risk_class"], action["policy_decision"],
+                action["confidence"],
+            )
+        )
+        for reason in action.get("reasons", [])[:2]:
+            lines.append("      - %s" % reason)
+    return "\n".join(lines)

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/tide_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tide-runtime
-Version: 0.2.6
+Version: 0.2.7
 Summary: Tide runtime policy, approvals, and earned-use ledger for AI agent tools.
 Project-URL: Repository, https://github.com/rippletideco/rippletide-package
 Requires-Python: >=3.8
@@ -19,6 +19,16 @@ tide init --pack support-refunds --environment prod
 `tide init --dry-run --pack <name>` prints the policy before writing it.
 Built-in packs: `baseline`, `support-refunds`, `sql-analyst`, `mcp-baseline`.
 
+To have Tide suggest wrappers for an existing Python agent:
+
+```bash
+tide scan --path . --pack support-refunds
+$EDITOR .tide/tide-plan.json
+tide apply --interactive --write-policy
+```
+
+Use `tide apply --yes --write-policy` to accept the reviewed plan non-interactively.
+
 ```python
 from tide import configure, controlled_tool, record_outcome
 

{tide_runtime-0.2.6 → tide_runtime-0.2.7}/tide_runtime.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 tests/test_runtime.py
 tide/__init__.py
 tide/cli.py
+tide/instrument.py
 tide/packs.py
 tide/policy.py
 tide/store.py