ltcai 6.1.0 → 6.2.0

package/ltcai_cli.py

@@ -1,283 +1,11 @@
-"""Command line entrypoint for Lattice AI."""
+"""Compatibility shim for the historical root CLI module."""
 
-from __future__ import annotations
-
-import argparse
-import os
-import platform
-import re
-import shutil
-import socket
-import stat
-import subprocess
-import sys
-import threading
-import time
-import urllib.request
-from pathlib import Path
-
-from latticeai.cli.runtime import (
-    _apply_extra_path,
-    _has_module,
-    _load_env_file,
-)
-
-def _local_ips() -> list[str]:
-    ips: list[str] = []
-    try:
-        hostname = socket.gethostname()
-        for info in socket.getaddrinfo(hostname, None):
-            addr = info[4][0]
-            if ":" not in addr and not addr.startswith("127."):
-                if addr not in ips:
-                    ips.append(addr)
-    except Exception:
-        pass
-    if not ips:
-        try:
-            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.connect(("8.8.8.8", 80))
-            ips.append(s.getsockname()[0])
-            s.close()
-        except Exception:
-            pass
-    return ips
-
-
-def _print_banner(host: str, port: int, tunnel_url: str | None = None) -> None:
-    local_url = f"http://localhost:{port}"
-    print()
-    print("=" * 56)
-    print("  Lattice AI is running")
-    print(f"  Local:    {local_url}")
-    if host == "0.0.0.0":
-        for ip in _local_ips():
-            print(f"  Network:  http://{ip}:{port}")
-        print()
-        print("  Other devices on the same Wi-Fi can open the")
-        print("  Network URL above in their browser.")
-        print("  On iPad/Android: browser menu → 'Add to Home Screen'")
-    if tunnel_url:
-        print()
-        print(f"  Tunnel:   {tunnel_url}")
-        print("  Anyone on the internet can access via the Tunnel URL.")
-    print("=" * 56)
-    print()
-
-
-def doctor() -> int:
-    checks = [
-        ("Python 3.11+", sys.version_info >= (3, 11), sys.version.split()[0], True),
-        ("FastAPI", _has_module("fastapi"), "required server dependency", True),
-        ("Uvicorn", _has_module("uvicorn"), "required server dependency", True),
-        ("OpenAI SDK", _has_module("openai"), "required for cloud providers", False),
-        ("MLX", _has_module("mlx"), "required for Apple Silicon multimodal models", False),
-        ("MLX-VLM", _has_module("mlx_vlm"), "required for Gemma-4/VLM models", False),
-        ("Ollama binary", shutil.which("ollama") is not None, "optional local-server engine", False),
-    ]
-    data_dir = Path(os.getenv("LATTICEAI_DATA_DIR") or Path.home() / ".ltcai")
-    static_dir = Path(os.getenv("LATTICEAI_STATIC_DIR") or Path(__file__).resolve().parent / "static")
-    checks.extend([
-        ("Data dir", data_dir.exists() or data_dir.parent.exists(), str(data_dir), True),
-        ("Static UI", static_dir.exists(), str(static_dir), True),
-    ])
-
-    ok = True
-    for label, passed, detail, required in checks:
-        icon = "OK" if passed else ("MISS" if required else "OPTIONAL")
-        print(f"[{icon}] {label}: {detail}")
-        ok = ok and (passed or not required)
-
-    cloud_keys = ["OPENAI_API_KEY", "OPENROUTER_API_KEY", "GROQ_API_KEY", "TOGETHER_API_KEY"]
-    configured = [key for key in cloud_keys if os.getenv(key)]
-    print(f"[INFO] Cloud keys configured: {', '.join(configured) if configured else 'none'}")
-    return 0 if ok else 1
-
-
-# ── Cloudflare Tunnel ─────────────────────────────────────────────────────────
-
-def _cloudflared_url() -> str:
-    system = sys.platform
-    machine = platform.machine().lower()
-    base = "https://github.com/cloudflare/cloudflared/releases/latest/download"
-    if system == "darwin":
-        arch = "arm64" if machine in ("arm64", "aarch64") else "amd64"
-        return f"{base}/cloudflared-darwin-{arch}"
-    if system == "win32":
-        return f"{base}/cloudflared-windows-amd64.exe"
-    arch = "arm64" if machine in ("arm64", "aarch64") else "amd64"
-    return f"{base}/cloudflared-linux-{arch}"
-
-
-def _cloudflared_bin() -> Path:
-    suffix = ".exe" if sys.platform == "win32" else ""
-    return Path.home() / ".latticeai" / "bin" / f"cloudflared{suffix}"
-
-
-def _ensure_cloudflared() -> str:
-    found = shutil.which("cloudflared")
-    if found:
-        return found
-    dest = _cloudflared_bin()
-    if dest.exists():
-        return str(dest)
-    dest.parent.mkdir(parents=True, exist_ok=True)
-    url = _cloudflared_url()
-    print("  cloudflared not found — downloading from GitHub...")
-    try:
-        urllib.request.urlretrieve(url, dest)
-        if sys.platform != "win32":
-            dest.chmod(dest.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
-        print(f"  cloudflared installed at {dest}")
-        return str(dest)
-    except Exception as e:
-        print(f"  cloudflared download failed: {e}")
-        print("  Install manually: https://developers.cloudflare.com/cloudflared/install")
-        return ""
-
-
-def _send_telegram(token: str, chat_id: str, text: str) -> None:
-    try:
-        data = urllib.parse.urlencode({"chat_id": chat_id, "text": text}).encode()
-        req = urllib.request.Request(
-            f"https://api.telegram.org/bot{token}/sendMessage",
-            data=data,
-        )
-        urllib.request.urlopen(req, timeout=10)
-    except Exception:
-        pass
-
-
-def _start_tunnel(port: int) -> str | None:
-
-    bin_path = _ensure_cloudflared()
-    if not bin_path:
-        return None
-
-    log_path = Path.home() / ".latticeai" / "tunnel.log"
-    log_path.parent.mkdir(parents=True, exist_ok=True)
-
-    proc = subprocess.Popen(
-        [bin_path, "tunnel", "--url", f"http://localhost:{port}"],
-        stdout=open(log_path, "w"),
-        stderr=subprocess.STDOUT,
-    )
-
-    # Wait for the public URL (up to 30s)
-    pattern = re.compile(r"https://[a-z0-9-]+\.trycloudflare\.com")
-    deadline = time.time() + 30
-    url: str | None = None
-    while time.time() < deadline:
-        time.sleep(0.5)
-        try:
-            text = log_path.read_text(errors="replace")
-            m = pattern.search(text)
-            if m:
-                url = m.group(0)
-                break
-        except Exception:
-            pass
-
-    if not url:
-        return None
-
-    # Telegram notification if configured
-    token = os.getenv("LATTICEAI_TELEGRAM_BOT_TOKEN", "")
-    chat_id = os.getenv("LATTICEAI_TELEGRAM_CHAT_ID", "")
-    if token and chat_id:
-        msg = (
-            f"✅ Lattice AI 시작됨\n\n"
-            f"🌐 외부 URL: {url}\n"
-            f"🏠 로컬: http://localhost:{port}"
-        )
-        threading.Thread(target=_send_telegram, args=(token, chat_id, msg), daemon=True).start()
-
-    return url
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-
-def main() -> None:
-    app_dir = Path(__file__).resolve().parent
-    _load_env_file(app_dir / ".env")
-    _apply_extra_path()
-
-    parser = argparse.ArgumentParser(prog="LTCAI", description="Run the Lattice AI local server.")
-    subparsers = parser.add_subparsers(dest="command")
-    subparsers.add_parser("doctor", help="Check local runtime dependencies and configuration.")
-    parser.add_argument("--host", default=os.getenv("LATTICEAI_HOST") or "127.0.0.1")
-    parser.add_argument("--port", type=int, default=int(os.getenv("LATTICEAI_PORT") or "4825"))
-    parser.add_argument("--reload", action="store_true", help="Enable uvicorn reload for local development.")
-    parser.add_argument(
-        "--tunnel",
-        action="store_true",
-        help="Open a public Cloudflare tunnel so anyone can access this server from the internet.",
-    )
-    args = parser.parse_args()
-
-    if args.command == "doctor":
-        raise SystemExit(doctor())
-
-    os.chdir(app_dir)
-
-    if not args.tunnel and os.getenv("LATTICEAI_TUNNEL", "").lower() in (
-        "1",
-        "true",
-        "yes",
-    ):
-        print(
-            "  LATTICEAI_TUNNEL is ignored during default local startup; "
-            "restart with --tunnel to expose this server."
-        )
-
-    # --tunnel forces 0.0.0.0 so cloudflared can reach the server
-    if args.tunnel and args.host == "127.0.0.1":
-        args.host = "0.0.0.0"
-        os.environ.setdefault("LATTICEAI_HOST", "0.0.0.0")
-        os.environ.setdefault("LATTICEAI_CORS_ALLOW_NETWORK", "true")
-        os.environ.setdefault("LATTICEAI_REQUIRE_AUTH", "true")
-
-    # Keep the app config in sync with CLI flags. ``Config.from_env`` is the
-    # source of truth for /mode, /health.features, SSO defaults, and routers.
-    os.environ["LATTICEAI_HOST"] = str(args.host)
-    os.environ["LATTICEAI_PORT"] = str(args.port)
-
-    tunnel_url: str | None = None
-    if args.tunnel:
-        print()
-        print("  Starting Cloudflare tunnel...")
-        tunnel_url = _start_tunnel(args.port)
-        if not tunnel_url:
-            print("  ⚠️  Tunnel URL not obtained — server will start without tunnel.")
-
-    _print_banner(args.host, args.port, tunnel_url)
-
-    # Telegram startup notification (local start, tunnel handled separately inside _start_tunnel)
-    if not args.tunnel:
-        _tg_enabled = os.getenv("LATTICEAI_ENABLE_TELEGRAM", "").strip().lower() in ("1", "true", "yes", "on")
-        _tg_token = os.getenv("LATTICEAI_TELEGRAM_BOT_TOKEN", "")
-        _tg_chat  = os.getenv("LATTICEAI_TELEGRAM_CHAT_ID", "")
-        if _tg_enabled and _tg_token and _tg_chat:
-            _local_msg = (
-                f"✅ Lattice AI 시작됨\n\n"
-                f"🏠 로컬: http://localhost:{args.port}"
-            )
-            threading.Thread(
-                target=_send_telegram,
-                args=(_tg_token, _tg_chat, _local_msg),
-                daemon=True,
-            ).start()
-
-    import uvicorn
-
-    uvicorn.run(
-        "server:app",
-        host=args.host,
-        port=args.port,
-        reload=args.reload,
-        log_level="info",
-    )
+from latticeai.cli import entrypoint as _impl
 
 
 if __name__ == "__main__":
-    main()
+    _impl.main()
+else:
+    import sys
+
+    sys.modules[__name__] = _impl

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.1.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",