ltcai 6.0.0 → 6.2.0

package/p_reinforce.py

@@ -1,258 +1,7 @@
-"""
-P-Reinforce Knowledge Gardener — notes capture with a brain-backed memory.
+"""Compatibility shim for the historical root P-Reinforce module."""
 
-v4 (T4.3 garden absorption): the markdown vault is no longer a second brain.
-The vault stays as the user-owned, Obsidian-compatible *mirror* (capability
-preserved), but the Knowledge Graph is authoritative: notes created through
-the API are ingested through the unified pipeline (provenance + hooks), the
-existing vault is imported idempotently, and chat context comes from brain
-queries instead of an O(n) vault scan per message.
-"""
+import sys
 
-import logging
-import os
-import re
-import shutil
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Optional
+from latticeai.services import p_reinforce as _impl
 
-BRAIN_DIR = Path(
-    os.getenv("LATTICEAI_OBSIDIAN_VAULT_DIR")
-    or os.getenv("LATTICEAI_BRAIN_DIR")
-    or Path.home() / ".ltcai-brain"
-)
-
-STRUCTURE = {
-    "10_Wiki":   "검증된 지식, 개념 설명, 레퍼런스",
-    "00_Raw":    "정제되지 않은 원시 데이터, 아이디어 메모",
-    "20_Skills": "재사용 가능한 코드 스니펫, 프롬프트, 워크플로",
-    "30_Projects": "프로젝트별 컨텍스트, 진행 상황",
-    "40_Log":    "날짜별 작업 로그",
-}
-
-
-class PReinforceGardener:
-    def __init__(self, ingestion_pipeline: Any = None, knowledge_graph: Any = None):
-        self._pipeline = ingestion_pipeline
-        self._kg = knowledge_graph
-        self._ensure_structure()
-
-    def _ensure_structure(self):
-        for folder in STRUCTURE:
-            (BRAIN_DIR / folder).mkdir(parents=True, exist_ok=True)
-        # 인덱스 파일
-        index_path = BRAIN_DIR / "INDEX.md"
-        if not index_path.exists():
-            index_path.write_text(self._render_index())
-
-    def _render_index(self) -> str:
-        lines = ["# 🧠 Lattice AI Brain — P-Reinforce Index\n"]
-        lines.append(f"*Generated: {datetime.now().strftime('%Y-%m-%d %H:%M')}*\n")
-        lines.append("\nThis folder is an Obsidian-compatible Markdown vault.\n")
-        lines.append("\nThe Knowledge Graph is the authoritative store; this vault is the\nuser-owned markdown mirror of garden notes.\n")
-        for folder, desc in STRUCTURE.items():
-            lines.append(f"## [{folder}](./{folder}/)\n_{desc}_\n")
-        lines.append("## Connector Status\n")
-        lines.append(f"- OCR engine: `{'tesseract' if shutil.which('tesseract') else 'not installed'}`\n")
-        return "\n".join(lines)
-
-    # ── Classify ──────────────────────────────────────────────────────────────
-
-    def _classify(self, text: str) -> str:
-        """간단한 규칙 기반 분류 (LLM 없이도 동작)"""
-        text_lower = text.lower()
-
-        code_signals = ["def ", "class ", "import ", "```", "function ", "const ", "let ", "var "]
-        if any(s in text for s in code_signals):
-            return "20_Skills"
-
-        wiki_signals = ["개념", "원리", "이란", "what is", "how does", "definition", "explanation"]
-        if any(s in text_lower for s in wiki_signals):
-            return "10_Wiki"
-
-        project_signals = ["project", "프로젝트", "todo", "task", "작업", "기능", "feature"]
-        if any(s in text_lower for s in project_signals):
-            return "30_Projects"
-
-        return "00_Raw"
-
-    # ── File Naming ───────────────────────────────────────────────────────────
-
-    def _make_filename(self, text: str, folder: str) -> str:
-        # 첫 줄을 제목으로
-        first_line = text.strip().split("\n")[0][:60]
-        # 파일명 안전하게
-        safe = re.sub(r"[^\w\s-]", "", first_line).strip()
-        safe = re.sub(r"\s+", "_", safe)
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        return f"{timestamp}_{safe or 'note'}.md"
-
-    # ── Process ───────────────────────────────────────────────────────────────
-
-    async def process(self, raw_data: str, category: Optional[str] = None) -> dict:
-        folder = category if category in STRUCTURE else self._classify(raw_data)
-        filename = self._make_filename(raw_data, folder)
-        filepath = BRAIN_DIR / folder / filename
-
-        # 마크다운 미러 (사용자 소유 Obsidian 호환 아티팩트)
-        content = self._wrap_markdown(raw_data, folder)
-        filepath.write_text(content, encoding="utf-8")
-
-        # 오늘 로그에도 기록
-        self._append_log(raw_data[:200], folder, filename)
-
-        result = {
-            "status": "saved",
-            "folder": folder,
-            "filename": filename,
-            "path": str(filepath),
-            "classified_as": folder,
-            "description": STRUCTURE[folder],
-        }
-        # 두뇌(Knowledge Graph)가 정식 저장소: 통합 수집 파이프라인으로 ingest.
-        result.update(self._ingest_note(raw_data, source_uri=str(filepath), folder=folder))
-        return result
-
-    def _ingest_note(self, text: str, *, source_uri: str, folder: str, title: Optional[str] = None) -> dict:
-        if self._pipeline is None:
-            return {"graph": "unavailable", "graph_detail": "ingestion pipeline not wired"}
-        try:
-            from lattice_brain.ingestion import IngestionItem
-
-            ingest = self._pipeline.ingest(
-                IngestionItem(
-                    source_type="note",
-                    title=title or text.strip().split("\n")[0][:80],
-                    text=text,
-                    source_uri=source_uri,
-                    metadata={"garden_folder": folder, "pipeline": "p-reinforce"},
-                )
-            )
-            if ingest.status != "ok":
-                return {"graph": ingest.status, "graph_detail": ingest.detail}
-            return {
-                "graph": "ok",
-                "graph_node_id": ingest.node_id,
-                "provenance_id": ingest.provenance_id,
-                "duplicate": ingest.duplicate,
-            }
-        except Exception as exc:
-            logging.warning("garden note ingest failed: %s", exc)
-            return {"graph": "failed", "graph_detail": str(exc)}
-
-    def import_vault(self) -> dict:
-        """Idempotent import of every existing vault note into the brain.
-
-        Content-hash dedup in the store makes re-runs safe; vault files are
-        never modified or deleted. INDEX.md and the daily logs are skipped.
-        """
-        if self._pipeline is None:
-            return {"status": "unavailable", "imported": 0}
-        imported = duplicates = failed = 0
-        for file_path in sorted(BRAIN_DIR.rglob("*.md")):
-            if file_path.name == "INDEX.md" or "40_Log" in file_path.parts:
-                continue
-            try:
-                text = file_path.read_text(encoding="utf-8")
-            except Exception:
-                failed += 1
-                continue
-            folder = file_path.parent.name if file_path.parent != BRAIN_DIR else "00_Raw"
-            outcome = self._ingest_note(
-                text, source_uri=str(file_path), folder=folder, title=file_path.stem
-            )
-            if outcome.get("graph") == "ok":
-                if outcome.get("duplicate"):
-                    duplicates += 1
-                else:
-                    imported += 1
-            else:
-                failed += 1
-        if imported:
-            logging.info("garden: imported %d vault notes into the brain (%d already known)", imported, duplicates)
-        return {"status": "ok", "imported": imported, "duplicates": duplicates, "failed": failed}
-
-    def _wrap_markdown(self, raw: str, folder: str) -> str:
-        now = datetime.now().strftime("%Y-%m-%d %H:%M")
-        first_line = raw.strip().split("\n")[0][:80]
-        lines = [
-            f"# {first_line}",
-            f"\n> 📁 `{folder}` | 🕐 {now} | Lattice AI MLX\n",
-            "---\n",
-            raw,
-            "\n\n---",
-            "*Auto-organized by P-Reinforce Gardener*",
-        ]
-        return "\n".join(lines)
-
-    def _append_log(self, preview: str, folder: str, filename: str):
-        today = datetime.now().strftime("%Y-%m-%d")
-        log_path = BRAIN_DIR / "40_Log" / f"{today}.md"
-        entry = f"\n- [{datetime.now().strftime('%H:%M')}] → `{folder}/{filename}`\n  > {preview[:100]}\n"
-        with open(log_path, "a", encoding="utf-8") as f:
-            if log_path.stat().st_size == 0 if log_path.exists() else True:
-                f.write(f"# 📅 Log — {today}\n")
-            f.write(entry)
-
-    # ── Tree ──────────────────────────────────────────────────────────────────
-
-    def get_tree(self) -> dict:
-        """지식 정원 파일트리 (마크다운 미러 기준)."""
-        folders = []
-        for folder, desc in STRUCTURE.items():
-            folder_path = BRAIN_DIR / folder
-            files = []
-            if folder_path.exists():
-                for file_path in sorted(folder_path.glob("*.md")):
-                    try:
-                        stat = file_path.stat()
-                        files.append({
-                            "name": file_path.name,
-                            "size_bytes": stat.st_size,
-                            "modified_at": datetime.fromtimestamp(stat.st_mtime).isoformat(timespec="seconds"),
-                        })
-                    except OSError:
-                        continue
-            folders.append({"name": folder, "description": desc, "files": files, "count": len(files)})
-        return {"root": str(BRAIN_DIR), "folders": folders}
-
-    def get_relevant_context(self, query: str, limit: int = 3) -> str:
-        """질문과 관련된 정원 노트를 두뇌에서 검색해 컨텍스트로 반환.
-
-        v4: 채팅마다 vault 전체를 rglob 하던 O(n) 스캔을 브레인 검색으로
-        대체. 그래프가 없으면(비활성) 기존 파일 스캔으로 정직하게 폴백.
-        """
-        if self._kg is not None:
-            try:
-                matches = self._kg.search(query, max(limit * 4, 8)).get("matches", [])
-                results = []
-                for match in matches:
-                    meta = match.get("metadata") or {}
-                    if not (meta.get("garden_folder") or meta.get("pipeline") == "p-reinforce"):
-                        continue
-                    title = match.get("title") or "note"
-                    body = match.get("summary") or ""
-                    results.append(f"--- Document: {title} ---\n{body[:800]}")
-                    if len(results) >= limit:
-                        break
-                return "\n\n".join(results)
-            except Exception as exc:
-                logging.debug("garden brain context failed, falling back to vault scan: %s", exc)
-        return self._scan_vault_context(query, limit)
-
-    def _scan_vault_context(self, query: str, limit: int = 3) -> str:
-        results = []
-        for file_path in BRAIN_DIR.rglob("*.md"):
-            if file_path.name == "INDEX.md" or "40_Log" in str(file_path):
-                continue
-            try:
-                content = file_path.read_text(encoding="utf-8")
-                keywords = [k for k in re.split(r"\s+", query) if len(k) > 1]
-                if any(k.lower() in content.lower() for k in keywords):
-                    results.append(f"--- Document: {file_path.name} ---\n{content[:800]}")
-                    if len(results) >= limit:
-                        break
-            except Exception:
-                continue
-        return "\n\n".join(results)
+sys.modules[__name__] = _impl

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "6.0.0",
+  "version": "6.2.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -40,6 +40,7 @@
     "package:vsix": "node scripts/build_vsix.mjs",
     "release:artifacts": "node scripts/clean_release_artifacts.mjs $npm_package_version && npm run build:assets && npm run build:python && npm pack && npm run package:vsix && npm run desktop:tauri:build",
     "release:validate": "node scripts/run_python.mjs scripts/validate_release_artifacts.py $npm_package_version --require-vsix --require-tgz --require-dmg",
+    "release:smoke": "node scripts/run_python.mjs scripts/release_smoke.py $npm_package_version",
     "publish:npm": "npm pack && npm publish ltcai-$npm_package_version.tgz --access public",
     "publish:pypi": "npm run build:python && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl",
     "publish:vscode": "cd vscode-extension && npm run package:vsix && npm run publish:vscode",

package/scripts/release_smoke.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Release smoke checks for exact-version release artifacts.
+
+This complements ``validate_release_artifacts.py`` by opening the generated
+artifacts and proving the installable surfaces are coherent:
+
+- wheel installs/imports in a fresh environment via ``wheel_smoke.py``
+- npm tgz contains the package metadata, CLI bin, and static assets
+- static asset manifest points at files that exist on disk
+- Tauri DMG/app bundle exists, and can optionally be launched briefly
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import tarfile
+import time
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+
+
+def run(cmd: list[str], **kwargs) -> None:
+    print("+", " ".join(str(item) for item in cmd), flush=True)
+    subprocess.run(cmd, check=True, **kwargs)
+
+
+def smoke_wheel(version: str, skip_health: bool) -> None:
+    wheel = REPO_ROOT / "dist" / f"ltcai-{version}-py3-none-any.whl"
+    if not wheel.is_file():
+        raise SystemExit(f"missing wheel: {wheel}")
+    cmd = [sys.executable, str(REPO_ROOT / "scripts" / "wheel_smoke.py"), "--wheel", str(wheel)]
+    if skip_health:
+        cmd.append("--skip-health")
+    run(cmd, cwd=REPO_ROOT)
+
+
+def smoke_npm_tgz(version: str) -> None:
+    tgz = REPO_ROOT / f"ltcai-{version}.tgz"
+    if not tgz.is_file():
+        raise SystemExit(f"missing npm tgz: {tgz}")
+    required = {
+        "package/package.json",
+        "package/bin/ltcai.js",
+        "package/static/app/index.html",
+        "package/static/app/asset-manifest.json",
+    }
+    with tarfile.open(tgz, "r:gz") as archive:
+        names = set(archive.getnames())
+        missing = sorted(required - names)
+        if missing:
+            raise SystemExit(f"{tgz.name} missing entries: {missing}")
+        package_data = json.loads(archive.extractfile("package/package.json").read().decode("utf-8"))  # type: ignore[union-attr]
+        if package_data.get("version") != version:
+            raise SystemExit(f"{tgz.name} package.json version {package_data.get('version')!r} != {version!r}")
+    print(f"npm tgz smoke ok: {tgz.name}")
+
+
+def smoke_static_assets(version: str) -> None:
+    manifest_path = REPO_ROOT / "static" / "app" / "asset-manifest.json"
+    if not manifest_path.is_file():
+        raise SystemExit(f"missing static manifest: {manifest_path}")
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    if manifest.get("version") != version:
+        raise SystemExit(f"static manifest version {manifest.get('version')!r} != {version!r}")
+    required_paths = {"/static/app/index.html"}
+    required_paths.update(str(path) for path in manifest.get("assets", {}).values())
+    missing = []
+    for static_path in required_paths:
+        rel = static_path.removeprefix("/static/")
+        path = REPO_ROOT / "static" / rel
+        if not path.is_file():
+            missing.append(static_path)
+    if missing:
+        raise SystemExit(f"static manifest references missing files: {missing}")
+    print(f"static asset smoke ok: {len(required_paths)} files")
+
+
+def smoke_tauri(version: str, launch: bool) -> None:
+    dmg = REPO_ROOT / "src-tauri" / "target" / "release" / "bundle" / "dmg" / f"Lattice AI_{version}_aarch64.dmg"
+    app = REPO_ROOT / "src-tauri" / "target" / "release" / "bundle" / "macos" / "Lattice AI.app"
+    macos_dir = app / "Contents" / "MacOS"
+    executable = app / "Contents" / "MacOS" / "Lattice AI"
+    if not executable.exists() and macos_dir.is_dir():
+        candidates = [path for path in macos_dir.iterdir() if path.is_file() and os.access(path, os.X_OK)]
+        if candidates:
+            executable = candidates[0]
+    missing = [path for path in (dmg, app, executable) if not path.exists()]
+    if missing:
+        raise SystemExit("missing Tauri artifact(s): " + ", ".join(str(path) for path in missing))
+    if launch:
+        env = {
+            **os.environ,
+            "LATTICEAI_ENABLE_TELEGRAM": "false",
+            "LATTICEAI_AUTOLOAD_MODELS": "false",
+        }
+        proc = subprocess.Popen([str(executable)], cwd=REPO_ROOT, env=env)
+        time.sleep(4)
+        if proc.poll() not in (None, 0):
+            raise SystemExit(f"Tauri executable exited early with {proc.returncode}")
+        if proc.poll() is None:
+            proc.terminate()
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait(timeout=5)
+        print("Tauri launch smoke ok")
+    else:
+        print(f"Tauri artifact smoke ok: {dmg.name}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("version", help="exact version to smoke, e.g. 6.2.0")
+    parser.add_argument("--skip-wheel-health", action="store_true", help="skip FastAPI /health check inside wheel smoke")
+    parser.add_argument("--launch-tauri", action="store_true", help="briefly launch the built Tauri executable")
+    args = parser.parse_args()
+
+    smoke_wheel(args.version, args.skip_wheel_health)
+    smoke_npm_tgz(args.version)
+    smoke_static_assets(args.version)
+    smoke_tauri(args.version, args.launch_tauri)
+    print(f"release smoke passed for v{args.version}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/wheel_smoke.py

@@ -46,9 +46,13 @@ WHEEL_MODULES = [
     "latticeai",
     "latticeai.server_app",
     "latticeai.app_factory",
+    "latticeai.cli.entrypoint",
+    "latticeai.integrations",
+    "latticeai.integrations.telegram_bot",
     "latticeai.models.router",
     "latticeai.core.mcp_registry",
     "latticeai.api.knowledge_graph",
+    "latticeai.services.p_reinforce",
     "ltcai_cli",
     "auto_setup",
     "server",

package/src-tauri/Cargo.lock

@@ -1654,7 +1654,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "6.0.0"
+version = "6.2.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "6.0.0"
+version = "6.2.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "6.0.0",
+  "version": "6.2.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,13 +1,13 @@
 {
-  "version": "6.0.0",
+  "version": "6.2.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-D2zafMYb.js",
-    "assets/index-xRn29gI8.css": "/static/app/assets/index-xRn29gI8.css"
+    "index.html": "/static/app/assets/index-D91Rz5--.js",
+    "assets/index-B2-1Gm0q.css": "/static/app/assets/index-B2-1Gm0q.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-D2zafMYb.js",
+      "file": "assets/index-D91Rz5--.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-xRn29gI8.css"
+        "assets/index-B2-1Gm0q.css"
       ]
     }
   }