veritool 1.0.0__py3-none-any.whl

bridge/__init__.py

@@ -0,0 +1,41 @@
+from bridge.policy_spec import PolicySpec, NatType, StringType, FinsetType, FunctionDef, BridgeError
+from bridge.z3_encoder import check_policy, compile_policy
+
+TAHOE_SPEC = PolicySpec(
+    name="tahoe",
+    _policy_type="tahoe",
+    params={"model": StringType, "price": NatType},
+    functions=[
+        FunctionDef("floor_price", StringType, NatType,
+                    mapping={"Tahoe": 45000, "Malibu": 25000}, default=0),
+    ],
+    violation_expr="price < floor_price(model)",
+    description="Tahoe/Malibu minimum price policy",
+)
+
+DELETION_SPEC = PolicySpec(
+    name="deletion",
+    _policy_type="deletion",
+    params={"target": StringType},
+    violation_expr="Not(in_scope(target))",
+    _allowed_scope=["/project/temp", "/project/output"],
+    description="File deletion frame policy requiring target in allowed scope",
+)
+
+
+def bridge_check(policy_name: str, params: dict | None = None, timeout_ms: int = 5000) -> dict:
+    spec_map = {
+        "tahoe": TAHOE_SPEC,
+        "deletion": DELETION_SPEC,
+    }
+    spec = spec_map.get(policy_name)
+    if spec is None:
+        return {"status": "error", "reason": f"Unknown policy: {policy_name}"}
+    return check_policy(spec, params=params, timeout_ms=timeout_ms)
+
+
+__all__ = [
+    "PolicySpec", "NatType", "StringType", "FinsetType", "FunctionDef", "BridgeError",
+    "check_policy", "compile_policy",
+    "TAHOE_SPEC", "DELETION_SPEC", "bridge_check",
+]

bridge/policy_spec.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+
+class BridgeError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class TypeSpec:
+    name: str
+
+
+NatType = TypeSpec("Nat")
+StringType = TypeSpec("String")
+BoolType = TypeSpec("Bool")
+
+
+@dataclass(frozen=True)
+class FinsetType:
+    elem_type: TypeSpec
+
+
+@dataclass(frozen=True)
+class FunctionDef:
+    name: str
+    arg_type: TypeSpec
+    return_type: TypeSpec
+    mapping: dict[str, Any] = field(default_factory=dict)
+    default: Any = 0
+
+
+@dataclass(frozen=True)
+class PolicySpec:
+    name: str
+    params: dict[str, TypeSpec] = field(default_factory=dict)
+    functions: list[FunctionDef] = field(default_factory=list)
+    violation_expr: str = ""
+    description: str = ""
+    _tool_name: str = ""
+    _allowed_scope: list[str] = field(default_factory=list)
+    _param_name: str = "value"
+    _policy_type: str = "generic"

bridge/z3_encoder.py

@@ -0,0 +1,205 @@
+import json
+
+from z3 import (
+    Solver, Int, Bool, String, StringVal,
+    Function, IntSort, BoolSort, StringSort,
+    ForAll, Const, Implies, And, Or,
+    sat, unknown,
+)
+
+from bridge.policy_spec import (
+    PolicySpec, FunctionDef, FinsetType,
+    NatType, StringType, BoolType,
+    BridgeError,
+)
+
+
+_SORT_MAP = {
+    NatType: IntSort(),
+    StringType: StringSort(),
+    BoolType: BoolSort(),
+}
+
+
+def _z3_sort(t):
+    if isinstance(t, FinsetType):
+        return _SORT_MAP.get(t.elem_type)
+    return _SORT_MAP.get(t)
+
+
+def compile_policy(spec: PolicySpec, timeout_ms: int = 5000) -> Solver:
+    s = Solver()
+    s.set("timeout", timeout_ms)
+
+    ptype = spec._policy_type if spec._policy_type != "generic" else spec.name
+
+    if ptype in ("price_floor", "tahoe"):
+        _add_floor_price_defs(s, spec)
+    elif ptype in ("file_access", "deletion"):
+        allowed = getattr(spec, "_allowed_scope", ["/project/temp", "/project/output"])
+        _add_in_scope_defs(s, allowed)
+    elif ptype == "sql_safety":
+        _add_allowed_patterns(s, spec)
+    elif ptype == "rate_limit":
+        _add_rate_limit_defs(s, spec)
+    elif ptype == "role_hours":
+        _add_role_hours_defs(s, spec)
+    elif ptype == "api_access":
+        _add_api_access_defs(s, spec)
+    else:
+        raise BridgeError(f"Unknown policy type: {ptype}")
+    return s
+
+
+def _add_floor_price_defs(solver, spec: PolicySpec):
+    if not spec.functions:
+        return
+    fn = spec.functions[0]
+    sort = _z3_sort(fn.arg_type)
+    ret_sort = _z3_sort(fn.return_type)
+    if sort is None or ret_sort is None:
+        raise BridgeError(f"Unsupported type in function {fn.name}")
+
+    floor_z3 = Function(fn.name, sort, ret_sort)
+    for k, v in fn.mapping.items():
+        solver.add(floor_z3(StringVal(k)) == v)
+    solver.add(floor_z3(StringVal("")) == fn.default)
+    return floor_z3
+
+
+def _add_in_scope_defs(solver, allowed_paths: list[str]):
+    in_scope = Function("in_scope", StringSort(), BoolSort())
+    for p in allowed_paths:
+        solver.add(in_scope(StringVal(p)) == True)
+    return in_scope
+
+
+def _add_allowed_patterns(solver, spec: PolicySpec):
+    if not spec.functions:
+        return
+    fn_def = spec.functions[0]
+    allowed_fn = Function(fn_def.name, StringSort(), BoolSort())
+    for q, val in fn_def.mapping.items():
+        solver.add(allowed_fn(StringVal(q)) == (val if isinstance(val, bool) else val == True))
+    _add_default_false(solver, allowed_fn, fn_def)
+    return allowed_fn
+
+
+def _add_rate_limit_defs(solver, spec: PolicySpec):
+    if not spec.functions:
+        return
+    fn = spec.functions[0]
+    max_fn = Function(fn.name, StringSort(), IntSort())
+    for k, v in fn.mapping.items():
+        solver.add(max_fn(StringVal(k)) == v)
+    solver.add(max_fn(StringVal("")) == fn.default)
+    return max_fn
+
+
+def _add_default_false(solver, z3_fn, fn_def):
+    x = Const(f"_{z3_fn.name()}_x", StringSort())
+    conditions = [x != StringVal(k) for k in fn_def.mapping]
+    if conditions:
+        solver.add(ForAll([x], Implies(And(*conditions), z3_fn(x) == False)))
+
+
+def _add_role_hours_defs(solver, spec: PolicySpec):
+    if not spec.functions:
+        return
+    fn_def = spec.functions[0]
+    blocked_fn = Function(fn_def.name, StringSort(), BoolSort())
+    for action, val in fn_def.mapping.items():
+        solver.add(blocked_fn(StringVal(action)) == (val if isinstance(val, bool) else True))
+    _add_default_false(solver, blocked_fn, fn_def)
+    return blocked_fn
+
+
+def _add_api_access_defs(solver, spec: PolicySpec):
+    if len(spec.functions) >= 1:
+        fn_def = spec.functions[0]
+        ep_fn = Function(fn_def.name, StringSort(), BoolSort())
+        for ep, val in fn_def.mapping.items():
+            solver.add(ep_fn(StringVal(ep)) == (val if isinstance(val, bool) else True))
+        _add_default_false(solver, ep_fn, fn_def)
+    if len(spec.functions) >= 2:
+        fn_def = spec.functions[1]
+        method_fn = Function(fn_def.name, StringSort(), BoolSort())
+        for m, val in fn_def.mapping.items():
+            solver.add(method_fn(StringVal(m)) == (val if isinstance(val, bool) else True))
+        _add_default_false(solver, method_fn, fn_def)
+
+
+def check_policy(spec: PolicySpec, params: dict | None = None, timeout_ms: int = 5000) -> dict:
+    solver = compile_policy(spec, timeout_ms)
+    ptype = spec._policy_type if spec._policy_type != "generic" else spec.name
+
+    if params:
+        if ptype in ("price_floor", "tahoe"):
+            model_val = params.get("model", "")
+            price_val = params.get("price", 0)
+            solver.add(String("model") == StringVal(model_val))
+            solver.add(Int("price") == price_val)
+            floor_z3 = Function("floor_price", StringSort(), IntSort())
+            solver.add(Int("price") < floor_z3(String("model")))
+
+        elif ptype in ("file_access", "deletion"):
+            target_val = params.get("target", "")
+            solver.add(String("target") == StringVal(target_val))
+            in_scope = Function("in_scope", StringSort(), BoolSort())
+            solver.add(in_scope(String("target")) == False)
+
+        elif ptype == "sql_safety":
+            query_val = params.get("query", "")
+            solver.add(String("query") == StringVal(query_val))
+            allowed_fn = Function("allowed_query_pattern", StringSort(), BoolSort())
+            solver.add(allowed_fn(String("query")) == False)
+
+        elif ptype == "rate_limit":
+            api_key_val = params.get("api_key", "")
+            current_count_val = params.get("current_count", 0)
+            solver.add(String("api_key") == StringVal(api_key_val))
+            solver.add(Int("current_count") == current_count_val)
+            max_fn = Function("max_per_minute", StringSort(), IntSort())
+            solver.add(Int("current_count") >= max_fn(String("api_key")))
+
+        elif ptype == "role_hours":
+            role_val = params.get("role", "")
+            hour_val = params.get("hour", 0)
+            action_val = params.get("action", "")
+            solver.add(String("role") == StringVal(role_val))
+            solver.add(Int("hour") == hour_val)
+            solver.add(String("action") == StringVal(action_val))
+            blocked_fn = Function("admin_blocked_actions", StringSort(), BoolSort())
+            solver.add(String("role") == StringVal("admin"))
+            solver.add(Int("hour") > 22)
+            solver.add(blocked_fn(String("action")) == True)
+
+        elif ptype == "api_access":
+            endpoint_val = params.get("endpoint", "")
+            method_val = params.get("method", "")
+            solver.add(String("endpoint") == StringVal(endpoint_val))
+            solver.add(String("method") == StringVal(method_val))
+            ep_fn = Function("allowed_endpoint", StringSort(), BoolSort())
+            method_fn = Function("allowed_method", StringSort(), BoolSort())
+            solver.add(Or(ep_fn(String("endpoint")) == False,
+                          method_fn(String("method")) == False))
+
+    result = solver.check()
+    if result == sat:
+        m = solver.model()
+        witness = {}
+        for d in m.decls():
+            val = m[d]
+            if val is not None:
+                try:
+                    witness[d.name()] = val.as_long()
+                except Exception:
+                    try:
+                        witness[d.name()] = str(val)
+                    except Exception:
+                        witness[d.name()] = repr(val)
+        return {"status": "violation", "witness": witness}
+    elif result == unknown:
+        return {"status": "unknown", "reason": "Z3 timed out or incomplete"}
+    else:
+        return {"status": "permitted"}

cli/__init__.py

@@ -0,0 +1,184 @@
+import argparse
+import json
+import sys
+
+from cli.auto_generator import AutoGenerator
+from cli.round_trip import round_trip_verify
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="veritool",
+        description="VeriTool — Formal verification framework for LLM tool-calling",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    p_run = sub.add_parser("run", help="Start verifier with specified policies")
+    p_run.add_argument("policies", nargs="+", help="Policy names or YAML files")
+
+    p_check = sub.add_parser("check", help="One-shot check a tool call")
+    p_check.add_argument("tool_call", help="JSON string or file path")
+
+    p_create = sub.add_parser("create", help="Generate policy from natural language")
+    p_create.add_argument("description", help="Policy description in plain English")
+
+    p_test = sub.add_parser("test", help="Run policy test suite")
+    p_test.add_argument("policy", nargs="?", help="Policy name (omit for all)")
+
+    p_status = sub.add_parser("status", help="Show runtime status and metrics")
+    p_hot = sub.add_parser("hot-reload", help="Deploy policy without restart")
+    p_hot.add_argument("policy_file", help="Path to policy YAML file")
+    p_rollback = sub.add_parser("rollback", help="Revert to previous policy version")
+    p_rollback.add_argument("version", help="Version to rollback to")
+
+    p_dashboard = sub.add_parser("dashboard", help="Launch monitoring dashboard")
+    p_dashboard.add_argument("--port", type=int, default=8501)
+
+    p_verify = sub.add_parser("verify", help="CI/CD — run all checks before deploy")
+    p_wrap = sub.add_parser("wrap", help="Auto-wrap a supported framework")
+    p_wrap.add_argument("framework", choices=["langchain", "crewai", "autogen"])
+
+    args = parser.parse_args()
+
+    if args.command == "create":
+        _cmd_create(args.description)
+    elif args.command == "check":
+        _cmd_check(args.tool_call)
+    elif args.command == "test":
+        _cmd_test(args.policy)
+    elif args.command == "run":
+        _cmd_run(args.policies)
+    elif args.command == "status":
+        _cmd_status()
+    elif args.command == "hot-reload":
+        _cmd_hot_reload(args.policy_file)
+    elif args.command == "rollback":
+        _cmd_rollback(args.version)
+    elif args.command == "dashboard":
+        _cmd_dashboard(args.port)
+    elif args.command == "verify":
+        _cmd_verify()
+    elif args.command == "wrap":
+        _cmd_wrap(args.framework)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+def _cmd_create(description: str):
+    gen = AutoGenerator()
+    result = gen.generate(description)
+    if result["status"] == "ok":
+        print(f"  Policy '{result['policy_name']}' created")
+        for artifact in result["artifacts"]:
+            print(f"  ✓ Generated {artifact}")
+        rtv = round_trip_verify(result["policy_name"], result["spec"])
+        if rtv["passed"]:
+            print(f"  ✓ Round-trip verification: PASSED")
+            if rtv.get("details"):
+                for d in rtv["details"]:
+                    print(f"    → {d}")
+        else:
+            print(f"  ✗ Round-trip verification: FAILED — {rtv.get('error', '')}")
+    else:
+        print(f"  ✗ Error: {result.get('error', 'Generation failed')}")
+        sys.exit(1)
+
+
+def _cmd_check(tool_call: str):
+    try:
+        raw = json.loads(tool_call)
+    except json.JSONDecodeError:
+        try:
+            with open(tool_call) as f:
+                raw = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError):
+            print("  ✗ Error: Provide valid JSON string or path to JSON file")
+            sys.exit(1)
+
+    from orchestrator import evaluate_tool_call
+    result = evaluate_tool_call(json.dumps(raw))
+    print(json.dumps(result, indent=2))
+
+
+def _cmd_test(policy: str | None):
+    import subprocess, sys as _sys
+    cmd = [_sys.executable, "-m", "pytest", "tests/", "-v"]
+    if policy:
+        test_file = f"tests/test_{policy}.py"
+        cmd = [_sys.executable, "-m", "pytest", test_file, "-v"]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    print(result.stdout)
+    if result.returncode != 0:
+        print(result.stderr)
+        _sys.exit(result.returncode)
+
+
+def _cmd_run(policies: list[str]):
+    from verifier.verifier import Verifier
+    v = Verifier()
+    print(f"  Verifier running with {len(policies)} policy(ies): {', '.join(policies)}")
+    for p in policies:
+        if p not in v._policies and p != "all":
+            print(f"  ⚠ Policy '{p}' not registered")
+    print(f"  Listening for tool calls...")
+
+
+def _cmd_status():
+    from pathlib import Path
+    from policy_store.store import PolicyStore
+    store = PolicyStore(Path("policy_store"))
+    store.load()
+    print(f"  Policy Store: {'healthy' if store.policies else 'empty'}")
+    print(f"  Active policies: {len(store.policies)}")
+    for name in store.policies:
+        print(f"    - {name}")
+    from config import POLICY_ROUTES
+    print(f"  Routes: {len(POLICY_ROUTES)}")
+    for tool, policy in POLICY_ROUTES.items():
+        print(f"    {tool} → {policy}")
+
+
+def _cmd_hot_reload(policy_file: str):
+    from pathlib import Path
+    from policy_store.store import PolicyStore
+    store = PolicyStore(Path("policy_store"))
+    store.hot_reload(Path(policy_file))
+    print(f"  ✓ Hot-reload complete: {policy_file}")
+
+
+def _cmd_rollback(version: str):
+    from pathlib import Path
+    from policy_store.store import PolicyStore
+    store = PolicyStore(Path("policy_store"))
+    store.rollback(version)
+    print(f"  ✓ Rolled back to {version}")
+
+
+def _cmd_dashboard(port: int):
+    print(f"  Launching dashboard on port {port}...")
+    print(f"  Run: streamlit run dashboard/app.py --server.port={port}")
+
+
+def _cmd_verify():
+    import subprocess, sys as _sys
+    print("  Running verification checks...")
+    r1 = subprocess.run([_sys.executable, "-m", "pytest", "tests/", "-x", "-q"], capture_output=True, text=True)
+    print(r1.stdout)
+    if r1.returncode != 0:
+        print("  ✗ Tests failed")
+        print(r1.stderr)
+        _sys.exit(1)
+    r2 = subprocess.run(["lean", "Lean/Policy.lean"], capture_output=True, text=True)
+    if r2.returncode == 0:
+        print("  ✓ Lean theorem compiles")
+    else:
+        print("  ✗ Lean theorem failed")
+        print(r2.stderr)
+        _sys.exit(1)
+    print("  ✓ All checks passed")
+
+
+def _cmd_wrap(framework: str):
+    print(f"  Wrapping {framework}...")
+    print(f"  Import veritool.integrations.{framework} and apply middleware")