ltcai 0.3.1 → 0.4.0

package/latticeai/core/graph_curator.py

@@ -72,6 +72,54 @@ _STOPWORDS: Set[str] = {
     "i'll", "as", "be", "is", "it", "an", "or", "to", "of", "in", "on",
 }
 
+# item 5: 한국어 그래프 노이즈를 줄이기 위한 일반어 blacklist 강화.
+# 의미를 담지 않는 흔한 단어들. (코드/도메인 고유명사는 제외)
+_GENERIC_BLACKLIST: Set[str] = {
+    # 한국어 일반어
+    "내용", "관련", "사용", "경우", "부분", "정도", "생각", "방법", "진행",
+    "확인", "작업", "설정", "추가", "수정", "정보", "결과", "상태", "기준",
+    "그것", "그거", "여기", "거기", "이거", "저거", "무엇", "어떤", "관해",
+    "그냥", "정말", "조금", "많이", "다시", "먼저", "현재", "다음", "이전",
+    # 영어 일반어
+    "thing", "things", "stuff", "etc", "really", "just", "like", "make",
+    "made", "want", "need", "good", "work", "works", "very", "more", "most",
+    "some", "such", "then", "than", "also", "here", "there", "what", "which",
+    "when", "where", "will", "would", "should", "could", "does", "done",
+}
+
+# item 5: 파일 확장자 토큰. 파일명에서 떨어져 나온 노이즈라 노드 후보로 부적절.
+_FILE_EXT_TOKENS: Set[str] = {
+    "py", "js", "ts", "tsx", "jsx", "json", "md", "txt", "csv", "tsv",
+    "png", "jpg", "jpeg", "gif", "svg", "webp", "pdf", "html", "css",
+    "yml", "yaml", "toml", "sh", "bash", "zsh", "log", "ipynb", "xml",
+    "lock", "cfg", "ini", "env", "bin", "exe", "zip", "tar", "gz",
+}
+
+_FILTER_TOKENS: Set[str] = _STOPWORDS | _GENERIC_BLACKLIST | _FILE_EXT_TOKENS
+
+# item 5: 한국어 조사. 토큰 끝에서 제거해 "그래프를"/"그래프가"/"그래프" 를 하나로 모은다.
+_JOSA_SUFFIXES: List[str] = sorted(
+    [
+        "으로는", "에서는", "에서의", "에게서", "이라는", "이라고", "라는", "라고",
+        "으로", "에서", "에게", "한테", "까지", "부터", "보다", "처럼", "마다",
+        "조차", "밖에", "라도", "이나", "에는", "에도", "께서", "이란",
+        "은", "는", "이", "가", "을", "를", "와", "과", "에", "의", "도",
+        "만", "로", "나", "께", "란",
+    ],
+    key=len,
+    reverse=True,
+)
+
+
+def _strip_josa(token: str) -> str:
+    """한국어 토큰 끝의 조사를 제거한다. (영문/혼합 토큰은 그대로)"""
+    if not re.search(r"[가-힣]", token):
+        return token
+    for suf in _JOSA_SUFFIXES:
+        if token.endswith(suf) and len(token) - len(suf) >= 2:
+            return token[: -len(suf)]
+    return token
+
 
 def _tokenize(text: str) -> List[str]:
     if not text:
@@ -81,10 +129,10 @@ def _tokenize(text: str) -> List[str]:
     tokens = [t for t in cleaned.split() if t]
     out = []
     for t in tokens:
-        low = t.lower()
+        low = _strip_josa(t.lower())
         if len(low) < 2:
             continue
-        if low in _STOPWORDS:
+        if low in _FILTER_TOKENS:
             continue
         out.append(low)
     return out
@@ -158,12 +206,20 @@ def extract_topic_candidates(
     for term, score in counts.items():
         if score < min_score:
             continue
-        normalized = math.log(1.0 + score) * (1.0 + 0.05 * len(term.split()))
+        term_sources = sources.get(term, [])
+        # item 5: 같은 대화/폴더(단일 출처)에서만 반복된 단어는 감점한다.
+        # 여러 출처에서 반복된 개념일수록 가산해 "진짜 주제"만 위로 올린다.
+        distinct_sources = len({s for s in term_sources if s})
+        if distinct_sources <= 1:
+            diversity = 0.5  # 단일 출처 노이즈 감점
+        else:
+            diversity = 1.0 + 0.15 * math.log(distinct_sources)
+        normalized = math.log(1.0 + score) * (1.0 + 0.05 * len(term.split())) * diversity
         candidates.append(
             TopicCandidate(
                 label=term,
                 score=round(normalized, 4),
-                sources=sources.get(term, [])[:20],
+                sources=term_sources[:20],
             )
         )
 

package/latticeai/core/model_compat.py

@@ -241,38 +241,70 @@ def fast_postprocess(text: str, profile: Dict[str, Any]) -> str:
 SMOKE_PROMPT = "한국어로 한 문장만 답해. 2+2는?"
 
 
-def validate_smoke_response(text: str) -> Tuple[bool, str]:
-    """Smoke test 응답의 정상성을 판단한다.
+def classify_smoke_response(text: str) -> Tuple[str, str]:
+    """Smoke test 응답을 ok / degraded / failed 로 분류한다. (item 3-3)
+
+    - failed: 채팅에 쓸 수 없는 수준 (빈 응답, 특수/role 토큰 누출, 심한 반복,
+      과도하게 긴 출력).
+    - degraded: 로드/채팅은 되지만 품질이 일정하지 않음 (가벼운 반복, 기대한
+      정답 없음, 다소 긴 출력).
+    - ok: 형식·정답·길이 모두 정상.
 
-    반환: (정상 여부, reason)
+    반환: (status, reason)
     """
     if text is None:
-        return False, "empty response"
+        return "failed", "empty response"
     raw = str(text).strip()
     if not raw:
-        return False, "empty response"
-    # 특수 토큰 leakage
+        return "failed", "empty response"
+
+    # 1. role / 특수 토큰 누출 → 채팅 형식이 깨진 것이므로 failed.
     for marker in BAD_MARKERS:
         if marker in raw:
-            return False, f"role token leakage ({marker})"
-    # 같은 문장 5회 이상 반복
-    sentences = re.split(r"[.!?\n]+", raw)
+            return "failed", f"role token leakage ({marker})"
+    if re.search(r"<\|[^|]{0,40}\|>", raw):
+        return "failed", "special token leakage"
+    # role marker 줄 출력 (예: "assistant:" 로 시작)
+    if re.match(r"^\s*(?:assistant|system|user)\s*:", raw, flags=re.I):
+        return "failed", "role marker leakage"
+
+    # 2. 반복 감지.
+    sentences = [s.strip() for s in re.split(r"[.!?\n]+", raw) if len(s.strip()) >= 3]
     counts: Dict[str, int] = {}
-    for s in sentences:
-        key = s.strip()
-        if len(key) >= 3:
-            counts[key] = counts.get(key, 0) + 1
-    if counts and max(counts.values()) >= 5:
-        return False, "repetition detected"
-    # 4 라는 답이 포함되어 있는지(약한 정상성 휴리스틱)
-    if "4" not in raw and "네" not in raw and "사" not in raw:
-        # 정답이 아니더라도 채팅 형식이 깨지지 않았으면 degraded로 통과
-        if len(raw) < 200:
-            return True, "no exact answer but formed"
-        return False, "answer did not contain 4 and response too long"
+    for key in sentences:
+        counts[key] = counts.get(key, 0) + 1
+    max_rep = max(counts.values()) if counts else 0
+    if max_rep >= 5:
+        return "failed", "severe repetition"
+    # 문자열 단위 폭주 반복 (예: "안녕안녕안녕…", "AAAA…")
+    if re.search(r"(.{1,20}?)\1{6,}", raw):
+        return "failed", "runaway repetition"
+
+    # 3. 과도하게 긴 출력 → failed.
     if len(raw) > 4000:
-        return False, "response too long"
-    return True, "ok"
+        return "failed", "response too long"
+
+    # 4. 여기까지 왔으면 채팅은 가능. degraded 신호를 모은다.
+    degraded: List[str] = []
+    if max_rep >= 3:
+        degraded.append("mild repetition")
+    if len(raw) > 600:
+        degraded.append("response longer than expected")
+    has_answer = ("4" in raw) or ("네" in raw) or ("사" in raw)
+    if not has_answer:
+        degraded.append("answer did not contain expected result")
+    if degraded:
+        return "degraded", "; ".join(degraded)
+    return "ok", "ok"
+
+
+def validate_smoke_response(text: str) -> Tuple[bool, str]:
+    """하위호환 wrapper. (ok 또는 degraded면 채팅 가능 → True)
+
+    반환: (채팅 가능 여부, reason)
+    """
+    status, reason = classify_smoke_response(text)
+    return status != "failed", reason
 
 
 # ── Compat cache (Slow Path) ──────────────────────────────────────────────────
@@ -346,11 +378,21 @@ def record_smoke_result(
     engine: Optional[str],
     ok: bool,
     reason: str,
+    *,
+    status: Optional[str] = None,
 ) -> CompatProfile:
+    """Smoke 결과를 프로필 캐시에 기록한다.
+
+    status 가 주어지면 ok/degraded/failed 3분류를 그대로 저장한다.
+    (하위호환: status 없이 ok bool만 오면 ok→"ok", False→"degraded")
+    """
     profile = ensure_profile(model_id, engine)
     profile.loaded = True
     profile.chat_compatible = bool(ok)
-    profile.quality_status = "ok" if ok else "degraded"
+    if status in ("ok", "degraded", "failed"):
+        profile.quality_status = status
+    else:
+        profile.quality_status = "ok" if ok else "degraded"
     profile.last_test_error = None if ok else reason
     profile.validated_at = time.time()
     remember_profile(profile)
@@ -395,6 +437,7 @@ __all__ = [
     "get_model_profile",
     "fast_postprocess",
     "validate_smoke_response",
+    "classify_smoke_response",
     "ensure_profile",
     "lookup_profile",
     "remember_profile",

package/latticeai/core/timezones.py

@@ -0,0 +1,80 @@
+"""Shared timezone helper (피드백 #5 / item 7).
+
+문제: audit 로그 timestamp는 ``datetime.now()`` (시스템 로컬 시간)으로 기록되는데,
+security_dashboard는 "오늘 이벤트 수"를 ``datetime.utcnow().date()`` (UTC) 기준으로
+계산해서 한국 사용자에게 events_today가 어긋났다.
+
+해결: 모든 날짜/시간 기준을 하나의 timezone 헬퍼로 통일한다.
+
+- 환경변수 ``LATTICE_TZ`` (또는 호환용 ``LTCAI_TZ``)가 있으면 그 시간대를 쓴다.
+  예: ``LATTICE_TZ=Asia/Seoul``.
+- 없으면 시스템 로컬 시간대를 쓴다 (기존 audit timestamp와 동일한 기준).
+
+이렇게 하면 "타임스탬프를 쓸 때 쓰는 시간대" === "오늘을 계산할 때 쓰는 시간대" 가
+항상 일치한다.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from datetime import datetime, tzinfo
+from typing import Optional
+
+try:  # py3.9+
+    from zoneinfo import ZoneInfo
+except Exception:  # pragma: no cover - 매우 오래된 런타임
+    ZoneInfo = None  # type: ignore
+
+logger = logging.getLogger(__name__)
+
+_TZ_ENV_VARS = ("LATTICE_TZ", "LTCAI_TZ")
+
+
+def _system_local_tz() -> tzinfo:
+    # tz-aware 시스템 로컬 시간대.
+    return datetime.now().astimezone().tzinfo  # type: ignore[return-value]
+
+
+def get_timezone() -> tzinfo:
+    """설정된 시간대를 돌려준다. (환경변수 → 시스템 로컬 순)"""
+    for var in _TZ_ENV_VARS:
+        name = (os.environ.get(var) or "").strip()
+        if not name:
+            continue
+        if ZoneInfo is None:
+            logger.warning("zoneinfo 사용 불가, %s=%s 무시하고 시스템 로컬 사용", var, name)
+            break
+        try:
+            return ZoneInfo(name)
+        except Exception:
+            logger.warning("알 수 없는 시간대 %s=%s, 시스템 로컬로 대체", var, name)
+            break
+    return _system_local_tz()
+
+
+def now(tz: Optional[tzinfo] = None) -> datetime:
+    """설정된 시간대의 현재 시각 (tz-aware)."""
+    return datetime.now(tz or get_timezone())
+
+
+def now_iso(tz: Optional[tzinfo] = None) -> str:
+    """ISO8601 문자열. audit timestamp 기록용."""
+    return now(tz).isoformat()
+
+
+def today_str(tz: Optional[tzinfo] = None) -> str:
+    """오늘 날짜 ``YYYY-MM-DD``. events_today 계산용."""
+    return now(tz).date().isoformat()
+
+
+def tz_name() -> str:
+    """설정된 시간대 이름(있으면 환경변수 값, 없으면 'local')."""
+    for var in _TZ_ENV_VARS:
+        name = (os.environ.get(var) or "").strip()
+        if name:
+            return name
+    return "local"
+
+
+__all__ = ["get_timezone", "now", "now_iso", "today_str", "tz_name"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Lattice AI local MLX/cloud LLM workspace server",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -23,7 +23,7 @@
     "test:unit": "python3 -m pytest tests/unit/ -v",
     "test:integration": "python3 -m pytest tests/integration/ -v",
     "publish:npm": "npm publish --access public",
-    "publish:pypi": "python3 -m twine upload dist/*"
+    "publish:pypi": "python3 -m twine upload --skip-existing dist/*.tar.gz dist/*.whl"
   },
   "keywords": [
     "ltcai",