ltcai 11.7.0 → 12.0.0

package/latticeai/api/tools.py

@@ -1,126 +0,0 @@
-"""The document parser routes — the two ``/tools/*`` that are pure compute.
-
-This module used to be the direct tool surface: ~30 ``/tools/*`` routes, the
-upload door, the MCP catalogue, computer-use, the permission gateway and the
-local-file browser, all composed into one router. Every one of those is a write,
-an OS actuator, an exec, or platform state, and v11.6.0 serves them from
-``lattice-host``.
-
-Two survive, because parsing a document is compute and nothing else:
-
-``POST /tools/read_document``
-    Text plus metadata out of a ``.pdf`` / ``.docx`` / ``.xlsx`` / ``.pptx`` /
-    plain-text file. The same parser matrix ``POST /worker/parse`` wraps.
-
-``GET /tools/pdf_pages``
-    Up to twenty PDF pages rasterised to base64 PNG through pypdfium2.
-
-**The approval hop is gone, and the confinement is now absolute.** Both routes
-used to accept an approval token minted by ``/permissions/*`` and, with one,
-read a file anywhere on the disk. ``/permissions/*`` is a native platform route
-now and the approval queue is native state, so a token this process is handed is
-one it cannot verify — and a check against an always-empty local queue is not a
-weaker guard, it is a guard that refuses everything while looking like it works.
-Both routes therefore refuse outright outside ``AGENT_ROOT``. Reading an
-arbitrary path on the user's behalf is the host's call to make, with the
-approval record it actually holds.
-"""
-
-from __future__ import annotations
-
-import base64
-import io
-import logging
-from pathlib import Path
-from typing import Optional
-
-from fastapi import APIRouter, Request
-from pydantic import BaseModel
-
-from lattice_brain.runtime.hooks import dispatch_tool
-from latticeai.core.messages import http_error, resolve_language
-from latticeai.tools import AGENT_ROOT, ToolError, read_document
-
-
-class ToolPathRequest(BaseModel):
-    path: str = "."
-    approval_token: Optional[str] = None
-
-
-def create_tools_router(*, require_user) -> APIRouter:
-    router = APIRouter()
-
-    def _confined(request: Request, raw: str) -> Path:
-        """Resolve ``raw`` under ``AGENT_ROOT`` or refuse.
-
-        Relative paths are taken from the workspace root, which is what every
-        caller of these two routes sends. An absolute path is accepted only when
-        it is already inside the workspace, so ``../`` and ``/etc/passwd`` reach
-        the same refusal by the same rule.
-        """
-        candidate = Path(raw).expanduser()
-        target = (
-            candidate.resolve()
-            if candidate.is_absolute()
-            else (AGENT_ROOT / candidate).resolve()
-        )
-        if target != AGENT_ROOT and AGENT_ROOT not in target.parents:
-            raise http_error(403, "tools.path_outside_workspace", resolve_language(request))
-        return target
-
-    @router.post("/tools/read_document")
-    async def tools_read_document(req: ToolPathRequest, request: Request):
-        current_user = require_user(request)
-        target = _confined(request, req.path)
-        try:
-            result = dispatch_tool(
-                None,
-                "read_document",
-                {"path": str(target)},
-                lambda: read_document(str(target)),
-                user_email=current_user,
-                source="workspace",
-            )
-        except ToolError as exc:
-            raise http_error(400, "worker_compute.parse_failed", resolve_language(request)) from exc
-        return {"status": "ok", "workspace": str(AGENT_ROOT), "result": result}
-
-    @router.get("/tools/pdf_pages")
-    async def tools_pdf_pages(path: str, request: Request, approval_token: Optional[str] = None):
-        """Render PDF pages as base64 PNG images using pypdfium2 (Apache-2.0)."""
-        require_user(request)
-        # Accepted and ignored: the host still sends the token it minted, and
-        # rejecting the request for carrying one would break a caller for a
-        # field this process no longer has any way to check.
-        _ = approval_token
-        target = _confined(request, path)
-        if not target.exists() or not target.is_file():
-            raise http_error(404, "common.file_not_found", resolve_language(request))
-        import pypdfium2 as pdfium
-        doc = None
-        try:
-            doc = pdfium.PdfDocument(str(target))
-            total = len(doc)
-            pages = []
-            for i in range(min(total, 20)):  # 최대 20페이지
-                page = doc[i]
-                bitmap = page.render(scale=1.5)
-                pil_image = bitmap.to_pil()
-                buf = io.BytesIO()
-                pil_image.save(buf, format="PNG")
-                b64 = base64.b64encode(buf.getvalue()).decode()
-                pages.append({"page": i + 1, "b64": b64})
-            return {"total": total, "pages": pages}
-        except Exception as e:
-            raise http_error(500, "tools.pdf_render_failed", resolve_language(request), reason=e)
-        finally:
-            if doc is not None:
-                try:
-                    doc.close()
-                except Exception as e:
-                    logging.warning("pypdfium2 doc close failed: %s", e)
-
-    return router
-
-
-__all__ = ["ToolPathRequest", "create_tools_router"]

package/latticeai/api/voice_capture.py

@@ -1,32 +0,0 @@
-"""Voice capability router (v9.9.7).
-
-``GET /api/capture/voice/status`` — what this machine can actually do with a
-voice memo. Capture and storage are native (``POST /api/capture/voice`` moved
-to ``lattice-platform`` in §W3b, and calls ``POST /worker/asr`` for the
-transcript); whether a local transcriber exists at all is a fact about this
-process, so the probe stays here.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Callable
-
-from fastapi import APIRouter, Request
-
-
-def create_voice_capture_router(
-    *,
-    service: Any,
-    require_user: Callable[[Request], Any],
-) -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/api/capture/voice/status")
-    async def voice_status(request: Request):
-        require_user(request)
-        return service.status()
-
-    return router
-
-
-__all__ = ["create_voice_capture_router"]

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:]))