npm - ltcai - Versions diffs - 9.9.2 → 9.9.4 - Mend

ltcai 9.9.2 → 9.9.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (109) hide show

package/README.md +44 -39
package/docs/CHANGELOG.md +109 -0
package/docs/COMMUNITY_AND_PLUGINS.md +1 -1
package/docs/DEVELOPMENT.md +1 -1
package/docs/ONBOARDING.md +1 -1
package/docs/OPERATIONS.md +1 -1
package/docs/SURFACE_PARITY.md +47 -0
package/docs/TRUST_MODEL.md +1 -1
package/docs/WHY_LATTICE.md +1 -1
package/docs/kg-schema.md +1 -1
package/lattice_brain/__init__.py +1 -1
package/lattice_brain/graph/_kg_common.py +335 -0
package/lattice_brain/graph/curator.py +141 -0
package/lattice_brain/graph/discovery_index.py +8 -1
package/lattice_brain/graph/documents.py +111 -0
package/lattice_brain/graph/fusion.py +179 -0
package/lattice_brain/graph/ingest.py +43 -9
package/lattice_brain/graph/projection.py +382 -37
package/lattice_brain/graph/retrieval.py +71 -4
package/lattice_brain/graph/retrieval_policy.py +174 -0
package/lattice_brain/graph/retrieval_vector.py +122 -2
package/lattice_brain/ingestion.py +66 -0
package/lattice_brain/portability.py +41 -12
package/lattice_brain/runtime/multi_agent.py +1 -1
package/latticeai/__init__.py +1 -1
package/latticeai/api/automation_intelligence.py +159 -0
package/latticeai/api/browser.py +15 -4
package/latticeai/api/chat.py +33 -2
package/latticeai/api/chat_agent_http.py +363 -6
package/latticeai/api/chat_contracts.py +7 -1
package/latticeai/api/chat_helpers.py +147 -0
package/latticeai/api/chat_intents.py +217 -10
package/latticeai/api/chat_stream.py +93 -3
package/latticeai/api/funnel_metrics.py +31 -0
package/latticeai/api/knowledge_graph.py +65 -1
package/latticeai/api/local_files.py +90 -0
package/latticeai/api/setup.py +134 -1
package/latticeai/api/tools.py +33 -3
package/latticeai/app_factory.py +14 -0
package/latticeai/core/agent.py +355 -18
package/latticeai/core/agent_eval.py +107 -0
package/latticeai/core/enterprise.py +5 -0
package/latticeai/core/file_generation.py +404 -2
package/latticeai/core/legacy_compatibility.py +1 -1
package/latticeai/core/marketplace.py +1 -1
package/latticeai/core/run_store.py +243 -0
package/latticeai/core/workspace_os.py +1 -1
package/latticeai/models/router.py +25 -12
package/latticeai/runtime/persistence_runtime.py +19 -1
package/latticeai/runtime/router_registration.py +8 -1
package/latticeai/services/app_context.py +3 -0
package/latticeai/services/architecture_readiness.py +1 -1
package/latticeai/services/automation_execution.py +266 -0
package/latticeai/services/automation_intelligence.py +7 -0
package/latticeai/services/command_center.py +110 -2
package/latticeai/services/folder_watch.py +396 -0
package/latticeai/services/funnel_metrics.py +210 -0
package/latticeai/services/product_readiness.py +1 -1
package/latticeai/services/search_service.py +51 -5
package/latticeai/setup/demo_corpus.py +98 -0
package/latticeai/tools/filesystem.py +38 -1
package/package.json +1 -1
package/scripts/bench_agent_smoke.py +410 -0
package/scripts/bench_models.py +234 -5
package/scripts/check_current_release_docs.mjs +1 -1
package/scripts/funnel_soft_gate.py +192 -0
package/src-tauri/Cargo.lock +1 -1
package/src-tauri/Cargo.toml +1 -1
package/src-tauri/tauri.conf.json +1 -1
package/static/app/asset-manifest.json +29 -27
package/static/app/assets/Act-BCmTU0E2.js +1 -0
package/static/app/assets/{Brain-BnGbytHa.js → Brain-CTnjox7w.js} +2 -2
package/static/app/assets/BrainHome-BJ3sFNX0.js +2 -0
package/static/app/assets/BrainSignals-C52lwZVD.js +1 -0
package/static/app/assets/{Capture-CAKnLcb0.js → Capture-B6vBhFa3.js} +1 -1
package/static/app/assets/CommandPalette-90u9FWFH.js +1 -0
package/static/app/assets/Library-pKCK0_tk.js +1 -0
package/static/app/assets/{LivingBrain-C3VbogVo.js → LivingBrain-Jlf2wFqI.js} +1 -1
package/static/app/assets/{ProductFlow-BLau7c7N.js → ProductFlow-yg1fKP1P.js} +1 -1
package/static/app/assets/ReviewCard-DWvD7n9h.js +3 -0
package/static/app/assets/{System-DRHc_6Su.js → System-BAEuHqNY.js} +1 -1
package/static/app/assets/{bot-DZkDdh-A.js → bot-nB_buEZD.js} +1 -1
package/static/app/assets/circle-pause-DLNw6Ucp.js +1 -0
package/static/app/assets/circle-play-B-IsFL1y.js +1 -0
package/static/app/assets/{cpu-DyvsDBbj.js → cpu-CEPBHaBl.js} +1 -1
package/static/app/assets/{folder-open-CffoIr9t.js → folder-open-hmN0N9cX.js} +1 -1
package/static/app/assets/{hard-drive-C1oojrHb.js → hard-drive-CBV_B_Yd.js} +1 -1
package/static/app/assets/index-7FAfYm4v.css +2 -0
package/static/app/assets/{index-BS_3aN1n.js → index-DrmOCySv.js} +3 -3
package/static/app/assets/{input-B_U7zvbR.js → input-gtVCg-ll.js} +1 -1
package/static/app/assets/{navigation-xG-gyjbe.js → navigation-Bot0hvuv.js} +1 -1
package/static/app/assets/{network-BF13HJJF.js → network-jE42eKfT.js} +1 -1
package/static/app/assets/{primitives-DsuKh3M8.js → primitives-CX2Komon.js} +1 -1
package/static/app/assets/shield-alert-BftATuAA.js +1 -0
package/static/app/assets/{textarea-DsDL4ET8.js → textarea-CiMJfOSI.js} +1 -1
package/static/app/assets/useFocusTrap-B7RPGfFy.js +1 -0
package/static/app/assets/utils-SJUNVOj5.js +7 -0
package/static/app/index.html +4 -4
package/static/sw.js +1 -1
package/static/app/assets/Act-Cx_gZNbE.js +0 -1
package/static/app/assets/BrainHome-CRUMJL93.js +0 -2
package/static/app/assets/BrainSignals-BP8-Qh2g.js +0 -1
package/static/app/assets/CommandPalette-BoUTXBfm.js +0 -1
package/static/app/assets/Library-PcfVUco6.js +0 -1
package/static/app/assets/ReviewCard-CX5RqRqx.js +0 -1
package/static/app/assets/download-C7yxYHvz.js +0 -1
package/static/app/assets/index-DU78Kogz.css +0 -2
package/static/app/assets/sunrise-CIP2ELJ1.js +0 -1
package/static/app/assets/utils-Dh-Dwtkb.js +0 -7

package/latticeai/core/agent_eval.py CHANGED Viewed

@@ -163,6 +163,18 @@ class Scenario:
     # canned results (node ids, snippets, proposal ids), so an answer that is
     # not grounded in the retrieved/executed evidence fails the scenario.
     expect_final_contains: List[str] = field(default_factory=list)
+    # Exact per-name counts against the LoopTrace ``repairs`` histogram —
+    # filegen scenarios use this to prove the ArtifactWritePipeline actually
+    # fired (``artifact_sanitize`` / ``artifact_repair``), not merely that
+    # the tool ran.
+    expect_repairs: Dict[str, int] = field(default_factory=dict)
+    # Content-level assertions on what file-writing tools actually received
+    # AFTER sanitize: every ``contains`` needle must appear in at least one
+    # written payload, every ``excludes`` needle in none. This is the teeth
+    # of the dirty-write scenarios — a fence or chat wrapper reaching the
+    # tool port fails the gate.
+    expect_write_contains: List[str] = field(default_factory=list)
+    expect_write_excludes: List[str] = field(default_factory=list)
     max_steps: int = 8
@@ -247,6 +259,37 @@ _WRITE = '{"action": "write_file", "args": {"path": "note.txt", "content": "hi"}
 _FINAL = '{"action": "final", "message": "done"}'
 _PASS = '{"action": "verdict", "verdict": "PASS", "next_state": "DONE", "reason": "ok"}'
+# ── dirty write_file payloads (ArtifactWritePipeline scenarios) ──────────
+# What weak local models actually put in args.content: chat framing + a
+# Markdown fence around the document. The JSON envelope itself is valid —
+# the dirt is *inside* the content string, so only the write-side sanitize
+# pass (agent.py _dispatch_step → sanitize_write_content) can clean it.
+_DIRTY_HTML_CONTENT = (
+    "Sure! Here is your page:\\n"
+    "```html\\n"
+    "<!DOCTYPE html>\\n<html>\\n<head><meta charset=\\\"utf-8\\\">"
+    "<title>Hello</title></head>\\n<body><h1>Hello</h1></body>\\n</html>\\n"
+    "```\\n"
+    "Hope this helps! Let me know if you need changes."
+)
+_DIRTY_WRITE = (
+    '{"thoughts": "produce the page", "action": "write_file", '
+    '"args": {"path": "pages/hello.html", "content": "' + _DIRTY_HTML_CONTENT + '"}}'
+)
+# Token-limit casualty: the document just stops mid-body (no </body>/</html>).
+_TRUNCATED_HTML_CONTENT = (
+    "<!DOCTYPE html>\\n<html>\\n<head><meta charset=\\\"utf-8\\\">"
+    "<title>Weekly</title></head>\\n<body>\\n<h1>Weekly report</h1>"
+)
+_TRUNCATED_WRITE = (
+    '{"thoughts": "write the report", "action": "write_file", '
+    '"args": {"path": "reports/weekly.html", "content": "' + _TRUNCATED_HTML_CONTENT + '"}}'
+)
+_FILEGEN_PLAN = (
+    '{"action": "plan", "goal": "save the requested web page to disk", '
+    '"steps": [{"action": "write_file"}]}'
+)
 def default_scenarios() -> List[Scenario]:
     return [
@@ -551,6 +594,54 @@ def default_scenarios() -> List[Scenario]:
             expected_class="failed",
             expect_tool_outcomes={"error": 1},
         ),
+        # ── ArtifactWritePipeline (write-side sanitize) ─────────────────
+        Scenario(
+            name="filegen-dirty-write-sanitized-critic-pass",
+            # Weak model wraps args.content in prose + a Markdown fence. The
+            # sanitize pass must strip the wrapper BEFORE the tool runs, the
+            # trace must record artifact_sanitize, and the critic PASS then
+            # completes over a transcript whose written payload is clean.
+            replies=[_FILEGEN_PLAN, _DIRTY_WRITE, _FINAL, _PASS],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["write_file"],
+            expect_repairs={"artifact_sanitize": 1},
+            expect_write_contains=["<!DOCTYPE html>", "</html>"],
+            expect_write_excludes=["```", "Sure!", "Hope this helps"],
+        ),
+        Scenario(
+            name="filegen-truncated-write-repaired-critic-pass",
+            # Token-limit truncation: no extractable clean document exists, so
+            # the pipeline's deterministic repair must close the document
+            # (artifact_repair) — the file on disk is still structurally valid.
+            replies=[_FILEGEN_PLAN, _TRUNCATED_WRITE, _FINAL, _PASS],
+            expect_exact={"parse_errors": 0},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["write_file"],
+            expect_repairs={"artifact_repair": 1},
+            expect_write_contains=["<h1>Weekly report</h1>", "</body>", "</html>"],
+            expect_write_excludes=["```"],
+        ),
+        Scenario(
+            name="filegen-dirty-write-unverifiable-needs-review",
+            # The dirty write is sanitized and runs, but the critic never
+            # produces a parseable verdict — fail-closed: the run must end
+            # NEEDS_REVIEW (never a fabricated DONE), while the written file
+            # stays clean because sanitize ran before the tool.
+            replies=[
+                _FILEGEN_PLAN, _DIRTY_WRITE, _FINAL,
+                "the page looks great, approving!",       # unparseable critic
+                "still prose, still not a JSON verdict",  # strict retry fails too
+            ],
+            expect_state="NEEDS_REVIEW",
+            expected_class="needs_review",
+            expect_min={"parse_errors": 2},
+            expect_tool_outcomes={"ok": 1},
+            expect_tool_calls=["write_file"],
+            expect_repairs={"artifact_sanitize": 1},
+            expect_write_excludes=["```", "Sure!"],
+            expect_final_contains=["직접 확인"],
+        ),
     ]
@@ -591,6 +682,22 @@ async def _run_scenario(scenario: Scenario) -> Dict[str, Any]:
     for needle in scenario.expect_final_contains:
         if needle not in ctx.final_message:
             failures.append(f"final_message missing {needle!r}")
+    for repair_name, count in scenario.expect_repairs.items():
+        seen = int((summary.get("repairs") or {}).get(repair_name, 0))
+        if seen != count:
+            failures.append(f"repairs[{repair_name}]={seen} != {count}")
+    # Payloads the file-writing tools actually received (post-sanitize).
+    written = [
+        str((call.get("args") or {}).get("content") or "")
+        for call in tool_log
+        if call["name"] in ("write_file", "generate_file")
+    ]
+    for needle in scenario.expect_write_contains:
+        if not any(needle in payload for payload in written):
+            failures.append(f"written content missing {needle!r}")
+    for needle in scenario.expect_write_excludes:
+        if any(needle in payload for payload in written):
+            failures.append(f"written content must not contain {needle!r}")
     if governor is not None and summary["tool_outcomes"].get("proposed", 0) != len(governor.proposals):
         failures.append(
             f"governor proposals={len(governor.proposals)} != "

package/latticeai/core/enterprise.py CHANGED Viewed

@@ -52,6 +52,11 @@ class EnterpriseCapability(str, Enum):
     DLP_POLICY = "dlp_policy"
     EDISCOVERY = "ediscovery"
     ADMIN_POLICY_PACKS = "admin_policy_packs"
+    # Human review-before-promote governance for knowledge-graph concept
+    # promotions (review 2026-07-25 Wave 4). Community users can opt in per
+    # deployment via LATTICEAI_GRAPH_PROMOTION_REVIEW; this capability is the
+    # seam for Enterprise policy packs that mandate reviewed promotions.
+    GRAPH_PROMOTION_REVIEW = "graph_promotion_review"
 @runtime_checkable

package/latticeai/core/file_generation.py CHANGED Viewed

@@ -25,6 +25,7 @@ The pipeline is pure (no I/O, no FastAPI); the chat layer injects an async
 from __future__ import annotations
+import ast
 import html as html_lib
 import json
 import re
@@ -91,6 +92,8 @@ _EXT_FENCE_LANGS: Dict[str, Tuple[str, ...]] = {
     ".xml": ("xml", "svg"),
     ".csv": ("csv",),
     ".txt": ("txt", "text", "plaintext"),
+    ".vue": ("vue", "html"),
+    ".svelte": ("svelte", "html"),
 }
@@ -181,6 +184,76 @@ def looks_like_refusal(content: str) -> bool:
     return bool(_REFUSAL_RE.search(head)) and len(content) < 600
+# Braced code types validated structurally (balanced delimiters, no fences).
+_BRACED_CODE_EXTENSIONS = frozenset({".js", ".jsx", ".ts", ".tsx"})
+# Single-file components validated by their block tags being closed.
+_COMPONENT_EXTENSIONS = frozenset({".vue", ".svelte"})
+def _strip_code_literals(text: str) -> str:
+    """Remove string literals and comments so delimiter counting stays honest.
+    A cheap single-pass scanner (not a parser): quotes ('', "", ``), line
+    comments (//) and block comments (/* */) commonly contain lone braces
+    that would otherwise false-flag valid JS/TS as unbalanced.
+    """
+    out: List[str] = []
+    i, n = 0, len(text)
+    while i < n:
+        ch = text[i]
+        nxt = text[i + 1] if i + 1 < n else ""
+        if ch == "\\":
+            i += 2  # escaped char (inside or outside a literal — always skip)
+            continue
+        if ch in ("'", '"', "`"):
+            quote = ch
+            i += 1
+            while i < n:
+                if text[i] == "\\":
+                    i += 2
+                    continue
+                if text[i] == quote:
+                    i += 1
+                    break
+                i += 1
+            continue
+        if ch == "/" and nxt == "/":
+            while i < n and text[i] != "\n":
+                i += 1
+            continue
+        if ch == "/" and nxt == "*":
+            end = text.find("*/", i + 2)
+            i = n if end < 0 else end + 2
+            continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+def _check_balanced_delimiters(content: str) -> Tuple[bool, str]:
+    """Lenient count-based balance check for braced code (js/ts family).
+    Only *counts* are compared, never ordering, so valid-but-unusual code is
+    not rejected; a truncated file with a dangling ``{`` still fails.
+    """
+    stripped = _strip_code_literals(content)
+    for opener, closer, label in (("{", "}", "braces"), ("(", ")", "parentheses"), ("[", "]", "brackets")):
+        if stripped.count(opener) != stripped.count(closer):
+            return False, f"unbalanced {label} ({opener}{closer}) — the file looks truncated"
+    return True, "ok"
+def _check_component_blocks(content: str) -> Tuple[bool, str]:
+    """Vue/Svelte SFC sanity: every opened block tag must be closed."""
+    lower = content.lower()
+    for tag in ("template", "script", "style"):
+        opened = len(re.findall(rf"<{tag}(?:\s[^>]*)?>", lower))
+        closed = lower.count(f"</{tag}>")
+        if opened != closed:
+            return False, f"<{tag}> block is not closed — the component looks truncated"
+    return True, "ok"
 def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
     """Structural sanity check per file type. Returns (ok, reason)."""
     if not content.strip():
@@ -211,10 +284,28 @@ def validate_file_content(content: str, target_path: str) -> Tuple[bool, str]:
             return False, f"invalid JSON: {exc}"
         return True, "ok"
     if ext == ".css":
+        if "```" in content:
+            return False, "output still contains Markdown fences"
         if "{" not in content or "}" not in content:
             return False, "no CSS rule blocks found"
         return True, "ok"
-    if ext in (".py", ".js", ".jsx", ".ts", ".tsx", ".sh", ".sql"):
+    if ext == ".py":
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        try:
+            ast.parse(content)
+        except SyntaxError as exc:
+            return False, f"invalid Python syntax: {exc.msg} (line {exc.lineno})"
+        return True, "ok"
+    if ext in _BRACED_CODE_EXTENSIONS:
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return _check_balanced_delimiters(content)
+    if ext in _COMPONENT_EXTENSIONS:
+        if "```" in content:
+            return False, "output still contains Markdown fences"
+        return _check_component_blocks(content)
+    if ext in (".sh", ".sql"):
         if "```" in content:
             return False, "output still contains Markdown fences"
         return True, "ok"
@@ -248,13 +339,48 @@ _TYPE_RULES: Dict[str, str] = {
     ".csv": "Produce CSV with a header row; comma-separated, one record per line.",
     ".py": "Produce complete runnable Python source code.",
     ".js": "Produce complete valid JavaScript source code.",
+    ".jsx": "Produce one complete React component file in JSX.",
+    ".ts": "Produce complete valid TypeScript source code.",
+    ".tsx": "Produce one complete React component file in TSX (TypeScript).",
+    ".vue": "Produce ONE complete Vue single-file component with closed <template>/<script>/<style> blocks.",
+    ".svelte": "Produce ONE complete Svelte component; every <script>/<style> block must be closed.",
 }
+# Multi-file bundles override the standalone-HTML rule: the page must link
+# its sibling files instead of inlining everything.
+_BUNDLE_HTML_RULE = (
+    "Produce ONE complete HTML5 document: <!DOCTYPE html>, <html>, <head> with "
+    "<meta charset=\"utf-8\"> and a <title>, and a closed </html> tag. "
+    "This page is part of a multi-file project: link the project stylesheet(s) "
+    "with <link rel=\"stylesheet\" href=\"...\"> and load the project script(s) "
+    "with <script src=\"...\"></script> just before </body>. Reference ONLY the "
+    "project files listed below — no other external files, no inline <style> "
+    "blocks, no inline behavior scripts."
+)
+# Vite/React bundles need a module entry point, not classic script tags.
+_BUNDLE_HTML_MODULE_RULE = (
+    "Produce ONE complete HTML5 document: <!DOCTYPE html>, <html>, <head> with "
+    "<meta charset=\"utf-8\"> and a <title>, and a closed </html> tag. "
+    "This page is the Vite entry of a React project: the <body> must contain "
+    "<div id=\"root\"></div> and load the app with "
+    "<script type=\"module\" src=\"/src/main.jsx\"></script> just before "
+    "</body>. No inline <style> blocks, no other scripts, no external files."
+)
+def _bundle_html_rule(bundle_files: List[str]) -> str:
+    """Pick the HTML bundle rule that matches the bundle's technology."""
+    if any(str(path).lower().endswith((".jsx", ".tsx")) for path in bundle_files):
+        return _BUNDLE_HTML_MODULE_RULE
+    return _BUNDLE_HTML_RULE
 def build_file_generation_context(
     target_path: str,
     user_request: str,
     feedback: Optional[str] = None,
+    bundle_files: Optional[List[str]] = None,
 ) -> str:
     """Strict, extension-aware generation instructions.
@@ -271,8 +397,13 @@ def build_file_generation_context(
         "no text before or after the content.",
     ]
     type_rule = _TYPE_RULES.get(ext)
+    if bundle_files and ext in (".html", ".htm"):
+        type_rule = _bundle_html_rule(bundle_files)
     if type_rule:
         parts.append(f"- {type_rule}")
+    if bundle_files:
+        listed = ", ".join(bundle_files)
+        parts.append(f"- Project files in this bundle: {listed}")
     first_line = _FIRST_LINE_HINTS.get(ext)
     if first_line:
         parts.append(f"- The very first line of your reply must be: {first_line}")
@@ -309,12 +440,29 @@ def repair_file_content(content: str, target_path: str, user_request: str) -> st
             ensure_ascii=False,
             indent=2,
         )
+    if ext == ".py" and salvage:
+        # The repair guarantee for Python is parseability: unparseable output
+        # is preserved honestly as a commented-out draft, never as a broken
+        # module the user has to debug.
+        try:
+            ast.parse(salvage)
+            return salvage
+        except SyntaxError:
+            commented = "\n".join(f"# {line}" for line in salvage.splitlines())
+            return (
+                f"# TODO: model produced invalid Python for: {user_request}\n"
+                "# The draft below is preserved as comments — fix and uncomment.\n"
+                f"{commented}\n"
+            )
     if salvage:
         return salvage
     # Nothing usable at all — leave an honest placeholder in the right format.
     comment = {
         ".py": "# TODO: model produced no usable content for: ",
         ".js": "// TODO: model produced no usable content for: ",
+        ".jsx": "// TODO: model produced no usable content for: ",
+        ".ts": "// TODO: model produced no usable content for: ",
+        ".tsx": "// TODO: model produced no usable content for: ",
         ".css": "/* TODO: model produced no usable content for: ",
         ".sh": "# TODO: model produced no usable content for: ",
         ".sql": "-- TODO: model produced no usable content for: ",
@@ -371,6 +519,7 @@ def _repair_html(salvage: str, user_request: str) -> str:
 PREVIEWABLE_EXTENSIONS = frozenset({
     ".html", ".htm", ".md", ".markdown", ".txt", ".json", ".css", ".js",
     ".csv", ".py", ".yaml", ".yml", ".xml", ".sql", ".sh",
+    ".jsx", ".ts", ".tsx", ".vue", ".svelte",
 })
@@ -457,6 +606,253 @@ def infer_file_target(message: str) -> Optional[str]:
     return None
+# ── project manifest (multi-file bundles) ───────────────────────────────
+# ``\b`` fails against Korean particles ("js로") because Hangul is ``\w`` —
+# use ASCII lookarounds so type keywords match with or without a particle.
+_HTML_HINT_RE = re.compile(
+    r"(?<![a-z0-9])html(?![a-z0-9])"
+    r"|웹\s*페이지|웹페이지|홈페이지|웹\s*사이트|웹사이트|website|web\s*page|landing\s*page",
+)
+_CSS_HINT_RE = re.compile(r"(?<![a-z0-9])css(?![a-z0-9])|스타일\s*시트|stylesheet")
+_JS_HINT_RE = re.compile(
+    r"(?<![a-z0-9])js(?![a-z0-9])|javascript|자바스크립트|자바\s*스크립트"
+)
+# An explicit filename means the user is managing paths — keep the
+# deterministic single-file flow untouched.
+_EXPLICIT_FILENAME_RE = re.compile(
+    r"[\w-]+\.(?:html?|css|js|jsx|ts|tsx|py|json|md|txt|csv|vue|svelte)\b",
+    re.IGNORECASE,
+)
+_PROJECT_NAME_RE = re.compile(r"([A-Za-z][A-Za-z0-9_-]{1,30})\s*(?:앱|app\b)", re.IGNORECASE)
+# React/Vite intent: the react keyword is specific enough on its own.
+_REACT_HINT_RE = re.compile(r"(?<![a-z0-9])react(?![a-z0-9])|리액트")
+_VITE_HINT_RE = re.compile(r"(?<![a-z0-9])vite(?![a-z0-9])")
+# Python package intent: language + package word, both required.
+_PYTHON_HINT_RE = re.compile(r"(?<![a-z0-9])python(?![a-z0-9])|파이썬")
+_PACKAGE_HINT_RE = re.compile(r"패키지|(?<![a-z0-9])package(?![a-z0-9])")
+_PKG_NAME_RE = re.compile(
+    r"([A-Za-z][A-Za-z0-9_-]{1,30})\s*(?:패키지|package\b)", re.IGNORECASE
+)
+def _react_manifest(text: str) -> Dict[str, Any]:
+    """Vite + React starter manifest (review Wave 4: manifest 확장)."""
+    name_match = _PROJECT_NAME_RE.search(text)
+    name = f"{name_match.group(1).lower()}-app" if name_match else "react-app"
+    return {
+        "name": name,
+        "kind": "react",
+        "files": [
+            {
+                "path": "package.json",
+                "brief": (
+                    f'Vite React app manifest: strictly valid JSON with "name": "{name}", '
+                    '"private": true, "type": "module", "scripts" {"dev": "vite", '
+                    '"build": "vite build", "preview": "vite preview"}, "dependencies" '
+                    'with react and react-dom (^18), and "devDependencies" with vite '
+                    "and @vitejs/plugin-react."
+                ),
+            },
+            {
+                "path": "index.html",
+                "brief": (
+                    "The Vite entry HTML: <div id=\"root\"></div> in <body> and "
+                    "<script type=\"module\" src=\"/src/main.jsx\"></script> just "
+                    "before </body>. No inline styles or scripts."
+                ),
+            },
+            {
+                "path": "src/main.jsx",
+                "brief": (
+                    "React entry: createRoot from react-dom/client rendering <App /> "
+                    "into #root; imports ./App.jsx and ./App.css."
+                ),
+            },
+            {
+                "path": "src/App.jsx",
+                "brief": (
+                    "The main App component implementing the user's request as one "
+                    "self-contained React component (hooks allowed, no extra deps)."
+                ),
+            },
+            {
+                "path": "src/App.css",
+                "brief": "All visual styles for the App component.",
+            },
+        ],
+    }
+def _python_package_manifest(text: str) -> Dict[str, Any]:
+    """Multi-file Python package manifest (review Wave 4: manifest 확장)."""
+    name_match = _PKG_NAME_RE.search(text)
+    raw_name = name_match.group(1).lower() if name_match else "my_package"
+    module = re.sub(r"[^a-z0-9_]", "_", raw_name)
+    if not re.match(r"[a-z_]", module):
+        module = f"pkg_{module}"
+    return {
+        "name": module,
+        "kind": "python",
+        "files": [
+            {
+                "path": f"{module}/__init__.py",
+                "brief": (
+                    f"Package init for {module}: import and re-export the public "
+                    "API from .core with an explicit __all__."
+                ),
+            },
+            {
+                "path": f"{module}/core.py",
+                "brief": (
+                    "Implement the user's request as clean, documented functions/"
+                    "classes with type hints. Standard library only."
+                ),
+            },
+            {
+                "path": f"{module}/cli.py",
+                "brief": (
+                    "argparse CLI wrapping the core API: a main() function and an "
+                    'if __name__ == "__main__": main() guard.'
+                ),
+            },
+            {
+                "path": "README.md",
+                "brief": (
+                    f"Usage documentation for the {module} package: install, import "
+                    "example, and CLI example."
+                ),
+            },
+        ],
+    }
+def infer_project_manifest(message: str) -> Optional[Dict[str, Any]]:
+    """Infer a multi-file project manifest from a creation request.
+    "todo 앱 html+css+js로 만들어줘" should yield real linked files, not one
+    inlined page. Deliberately narrow and deterministic (weak local models
+    never see this decision): requires a creation verb, a recognized project
+    intent (web page + css/js, React/Vite app, or Python package), and no
+    explicit filename. Single-type requests return ``None`` so the existing
+    single-file flow is completely unchanged.
+    """
+    text = (message or "").strip()
+    if not text or not _CREATE_VERB_RE.search(text):
+        return None
+    if _EXPLICIT_FILENAME_RE.search(text):
+        return None
+    lower = text.lower()
+    # Most-specific first: React (its own structure), then Python package,
+    # then the classic html+css/js web bundle.
+    if _REACT_HINT_RE.search(lower) or _VITE_HINT_RE.search(lower):
+        return _react_manifest(text)
+    if _PYTHON_HINT_RE.search(lower) and _PACKAGE_HINT_RE.search(lower):
+        return _python_package_manifest(text)
+    wants_html = bool(_HTML_HINT_RE.search(lower))
+    wants_css = bool(_CSS_HINT_RE.search(lower))
+    wants_js = bool(_JS_HINT_RE.search(lower))
+    if not wants_html or not (wants_css or wants_js):
+        return None
+    name_match = _PROJECT_NAME_RE.search(text)
+    name = f"{name_match.group(1).lower()}-app" if name_match else "web-project"
+    files: List[Dict[str, str]] = []
+    html_refs: List[str] = []
+    if wants_css:
+        html_refs.append('<link rel="stylesheet" href="style.css"> in <head>')
+    if wants_js:
+        html_refs.append('<script src="app.js"></script> just before </body>')
+    files.append({
+        "path": "index.html",
+        "brief": (
+            "The main HTML page of the project. Reference the sibling files: "
+            + " and ".join(html_refs)
+            + ". Do not inline styles or behavior scripts."
+        ),
+    })
+    if wants_css:
+        files.append({
+            "path": "style.css",
+            "brief": "All visual styles for index.html (layout, colors, typography).",
+        })
+    if wants_js:
+        files.append({
+            "path": "app.js",
+            "brief": (
+                "All page behavior for index.html as plain browser JavaScript "
+                "(no build step, no imports of missing files)."
+            ),
+        })
+    return {"name": name, "kind": "web", "files": files}
+_HTML_LOCAL_REF_RE = re.compile(
+    r"(?:href|src)\s*=\s*[\"']([^\"'#?]+)[\"']", re.IGNORECASE
+)
+_EXTERNAL_REF_PREFIXES = ("http://", "https://", "//", "data:", "mailto:", "tel:", "javascript:")
+def _local_bundle_refs(html: str) -> List[str]:
+    """File references inside an HTML document that must exist in the bundle."""
+    refs: List[str] = []
+    for ref in _HTML_LOCAL_REF_RE.findall(html or ""):
+        candidate = ref.strip()
+        if not candidate or candidate.startswith(_EXTERNAL_REF_PREFIXES):
+            continue
+        if "." not in candidate.rsplit("/", 1)[-1]:
+            continue  # anchors / routes, not files
+        refs.append(candidate)
+    return refs
+def repair_bundle_references(files: Dict[str, str]) -> Tuple[Dict[str, str], List[str]]:
+    """Deterministically point dangling HTML refs at real bundle files.
+    A weak model asked for ``style.css`` sometimes links ``styles.css``. When
+    a referenced file is missing but the bundle contains exactly one file of
+    the same extension, the reference is rewritten. Returns ``(files, fixes)``.
+    """
+    names = {p.rsplit("/", 1)[-1] for p in files}
+    fixes: List[str] = []
+    repaired = dict(files)
+    for path, content in files.items():
+        if _ext(path) not in (".html", ".htm"):
+            continue
+        updated = content
+        for ref in _local_bundle_refs(content):
+            base = ref.rsplit("/", 1)[-1]
+            if base in names:
+                continue
+            same_ext = [n for n in names if _ext(n) == _ext(base)]
+            if len(same_ext) == 1:
+                updated = updated.replace(ref, same_ext[0])
+                fixes.append(f"{path}: '{ref}' -> '{same_ext[0]}'")
+        if updated != content:
+            repaired[path] = updated
+    return repaired, fixes
+def validate_project_bundle(files: Dict[str, str]) -> Dict[str, Any]:
+    """Bundle-level verification: every file valid, every HTML ref resolvable."""
+    issues: List[str] = []
+    per_file: Dict[str, Dict[str, Any]] = {}
+    names = {p.rsplit("/", 1)[-1] for p in files}
+    for path, content in files.items():
+        ok, reason = validate_file_content(content, path)
+        per_file[path] = {"valid": ok, "reason": reason}
+        if not ok:
+            issues.append(f"{path}: {reason}")
+        if _ext(path) in (".html", ".htm"):
+            for ref in _local_bundle_refs(content):
+                if ref.rsplit("/", 1)[-1] not in names:
+                    issues.append(f"{path}: references missing file '{ref}'")
+    return {"ok": not issues, "issues": issues, "files": per_file}
 # ── orchestration ───────────────────────────────────────────────────────
 async def generate_file_content(
@@ -465,6 +861,7 @@ async def generate_file_content(
     target_path: str,
     user_request: str,
     max_attempts: int = 2,
+    bundle_files: Optional[List[str]] = None,
 ) -> Tuple[str, Dict[str, Any]]:
     """Generate validated file content with any LLM.
@@ -477,7 +874,9 @@ async def generate_file_content(
     feedback: Optional[str] = None
     last_candidate = ""
     for attempt in range(1, max_attempts + 1):
-        context = build_file_generation_context(target_path, user_request, feedback=feedback)
+        context = build_file_generation_context(
+            target_path, user_request, feedback=feedback, bundle_files=bundle_files,
+        )
         try:
             raw = await generate(context)
         except Exception as exc:  # model backend hiccup — repair still delivers
@@ -502,8 +901,11 @@ __all__ = [
     "extract_file_content",
     "generate_file_content",
     "infer_file_target",
+    "infer_project_manifest",
     "looks_like_refusal",
+    "repair_bundle_references",
     "repair_file_content",
     "sanitize_write_content",
     "validate_file_content",
+    "validate_project_bundle",
 ]

package/latticeai/core/legacy_compatibility.py CHANGED Viewed

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, List
-LEGACY_COMPATIBILITY_VERSION = "9.9.2"
+LEGACY_COMPATIBILITY_VERSION = "9.9.4"
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py CHANGED Viewed

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
-MARKETPLACE_VERSION = "9.9.2"
+MARKETPLACE_VERSION = "9.9.4"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")