ltcai 11.5.2 → 11.7.0

package/latticeai/core/product_hardening.py

@@ -1,218 +0,0 @@
-"""Product hardening and privacy status helpers.
-
-These helpers are read-only and must not perform network probes. They describe
-the local-first startup posture and distinguish available credentials from
-enabled outbound communication.
-"""
-
-from __future__ import annotations
-
-import os
-import shutil
-from pathlib import Path
-from typing import Any, Dict, Mapping, Optional
-
-from latticeai import __version__
-from latticeai.core.config import Config
-
-
-def _bool(env: Mapping[str, str], key: str, default: bool = False) -> bool:
-    raw = env.get(key)
-    if raw is None:
-        return default
-    return raw.strip().lower() in {"1", "true", "yes", "on"}
-
-
-def _present(env: Mapping[str, str], *keys: str) -> bool:
-    return any(bool(str(env.get(key) or "").strip()) for key in keys)
-
-
-def external_integration_status(
-    config: Config,
-    *,
-    env: Optional[Mapping[str, str]] = None,
-) -> Dict[str, Any]:
-    if env is None:
-        env = os.environ
-    telegram_credentials = _present(env, "LATTICEAI_TELEGRAM_BOT_TOKEN", "TELEGRAM_BOT_TOKEN")
-    brain_network_auto_push = _bool(env, "LATTICEAI_BRAIN_NETWORK_AUTO_PUSH", default=False)
-    updater_enabled = _bool(env, "LATTICEAI_ENABLE_UPDATES", default=False)
-    model_downloads_enabled = _bool(env, "LATTICEAI_ALLOW_MODEL_DOWNLOADS", default=False) or bool(config.autoload_models)
-    docker_auto_start = _bool(env, "LATTICEAI_DOCKER_AUTO_START", default=False)
-    external_connectors_enabled = _bool(env, "LATTICEAI_ENABLE_EXTERNAL_CONNECTORS", default=False)
-    postgres_enabled = config.storage_engine == "postgres" and bool(config.postgres_dsn)
-    return {
-        "local_only_default": default_startup_local_only(config, env=env),
-        "integrations": {
-            "telegram": {
-                "enabled": bool(config.enable_telegram),
-                "credential_present": telegram_credentials,
-                "opt_in_required": True,
-                "automatic_egress": bool(config.enable_telegram),
-                "detail": (
-                    "enabled by LATTICEAI_ENABLE_TELEGRAM"
-                    if config.enable_telegram
-                    else "disabled; token presence alone does not start Telegram"
-                ),
-            },
-            "brain_network": {
-                "enabled": brain_network_auto_push,
-                "credential_present": False,
-                "opt_in_required": True,
-                "automatic_egress": brain_network_auto_push,
-                "detail": "peer pushes are user/admin initiated; no automatic peer sync by default",
-            },
-            "updates": {
-                "enabled": updater_enabled,
-                "credential_present": False,
-                "opt_in_required": True,
-                "automatic_egress": updater_enabled,
-                "detail": "desktop updater checks are disabled unless LATTICEAI_ENABLE_UPDATES is true",
-            },
-            "model_downloads": {
-                "enabled": model_downloads_enabled,
-                "credential_present": _present(env, "HF_TOKEN", "HUGGINGFACEHUB_API_TOKEN"),
-                "opt_in_required": True,
-                "automatic_egress": bool(config.autoload_models),
-                "detail": "model downloads require an explicit load/autoload setting",
-            },
-            "docker": {
-                "enabled": docker_auto_start,
-                "credential_present": False,
-                "opt_in_required": True,
-                "automatic_egress": docker_auto_start,
-                "detail": "Docker setup requires explicit runtime consent; auto-start is disabled by default",
-            },
-            "postgres": {
-                "enabled": postgres_enabled,
-                "credential_present": bool(config.postgres_dsn),
-                "opt_in_required": True,
-                "automatic_egress": postgres_enabled,
-                "detail": "Postgres scale mode is used only when storage engine and DSN are explicitly configured",
-            },
-            "external_connectors": {
-                "enabled": external_connectors_enabled,
-                "credential_present": _present(
-                    env,
-                    "OPENAI_API_KEY",
-                    "ANTHROPIC_API_KEY",
-                    "GITHUB_TOKEN",
-                    "SLACK_BOT_TOKEN",
-                    "DISCORD_BOT_TOKEN",
-                ),
-                "opt_in_required": True,
-                "automatic_egress": external_connectors_enabled,
-                "detail": "connector credentials are inert until the connector is explicitly enabled and invoked",
-            },
-        },
-    }
-
-
-def default_startup_local_only(
-    config: Config,
-    *,
-    env: Optional[Mapping[str, str]] = None,
-) -> bool:
-    if env is None:
-        env = os.environ
-    local_embedding = config.embedding_provider in {"", "hash", "local", "fallback", "sqlite"}
-    external = external_integration_status_no_recurse(config, env=env)
-    return (
-        not config.network_exposed
-        and not config.cors_allow_network
-        and not config.enable_telegram
-        and not config.autoload_models
-        and config.storage_engine == "sqlite"
-        and local_embedding
-        and not any(item["automatic_egress"] for item in external.values())
-    )
-
-
-def external_integration_status_no_recurse(
-    config: Config,
-    *,
-    env: Mapping[str, str],
-) -> Dict[str, Dict[str, Any]]:
-    return {
-        "brain_network": {"automatic_egress": _bool(env, "LATTICEAI_BRAIN_NETWORK_AUTO_PUSH", default=False)},
-        "updates": {"automatic_egress": _bool(env, "LATTICEAI_ENABLE_UPDATES", default=False)},
-        "docker": {"automatic_egress": _bool(env, "LATTICEAI_DOCKER_AUTO_START", default=False)},
-        "postgres": {"automatic_egress": config.storage_engine == "postgres" and bool(config.postgres_dsn)},
-        "external_connectors": {"automatic_egress": _bool(env, "LATTICEAI_ENABLE_EXTERNAL_CONNECTORS", default=False)},
-    }
-
-
-def build_product_hardening_status(
-    *,
-    config: Config,
-    portability: Any = None,
-    device_identity: Any = None,
-    env: Optional[Mapping[str, str]] = None,
-) -> Dict[str, Any]:
-    if env is None:
-        env = os.environ
-    storage = {"available": False}
-    backup = {"available": False}
-    if portability is not None and getattr(portability, "available", lambda: False)():
-        storage = portability.storage_status()
-        backup = portability.backup_health()
-    identity = {}
-    if device_identity is not None:
-        identity = device_identity.describe()
-    data_dir = Path(config.data_dir)
-    return {
-        "version": __version__,
-        "startup": {
-            "local_only_default": default_startup_local_only(config, env=env),
-            "host": config.host,
-            "port": config.port,
-            "network_exposed": config.network_exposed,
-            "auth_required": config.require_auth,
-            "cors_network_allowed": config.cors_allow_network,
-        },
-        "desktop": {
-            "sidecar_lifecycle": "managed",
-            "restart_supported": True,
-            "shutdown_supported": True,
-            "updater": {
-                "enabled": _bool(env, "LATTICEAI_ENABLE_UPDATES", default=False),
-                "limitation": "No external update checks run unless explicitly enabled by policy.",
-            },
-        },
-        "first_run": {
-            "data_dir": str(data_dir),
-            "data_dir_exists": data_dir.exists(),
-            "python_available": shutil.which("python3") is not None or shutil.which("python") is not None,
-            "docker_available": shutil.which("docker") is not None,
-            "docker_required": False,
-            "postgres_required": False,
-        },
-        "privacy": external_integration_status(config, env=env),
-        "storage": storage,
-        "backup": backup,
-        "device_identity": identity,
-        "permissions": {
-            "export_requires_admin": True,
-            "import_requires_admin": True,
-            "restore_requires_admin": True,
-            "destructive_restore_requires_confirmation": True,
-            "workspace_isolation_enforced": True,
-            "audit_log_visible_to_admin": True,
-        },
-        "failure_policy": {
-            "archive_corruption": "fail_closed",
-            "partial_archive": "fail_closed",
-            "signature_mismatch": "fail_closed",
-            "unsupported_version": "fail_closed",
-            "missing_docker": "honest_unavailable",
-            "missing_postgres": "honest_unavailable",
-            "permission_denied": "honest_error",
-        },
-    }
-
-
-__all__ = [
-    "build_product_hardening_status",
-    "default_startup_local_only",
-    "external_integration_status",
-]

package/latticeai/core/project_sessions.py

@@ -1,337 +0,0 @@
-"""Persistent project sessions — the multi-turn project loop (v9.9.6).
-
-A single agent run is well modelled: PLAN → EXECUTE → VERIFY, with a durable
-approval pause and a transcript. What was missing is the loop *above* it —
-"만들고 → 고치고 → 검증하고 → 다시 고치는" work that spans several runs and
-several days. Each run started from a blank workspace picture, so the second
-turn could not see what the first produced, what still failed verification, or
-what was left to do.
-
-A project session is that missing state:
-
-* ``files`` — every artifact the project's runs actually produced;
-* ``todos`` — what is still open (explicit, user- or agent-authored);
-* ``last_verification`` — the most recent honest outcome (never upgraded);
-* ``runs`` — the run history that got there.
-
-Storage mirrors :mod:`latticeai.core.run_store`: one JSON file per session
-under the data dir, atomic replace on write, no new dependencies. Reads are
-fail-open (a corrupt file is skipped, not fatal); writes never break a run —
-a project session is context, not a gate.
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-import secrets
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from latticeai.core.io_utils import atomic_write_json
-from latticeai.core.timeutil import now_iso
-
-LOGGER = logging.getLogger(__name__)
-
-__all__ = ["ProjectSessionStore", "PROJECT_STATUSES"]
-
-# Terminal-ish project states. "active" is the default; "archived" hides a
-# project from the default listing without deleting its history.
-PROJECT_STATUSES = ("active", "archived")
-
-_SESSION_ID_RE = re.compile(r"^[A-Za-z0-9_-]{8,64}$")
-_MAX_FILES = 200
-_MAX_TODOS = 100
-_MAX_RUNS = 100
-
-
-def _clean(value: Any, limit: int) -> str:
-    return str(value or "").strip()[:limit]
-
-
-class ProjectSessionStore:
-    """JSON-file store for long-running project sessions."""
-
-    def __init__(self, root: Path) -> None:
-        self._root = Path(root)
-
-    # ── paths ────────────────────────────────────────────────────────────
-    def _path(self, session_id: str) -> Optional[Path]:
-        if not _SESSION_ID_RE.match(str(session_id or "")):
-            return None
-        return self._root / f"{session_id}.json"
-
-    def _ensure_root(self) -> None:
-        self._root.mkdir(parents=True, exist_ok=True)
-
-    # ── read ─────────────────────────────────────────────────────────────
-    def _load(self, session_id: str) -> Optional[Dict[str, Any]]:
-        path = self._path(session_id)
-        if path is None or not path.exists():
-            return None
-        try:
-            import json
-
-            with path.open(encoding="utf-8") as handle:
-                data = json.load(handle)
-            return data if isinstance(data, dict) else None
-        except Exception as exc:  # noqa: BLE001 — a bad file is skipped, not fatal
-            LOGGER.warning("project session load failed for %s: %s", session_id, exc)
-            return None
-
-    def get(
-        self,
-        session_id: str,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """One session, scoped. Returns None when it does not exist or is
-        outside the caller's scope — never a partial record."""
-        record = self._load(session_id)
-        if record is None:
-            return None
-        if user_email is not None and record.get("user_email") != user_email:
-            return None
-        if workspace_id is not None and record.get("workspace_id") != workspace_id:
-            return None
-        return record
-
-    def list(
-        self,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        status: str = "active",
-    ) -> Dict[str, Any]:
-        """Sessions for a caller, newest first. ``status="all"`` includes archived."""
-        if not self._root.exists():
-            return {"projects": [], "count": 0}
-        sessions: List[Dict[str, Any]] = []
-        for path in self._root.glob("*.json"):
-            record = self._load(path.stem)
-            if record is None:
-                continue
-            if user_email is not None and record.get("user_email") != user_email:
-                continue
-            if workspace_id is not None and record.get("workspace_id") != workspace_id:
-                continue
-            if status != "all" and record.get("status") != status:
-                continue
-            sessions.append(record)
-        sessions.sort(key=lambda item: str(item.get("updated_at") or ""), reverse=True)
-        return {"projects": sessions, "count": len(sessions)}
-
-    # ── write ────────────────────────────────────────────────────────────
-    def _save(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        record["updated_at"] = now_iso()
-        path = self._path(str(record.get("id") or ""))
-        if path is None:
-            raise ValueError("invalid project session id")
-        try:
-            self._ensure_root()
-            atomic_write_json(path, record)
-        except Exception as exc:  # noqa: BLE001 — persistence never breaks a run
-            LOGGER.warning("project session save failed for %s: %s", record.get("id"), exc)
-        return record
-
-    def create(
-        self,
-        *,
-        title: str,
-        goal: str = "",
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        session_id = secrets.token_urlsafe(12)
-        record: Dict[str, Any] = {
-            "id": session_id,
-            "title": _clean(title, 200) or "프로젝트",
-            "goal": _clean(goal, 2000),
-            "status": "active",
-            "user_email": user_email,
-            "workspace_id": workspace_id,
-            "created_at": now_iso(),
-            "updated_at": now_iso(),
-            "files": [],
-            "todos": [],
-            "runs": [],
-            "last_verification": None,
-        }
-        return self._save(record)
-
-    def update(
-        self,
-        session_id: str,
-        *,
-        title: Optional[str] = None,
-        goal: Optional[str] = None,
-        status: Optional[str] = None,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Optional[Dict[str, Any]]:
-        record = self.get(session_id, user_email=user_email, workspace_id=workspace_id)
-        if record is None:
-            return None
-        if title is not None:
-            record["title"] = _clean(title, 200) or record["title"]
-        if goal is not None:
-            record["goal"] = _clean(goal, 2000)
-        if status is not None and status in PROJECT_STATUSES:
-            record["status"] = status
-        return self._save(record)
-
-    def delete(
-        self,
-        session_id: str,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> bool:
-        record = self.get(session_id, user_email=user_email, workspace_id=workspace_id)
-        if record is None:
-            return False
-        path = self._path(session_id)
-        try:
-            if path is not None and path.exists():
-                path.unlink()
-            return True
-        except OSError as exc:
-            LOGGER.warning("project session delete failed for %s: %s", session_id, exc)
-            return False
-
-    def set_todos(
-        self,
-        session_id: str,
-        todos: List[Any],
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """Replace the open-work list. Accepts strings or ``{text, done}`` dicts."""
-        record = self.get(session_id, user_email=user_email, workspace_id=workspace_id)
-        if record is None:
-            return None
-        normalized: List[Dict[str, Any]] = []
-        for raw in list(todos or [])[:_MAX_TODOS]:
-            if isinstance(raw, dict):
-                text = _clean(raw.get("text"), 300)
-                done = bool(raw.get("done"))
-            else:
-                text = _clean(raw, 300)
-                done = False
-            if text:
-                normalized.append({"text": text, "done": done})
-        record["todos"] = normalized
-        return self._save(record)
-
-    def record_run(
-        self,
-        session_id: str,
-        *,
-        run_id: str = "",
-        goal: str = "",
-        status: str = "",
-        final_state: str = "",
-        files: Optional[List[Any]] = None,
-        explanation: Optional[Dict[str, Any]] = None,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-    ) -> Optional[Dict[str, Any]]:
-        """Fold one finished agent run into the project's state.
-
-        The verification result is recorded exactly as the run reported it —
-        a NEEDS_REVIEW run never becomes a project's "done".
-        """
-        record = self.get(session_id, user_email=user_email, workspace_id=workspace_id)
-        if record is None:
-            return None
-        paths: List[str] = []
-        for entry in list(files or []):
-            path = entry if isinstance(entry, str) else (entry or {}).get("path")
-            path = _clean(path, 400)
-            if path and path not in paths:
-                paths.append(path)
-        known = list(record.get("files") or [])
-        for path in paths:
-            if path not in known:
-                known.append(path)
-        record["files"] = known[-_MAX_FILES:]
-        headline = ""
-        next_step = ""
-        if isinstance(explanation, dict):
-            headline = _clean((explanation.get("headline") or {}).get("ko"), 400)
-            next_step = _clean((explanation.get("next_step") or {}).get("ko"), 400)
-        entry = {
-            "run_id": _clean(run_id, 120),
-            "goal": _clean(goal, 400),
-            "status": _clean(status, 40),
-            "final_state": _clean(final_state, 40),
-            "files": paths,
-            "at": now_iso(),
-            **({"headline": headline} if headline else {}),
-            **({"next_step": next_step} if next_step else {}),
-        }
-        runs = list(record.get("runs") or [])
-        runs.append(entry)
-        record["runs"] = runs[-_MAX_RUNS:]
-        record["last_verification"] = {
-            "final_state": entry["final_state"],
-            "ok": bool(isinstance(explanation, dict) and explanation.get("ok")),
-            "at": entry["at"],
-            **({"headline": headline} if headline else {}),
-            # Failure-learning loop (review 루프 §3): what the *last* attempt
-            # says to do differently travels into the next run's plan context
-            # instead of dying with the run.
-            **({"next_step": next_step} if next_step else {}),
-        }
-        return self._save(record)
-
-    # ── prompt context ───────────────────────────────────────────────────
-    def summary(
-        self,
-        session_id: str,
-        *,
-        user_email: Optional[str] = None,
-        workspace_id: Optional[str] = None,
-        max_files: int = 15,
-        max_todos: int = 10,
-    ) -> str:
-        """Prompt block describing where this project stands.
-
-        Injected into the planner/executor context so a later run sees the
-        files that already exist, what is still open, and whether the last
-        attempt actually passed. Empty string when there is nothing to say —
-        an empty project must not pad the prompt.
-        """
-        record = self.get(session_id, user_email=user_email, workspace_id=workspace_id)
-        if record is None:
-            return ""
-        lines: List[str] = []
-        title = record.get("title") or ""
-        goal = record.get("goal") or ""
-        lines.append(f"Project: {title}" + (f" — {goal}" if goal else ""))
-        files = list(record.get("files") or [])[-max_files:]
-        if files:
-            lines.append("Files this project has already produced (they exist now):")
-            lines.extend(f"- {path}" for path in files)
-        open_todos = [
-            todo for todo in (record.get("todos") or []) if not todo.get("done")
-        ][:max_todos]
-        if open_todos:
-            lines.append("Still open:")
-            lines.extend(f"- {todo['text']}" for todo in open_todos)
-        verification = record.get("last_verification")
-        if isinstance(verification, dict) and verification.get("final_state"):
-            verdict = verification["final_state"]
-            headline = verification.get("headline") or ""
-            lines.append(
-                f"Last verification: {verdict}" + (f" — {headline}" if headline else "")
-            )
-            next_step = verification.get("next_step") or ""
-            if next_step and not verification.get("ok"):
-                # The previous attempt's own diagnosis, so this plan does not
-                # repeat the same failure.
-                lines.append(f"What the last attempt said to do differently: {next_step}")
-        # Only the header line means nothing worth injecting.
-        return "\n".join(lines) if len(lines) > 1 else ""