ltcai 11.7.0 → 11.9.0

package/latticeai/core/agent_permission.py

@@ -1,85 +0,0 @@
-"""Agent-loop permission-mode gates (v9.9.8) — the two the parity fixtures pin.
-
-These were the Python loop's mode tables, called by ``SingleAgentRuntime`` and
-``build_agent_runtime``. Orchestration moved to ``lattice-agent`` in v11.6.0 and
-the Python loop is gone, so **nothing in the worker imports this module**.
-
-It survives for one reason, stated so it is not read as a leftover:
-``scripts/generate_agent_parity_fixtures.py`` produces the committed goldens
-``rust/fixtures`` holds for the Rust loop's permission gates, and it derives
-them from :func:`block_reason_for_tool` and :func:`non_auto_plan_steps` here.
-Deleting these two would leave the Rust side asserting against fixtures no
-Python could regenerate — the fixtures would still pass, and would stop meaning
-anything. The rest of the module (``call_mode_source``, ``resolve_deps_mode``,
-``approval_requirements_for``) went with the loop that called it.
-"""
-
-from __future__ import annotations
-
-from typing import Any, List, Mapping, Optional, Sequence
-
-from latticeai.core.permission_mode import (
-    PermissionMode,
-    effective_auto_approve,
-    is_circuit_breaker,
-    normalize_mode,
-)
-
-
-def non_auto_plan_steps(
-    mode: PermissionMode | str,
-    steps: Sequence[Mapping[str, Any]],
-    tool_governance: Mapping[str, Mapping[str, Any]],
-    *,
-    governed_tools: Optional[Any] = None,
-) -> List[Any]:
-    """Plan steps that still need approval under the active mode."""
-    mode = normalize_mode(mode)
-    governed = frozenset(governed_tools or ())
-    non_auto: List[Any] = []
-    for step in steps:
-        name = step.get("action")
-        if not name:
-            continue
-        if name in governed and mode == PermissionMode.STRICT:
-            # Strict keeps governor tools out of the plan-level block (per-call).
-            continue
-        policy = dict(tool_governance.get(name) or {
-            "auto_approve": False, "risk": "write", "destructive": False,
-            "shell": False, "network": False, "sandbox": "workspace", "rollback": "none",
-        })
-        if effective_auto_approve(mode, str(name), policy):
-            continue
-        non_auto.append(name)
-    return non_auto
-
-
-def block_reason_for_tool(
-    mode: PermissionMode | str,
-    name: str,
-    policy: Mapping[str, Any],
-    args: Mapping[str, Any],
-    *,
-    approved_by_human: bool = False,
-    governor_allows_additive: bool = False,
-) -> Optional[str]:
-    """Return a block reason, or None when the call may proceed."""
-    mode = normalize_mode(mode)
-    breaker = is_circuit_breaker(name, policy, args)
-    if breaker:
-        return f"BLOCKED: {breaker}"
-    if policy.get("risk") == "destructive" or policy.get("destructive"):
-        return f"BLOCKED: destructive action '{name}' not permitted in agent mode."
-    if approved_by_human or governor_allows_additive:
-        return None
-    if effective_auto_approve(mode, name, policy, args=args):
-        return None
-    if policy.get("auto_approve"):
-        return None
-    return f"BLOCKED: action '{name}' requires explicit approval (mode={mode.value})."
-
-
-__all__ = [
-    "block_reason_for_tool",
-    "non_auto_plan_steps",
-]

package/scripts/agent_eval.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-"""Agent-loop evaluation gate — native since v11.6.0.
-
-The deterministic scenario suite used to live in
-``latticeai.core.agent_eval`` and drive ``SingleAgentRuntime``. That loop is
-``lattice-agent`` now. CI still invokes this path; we verify the native suite
-is present rather than importing the deleted Python runtime.
-
-Last Python generating tree: commit fc65e60.
-Goldens: ``rust/fixtures/agent_loop/golden/`` (FROZEN).
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parents[1]
-REQUIRED = (
-    REPO / "rust" / "lattice-agent" / "tests" / "agent_loop.rs",
-    REPO / "rust" / "fixtures" / "agent_loop" / "golden",
-)
-
-
-def main() -> int:
-    missing = [str(path.relative_to(REPO)) for path in REQUIRED if not path.exists()]
-    if missing:
-        print("agent-loop-eval: FAIL missing native artifacts:", missing)
-        return 1
-    print("agent-loop-eval: native lattice-agent suite present (Python loop retired)")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/scripts/brain_quality_eval.py

@@ -1,37 +0,0 @@
-#!/usr/bin/env python3
-"""Brain recall / KG quality eval — native since v11.6.0.
-
-This used to import ``KnowledgeGraphStore``, ``RetrievalBenchmarkRunner`` and
-``MemoryService`` and run the Python retrieval bench. Retrieval and the
-store are ``lattice-retrieval`` / ``lattice-core`` now. CI still invokes
-this path; we verify the native goldens and the worker embedder report
-are present.
-
-Last Python generating tree: commit fc65e60.
-Goldens: ``rust/fixtures/golden/`` (FROZEN).
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parents[1]
-REQUIRED = (
-    REPO / "rust" / "fixtures" / "golden" / "manifest.json",
-    REPO / "rust" / "fixtures" / "parity_store.sqlite",
-    REPO / "latticeai" / "api" / "search.py",
-    REPO / "latticeai" / "services" / "search_service.py",
-)
-
-
-def main() -> int:
-    missing = [str(path.relative_to(REPO)) for path in REQUIRED if not path.exists()]
-    if missing:
-        print("brain-quality-eval: FAIL missing native artifacts:", missing)
-        return 1
-    print("brain-quality-eval: native retrieval goldens present (Python store retired)")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/scripts/check_legacy_debt.mjs

@@ -1,91 +0,0 @@
-#!/usr/bin/env node
-// Legacy debt gate (9.9.1): the root shim layer stays removed.
-//
-// Fails when:
-//  1. a Python module other than server.py appears at the repository root;
-//  2. any source tree imports a removed root shim module;
-//  3. a removed shim directory (tools/) reappears at the root.
-//
-// Mirror of tests/unit/test_legacy_root_shims.py, but static and runnable in
-// `npm run lint` without a Python environment.
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join, relative } from "node:path";
-
-const repo = join(import.meta.dirname, "..");
-
-const ALLOWED_ROOT_MODULES = new Set(["server.py"]);
-const REMOVED_ROOT_DIRS = ["tools"];
-const REMOVED_MODULES = [
-  "ltcai_cli",
-  "auto_setup",
-  "setup_wizard",
-  "mcp_registry",
-  "kg_schema",
-  "knowledge_graph",
-  "knowledge_graph_api",
-  "local_knowledge_api",
-  "llm_router",
-  "p_reinforce",
-  "telegram_bot",
-  "tools",
-];
-// Trees that must not import removed shims. static/app and node_modules are
-// build output; src-tauri/target is compiler output.
-const SOURCE_TREES = ["latticeai", "lattice_brain", "tests", "scripts", "bin"];
-
-const failures = [];
-
-for (const entry of readdirSync(repo)) {
-  if (entry.endsWith(".py") && !ALLOWED_ROOT_MODULES.has(entry)) {
-    failures.push(`root module reappeared: ${entry} — put code in latticeai/ or lattice_brain/`);
-  }
-}
-for (const dir of REMOVED_ROOT_DIRS) {
-  if (existsSync(join(repo, dir))) {
-    failures.push(`removed root package reappeared: ${dir}/ — use latticeai.${dir} instead`);
-  }
-}
-
-const modulePattern = REMOVED_MODULES.join("|");
-const pyImport = new RegExp(`^\\s*(?:import\\s+(?:${modulePattern})\\b|from\\s+(?:${modulePattern})\\s+import\\b)`);
-const jsSpawn = new RegExp(`(?:${modulePattern})\\.py\\b`);
-
-function* walk(dir) {
-  for (const entry of readdirSync(dir)) {
-    if (entry === "__pycache__" || entry === "node_modules" || entry === ".venv") continue;
-    const full = join(dir, entry);
-    const st = statSync(full);
-    if (st.isDirectory()) yield* walk(full);
-    else yield full;
-  }
-}
-
-for (const tree of SOURCE_TREES) {
-  const base = join(repo, tree);
-  if (!existsSync(base)) continue;
-  for (const file of walk(base)) {
-    const rel = relative(repo, file);
-    if (/\.py$/.test(file)) {
-      const lines = readFileSync(file, "utf8").split("\n");
-      lines.forEach((line, i) => {
-        if (pyImport.test(line)) {
-          failures.push(`${rel}:${i + 1} imports a removed root shim: ${line.trim()}`);
-        }
-      });
-    } else if (/\.(mjs|cjs|js)$/.test(file) && !/\.min\.js$/.test(file)) {
-      const lines = readFileSync(file, "utf8").split("\n");
-      lines.forEach((line, i) => {
-        if (jsSpawn.test(line) && !line.includes("check_legacy_debt")) {
-          failures.push(`${rel}:${i + 1} references a removed root shim file: ${line.trim()}`);
-        }
-      });
-    }
-  }
-}
-
-if (failures.length > 0) {
-  console.error("legacy debt gate FAILED:");
-  for (const failure of failures) console.error(`  - ${failure}`);
-  process.exit(1);
-}
-console.log("legacy debt gate ok: root shim layer stays removed (server.py only)");

package/scripts/check_python.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-"""Discover-and-syntax-check every first-party Python module.
-
-Replaces the hand-maintained ``py_compile`` enumeration in CI and
-``package.json``: walks the repository, skips vendored / virtualenv / build /
-cache / generated directories, and checks everything that remains. New
-modules are picked up automatically — there is nothing to update when a file is
-added, so the syntax gate can never silently fall behind the codebase.
-
-Unlike ``py_compile``, this script does not write ``.pyc`` files or create
-``__pycache__`` directories. Validation should not dirty a developer's working
-tree or leave generated files for later lint passes to trip over.
-
-Usage::
-
-    python scripts/check_python.py            # syntax-check all discovered modules
-    python scripts/check_python.py --list     # just print what would be checked
-
-Exit code is non-zero if any module fails to parse.
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-ROOT = Path(__file__).resolve().parent.parent
-
-# Directory names excluded anywhere in the tree: virtualenvs, build/cache
-# artifacts, generated agent output, and vendored snapshots of older releases.
-EXCLUDE_DIRS = {
-    ".git",
-    ".venv",
-    "venv",
-    "env",
-    ".build-venv",
-    ".npm-cache",
-    "build",
-    "dist",
-    "node_modules",
-    "__pycache__",
-    ".pytest_cache",
-    ".mypy_cache",
-    ".ruff_cache",
-    "agent_workspace",
-    "outputs",
-    "playwright-report",
-    "test-results",
-    "ltcai.egg-info",
-    "output",
-    ".ltcai",
-    ".ltcai-brain",
-    ".ltcai-test",
-    # Vendored snapshot of an older packaged release — not part of the build.
-    "ltcai-0.3.1",
-}
-
-
-def iter_modules():
-    for path in ROOT.rglob("*.py"):
-        parts = path.relative_to(ROOT).parts
-        if any(part in EXCLUDE_DIRS for part in parts):
-            continue
-        yield path
-
-
-def check_syntax(path: Path) -> str | None:
-    """Return a human-readable failure string, or ``None`` when syntax is valid."""
-
-    try:
-        compile(path.read_bytes(), str(path), "exec", dont_inherit=True)
-    except (OSError, SyntaxError, ValueError) as exc:
-        return f"{path.relative_to(ROOT)}: {exc}"
-    return None
-
-
-def main(argv: list[str]) -> int:
-    modules = sorted(iter_modules())
-    if "--list" in argv:
-        for path in modules:
-            print(path.relative_to(ROOT))
-        return 0
-
-    failures: list[str] = []
-    for path in modules:
-        failure = check_syntax(path)
-        if failure:
-            failures.append(failure)
-
-    if failures:
-        print("\n".join(failures))
-        print(f"check:python FAILED — {len(failures)} of {len(modules)} module(s) did not parse")
-        return 1
-
-    print(f"check:python OK — syntax-checked {len(modules)} modules")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))