Upload 80 files

.gitattributes

@@ -1,3 +1,9 @@
 # Keep shell scripts Unix-safe on Windows checkouts
 *.sh text eol=lf
 scripts/* text eol=lf
+frontend/dist/apple-touch-icon.png filter=lfs diff=lfs merge=lfs -text
+frontend/dist/zuzu-icon-512.png filter=lfs diff=lfs merge=lfs -text
+frontend/dist/zuzu-logo.png filter=lfs diff=lfs merge=lfs -text
+frontend/public/apple-touch-icon.png filter=lfs diff=lfs merge=lfs -text
+frontend/public/zuzu-icon-512.png filter=lfs diff=lfs merge=lfs -text
+frontend/public/zuzu-logo.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -22,7 +22,10 @@ ENV PYTHONDONTWRITEBYTECODE=1 \
     LANGUAGE_TOOL_ENABLED=true \
     LANGUAGE_TOOL_EMBEDDED=true \
     LANGUAGE_TOOL_LANGUAGE=en-US \
-    LANGUAGETOOL_JAVA_OPTS="-Xms256m -Xmx768m"
+    LANGUAGE_TOOL_TIMEOUT=90 \
+    LANGUAGE_TOOL_CHUNK_CHARS=1800 \
+    GRAMMAR_MAX_CHARS=12000 \
+    LANGUAGETOOL_JAVA_OPTS="-Xms256m -Xmx1024m"
 
 WORKDIR /app
 

app/config.py

@@ -45,6 +45,15 @@ SESSION_IDLE_MINUTES = int(os.environ.get("SESSION_IDLE_MINUTES", "30") or "30")
 # Example compose service: http://languagetool:8010  |  local: http://127.0.0.1:8010
 LANGUAGE_TOOL_URL = (os.environ.get("LANGUAGE_TOOL_URL") or "").rstrip("/")
 LANGUAGE_TOOL_LANGUAGE = os.environ.get("LANGUAGE_TOOL_LANGUAGE") or "en-US"
-LANGUAGE_TOOL_TIMEOUT = float(os.environ.get("LANGUAGE_TOOL_TIMEOUT", "30") or "30")
+LANGUAGE_TOOL_TIMEOUT = float(os.environ.get("LANGUAGE_TOOL_TIMEOUT", "90") or "90")
+LANGUAGE_TOOL_CHUNK_CHARS = max(
+    500,
+    min(int(os.environ.get("LANGUAGE_TOOL_CHUNK_CHARS", "1800") or "1800"), 8000),
+)
+# Hard cap for grammar checks (prevents Space OOMs / proxy 500s on huge pastes)
+GRAMMAR_MAX_CHARS = max(
+    1000,
+    min(int(os.environ.get("GRAMMAR_MAX_CHARS", "12000") or "12000"), MAX_CHARS),
+)
 _lt_flag = (os.environ.get("LANGUAGE_TOOL_ENABLED") or "true").strip().lower()
 LANGUAGE_TOOL_ENABLED = _lt_flag not in {"0", "false", "no", "off"} and bool(LANGUAGE_TOOL_URL)

app/main.py

@@ -26,8 +26,15 @@ from app.billing.quota import (
     record_rewrite,
 )
 from app.bootstrap import ensure_resources
-from app.config import APP_TITLE, AUTH_ENABLED, LANGUAGE_TOOL_LANGUAGE, LANGUAGE_TOOL_URL, MAX_CHARS
-from app.pipeline.grammar import check_grammar, languagetool_reachable, normalize_language
+from app.config import (
+    APP_TITLE,
+    AUTH_ENABLED,
+    GRAMMAR_MAX_CHARS,
+    LANGUAGE_TOOL_LANGUAGE,
+    LANGUAGE_TOOL_URL,
+    MAX_CHARS,
+)
+from app.pipeline.grammar import check_grammar, languagetool_reachable, normalize_language, rules_fallback_result
 from app.pipeline.nlp import spacy_available
 from app.pipeline.orchestrator import rewrite_text, similarity_check
 from app.pipeline.tones import normalize_tone
@@ -191,11 +198,14 @@ def api_grammar(body: GrammarRequest):
     if not text:
         logger.info("grammar rejected: empty text")
         raise HTTPException(status_code=400, detail="Paste some text to check.")
-    if len(text) > MAX_CHARS:
-        logger.info("grammar rejected: too long chars=%s", len(text))
+    if len(text) > GRAMMAR_MAX_CHARS:
+        logger.info("grammar rejected: too long chars=%s max=%s", len(text), GRAMMAR_MAX_CHARS)
         raise HTTPException(
             status_code=413,
-            detail=f"Text is too long ({len(text):,} chars). Max is {MAX_CHARS:,}.",
+            detail=(
+                f"Text is too long for grammar check ({len(text):,} chars). "
+                f"Max is {GRAMMAR_MAX_CHARS:,} characters — shorten the draft or split into sections."
+            ),
         )
     try:
         result = check_grammar(text, language=language)
@@ -207,12 +217,18 @@ def api_grammar(body: GrammarRequest):
             result.get("engine"),
         )
         return result
+    except HTTPException:
+        raise
     except Exception:
-        logger.exception("grammar check crashed")
-        raise HTTPException(
-            status_code=500,
-            detail="Grammar check failed on the server. Please try again.",
-        ) from None
+        logger.exception("grammar check crashed — returning safe fallback")
+        try:
+            return rules_fallback_result(text, language)
+        except Exception:
+            logger.exception("grammar fallback also failed")
+            raise HTTPException(
+                status_code=500,
+                detail="Grammar check failed on the server. Try a shorter text and retry.",
+            ) from None
 
 
 def _register_frontend() -> None:

app/pipeline/grammar.py

@@ -9,6 +9,7 @@ from dataclasses import asdict, dataclass
 import httpx
 
 from app.config import (
+    LANGUAGE_TOOL_CHUNK_CHARS,
     LANGUAGE_TOOL_ENABLED,
     LANGUAGE_TOOL_LANGUAGE,
     LANGUAGE_TOOL_TIMEOUT,
@@ -119,37 +120,54 @@ def _check_languagetool_chunk(
     return issues
 
 
-def _iter_chunks(text: str, max_chars: int = 12000) -> list[tuple[int, str]]:
-    """Split long text into overlapping-safe paragraph chunks with absolute offsets."""
-    if len(text) <= max_chars:
+def _iter_chunks(text: str, max_chars: int | None = None) -> list[tuple[int, str]]:
+    """Split text into small chunks by sentence, then hard-split if needed.
+
+    Long single paragraphs (no blank lines) must still be chunked — otherwise
+    LanguageTool OOMs / times out on Spaces.
+    """
+    limit = max_chars if max_chars is not None else LANGUAGE_TOOL_CHUNK_CHARS
+    if len(text) <= limit:
         return [(0, text)]
+
+    # Prefer sentence boundaries, then paragraph breaks
+    pieces: list[tuple[int, str]] = []
+    pattern = re.compile(r".+?(?:[.!?][)\"']*\s+|\n+|$)", re.DOTALL)
+    pos = 0
+    for m in pattern.finditer(text):
+        chunk = m.group(0)
+        if not chunk:
+            continue
+        pieces.append((m.start(), chunk))
+        pos = m.end()
+    if pos < len(text):
+        pieces.append((pos, text[pos:]))
+    if not pieces:
+        pieces = [(0, text)]
+
     chunks: list[tuple[int, str]] = []
-    parts = re.split(r"(?<=\n\n)", text)
     buf = ""
     buf_start = 0
-    pos = 0
-    for part in parts:
-        if not part:
+    for start, part in pieces:
+        # Oversized single sentence → hard split
+        if len(part) > limit:
+            if buf:
+                chunks.append((buf_start, buf))
+                buf = ""
+            for i in range(0, len(part), limit):
+                chunks.append((start + i, part[i : i + limit]))
             continue
-        if buf and len(buf) + len(part) > max_chars:
+        if buf and len(buf) + len(part) > limit:
             chunks.append((buf_start, buf))
             buf = part
-            buf_start = pos
+            buf_start = start
         else:
             if not buf:
-                buf_start = pos
+                buf_start = start
             buf += part
-        pos += len(part)
-        if len(buf) >= max_chars:
-            chunks.append((buf_start, buf))
-            buf = ""
     if buf:
         chunks.append((buf_start, buf))
-    if not chunks:
-        # hard split
-        for i in range(0, len(text), max_chars):
-            chunks.append((i, text[i : i + max_chars]))
-    return chunks
+    return chunks or [(0, text)]
 
 
 def normalize_language(language: str | None) -> str:
@@ -164,20 +182,41 @@ def normalize_language(language: str | None) -> str:
     return f"{parts[0].lower()}-{parts[1].upper()}"
 
 
-def check_languagetool(text: str, language: str | None = None) -> list[GrammarIssue] | None:
-    """Call self-hosted LanguageTool. Returns None if unavailable."""
+def check_languagetool(text: str, language: str | None = None) -> tuple[list[GrammarIssue] | None, str | None]:
+    """Call self-hosted LanguageTool.
+
+    Returns (issues, warning). issues is None if LT is unavailable entirely.
+    """
     if not LANGUAGE_TOOL_ENABLED or not LANGUAGE_TOOL_URL:
-        return None
+        return None, None
     lang = normalize_language(language)
+    chunks = _iter_chunks(text)
+    issues: list[GrammarIssue] = []
+    failures = 0
+    timeout = httpx.Timeout(connect=5.0, read=LANGUAGE_TOOL_TIMEOUT, write=10.0, pool=5.0)
     try:
-        issues: list[GrammarIssue] = []
-        with httpx.Client(timeout=LANGUAGE_TOOL_TIMEOUT) as client:
-            for base, chunk in _iter_chunks(text):
-                issues.extend(_check_languagetool_chunk(client, chunk, base, lang))
-        return issues
+        with httpx.Client(timeout=timeout) as client:
+            for base, chunk in chunks:
+                try:
+                    issues.extend(_check_languagetool_chunk(client, chunk, base, lang))
+                except Exception as exc:  # noqa: BLE001
+                    failures += 1
+                    logger.warning(
+                        "LanguageTool chunk failed (offset=%s len=%s): %s",
+                        base,
+                        len(chunk),
+                        exc,
+                    )
     except Exception as exc:  # noqa: BLE001
-        logger.warning("LanguageTool request failed: %s", exc)
-        return None
+        logger.warning("LanguageTool client failed: %s", exc)
+        return None, str(exc)
+
+    if not issues and failures == len(chunks):
+        return None, f"All {failures} LanguageTool chunk(s) failed"
+    warning = None
+    if failures:
+        warning = f"{failures} of {len(chunks)} chunk(s) failed; showing partial results."
+    return issues, warning
 
 
 def check_rules(text: str) -> list[GrammarIssue]:
@@ -325,15 +364,18 @@ def check_grammar(text: str, language: str | None = None) -> dict:
             "note": "Paste some text to check.",
         }
 
-    lt_issues = check_languagetool(text, lang)
+    lt_issues, lt_warning = check_languagetool(text, lang)
     if lt_issues is not None:
         filtered = _dedupe(lt_issues)
+        note = f"Self-hosted LanguageTool ({lang}) — full sentence grammar & spelling."
+        if lt_warning:
+            note = f"{note} {lt_warning}"
         return {
             "issues": [asdict(i) for i in filtered],
             "input_words": _word_count(text),
             "engine": "languagetool",
             "language": lang,
-            "note": f"Self-hosted LanguageTool ({lang}) — full sentence grammar & spelling.",
+            "note": note,
         }
 
     # Fallback when LT is down / not configured
@@ -345,6 +387,8 @@ def check_grammar(text: str, language: str | None = None) -> dict:
         else "LanguageTool is not configured — using basic local rules only. "
         "Set LANGUAGE_TOOL_URL and start the self-hosted server."
     )
+    if lt_warning:
+        note = f"{note} ({lt_warning})"
     return {
         "issues": [asdict(i) for i in filtered],
         "input_words": _word_count(text),
@@ -352,3 +396,22 @@ def check_grammar(text: str, language: str | None = None) -> dict:
         "language": lang,
         "note": note,
     }
+
+
+def rules_fallback_result(text: str, language: str | None = None, extra_note: str = "") -> dict:
+    """Safe local-rules payload when LT or the main checker fails hard."""
+    lang = normalize_language(language)
+    filtered = _dedupe(check_rules(text or ""))
+    note = (
+        "Grammar engine hit an error on this text — showing basic local rules only. "
+        "Try a shorter section, or wait and retry."
+    )
+    if extra_note:
+        note = f"{note} {extra_note}"
+    return {
+        "issues": [asdict(i) for i in filtered],
+        "input_words": _word_count(text or ""),
+        "engine": "rules",
+        "language": lang,
+        "note": note,
+    }

frontend/dist/assets/index.css

@@ -318,6 +318,33 @@ textarea {
   line-height: 1.45;
 }
 
+.engine-badge {
+  display: inline-flex;
+  align-self: flex-start;
+  margin-top: 0.35rem;
+  font-size: 0.72rem;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  padding: 0.25rem 0.55rem;
+  border-radius: 999px;
+  border: 1px solid var(--panel-edge);
+  background: rgba(255, 255, 255, 0.75);
+  color: var(--ink-soft);
+}
+
+.engine-badge.engine-languagetool {
+  border-color: rgba(15, 122, 95, 0.35);
+  background: rgba(15, 122, 95, 0.1);
+  color: var(--accent);
+}
+
+.engine-badge.engine-rules {
+  border-color: rgba(226, 90, 60, 0.35);
+  background: rgba(226, 90, 60, 0.1);
+  color: var(--coral);
+}
+
 .grammar-lang {
   flex-wrap: wrap;
 }

frontend/dist/assets/index.js

@@ -15,6 +15,7 @@ const TONES = ["Neutral", "Casual", "Formal", "Academic"];
 const STRENGTHS = ["Light", "Normal", "Heavy"];
 const STRENGTH_MAP = { Light: 0, Normal: 1, Heavy: 2 };
 const MAX_CHARS = 50000;
+const GRAMMAR_MAX_CHARS = 12000;
 const LOGO_SRC = "/zuzu-logo.png";
 
 function BrandLogo({ size = 44, className = "" }) {
@@ -623,6 +624,7 @@ function App() {
   const [grammarLanguage, setGrammarLanguage] = useState("en-US");
   const [grammarIssues, setGrammarIssues] = useState([]);
   const [grammarNote, setGrammarNote] = useState("");
+  const [grammarEngine, setGrammarEngine] = useState("");
   const [grammarLoading, setGrammarLoading] = useState(false);
   const [grammarError, setGrammarError] = useState("");
   const [grammarMeta, setGrammarMeta] = useState("");
@@ -671,10 +673,14 @@ function App() {
   async function onGrammarCheck() {
     const text = grammarText.trim();
     if (!text) { setGrammarError("Paste some text first — or try the sample."); return; }
-    if (text.length > MAX_CHARS) { setGrammarError(`Text is too long (${text.length.toLocaleString()} chars).`); return; }
+    if (text.length > GRAMMAR_MAX_CHARS) {
+      setGrammarError(`Text is too long for grammar check (${text.length.toLocaleString()} chars). Max is ${GRAMMAR_MAX_CHARS.toLocaleString()} — shorten or split into sections.`);
+      return;
+    }
     setGrammarLoading(true);
     setGrammarError("");
     setGrammarMeta("Checking…");
+    setGrammarEngine("");
     try {
       const result = await checkGrammar(text, {
         language: grammarLanguage,
@@ -682,12 +688,14 @@ function App() {
       });
       setGrammarIssues(result.issues || []);
       setGrammarNote(result.note || "");
+      setGrammarEngine(result.engine || "");
       const n = (result.issues || []).length;
       const lang = result.language || grammarLanguage;
       setGrammarMeta(n ? `${n} issue${n === 1 ? "" : "s"} · ${result.input_words} words · ${lang}` : `No issues found · ${result.input_words} words · ${lang}`);
     } catch (err) {
       setGrammarError(err instanceof Error ? err.message : "Grammar check failed.");
       setGrammarMeta("");
+      setGrammarEngine("");
       setGrammarIssues([]);
     } finally {
       setGrammarLoading(false);
@@ -863,11 +871,17 @@ function App() {
               h("p", { className: "grammar-lead" },
                 "Self-hosted LanguageTool checks full sentence grammar for ",
                 h("strong", null, (GRAMMAR_LANGUAGES.find((l) => l.id === grammarLanguage) || {}).label || grammarLanguage),
-                ". If LanguageTool is offline, basic local rules are used instead.",
+                ". Long text is checked in small chunks. If LanguageTool is offline, basic local rules are used instead.",
               ),
+              grammarEngine
+                ? h("span", {
+                    className: `engine-badge engine-${grammarEngine}`,
+                    title: grammarNote || undefined,
+                  }, `Engine: ${grammarEngine === "languagetool" ? "LanguageTool" : grammarEngine === "rules" ? "Local rules" : grammarEngine}`)
+                : null,
             ),
             h("div", { className: "toolbar-actions" },
-              h("button", { type: "button", className: "btn btn-quiet", disabled: grammarLoading, onClick: () => { setGrammarText(""); setGrammarIssues([]); setGrammarMeta(""); setGrammarError(""); setGrammarNote(""); } }, "Clear"),
+              h("button", { type: "button", className: "btn btn-quiet", disabled: grammarLoading, onClick: () => { setGrammarText(""); setGrammarIssues([]); setGrammarMeta(""); setGrammarError(""); setGrammarNote(""); setGrammarEngine(""); } }, "Clear"),
               h("button", { type: "button", className: "btn btn-quiet", disabled: grammarLoading, onClick: () => { setGrammarText(GRAMMAR_SAMPLE); setGrammarIssues([]); setGrammarError(""); setGrammarMeta("Sample loaded — hit Check grammar."); setGrammarNote(""); } }, "Try sample"),
               grammarIssues.length ? h("button", { type: "button", className: "btn btn-quiet", disabled: grammarLoading, onClick: onApplyAllGrammar }, "Apply all") : null,
               h("button", { type: "button", className: "btn btn-primary btn-rewrite", disabled: grammarLoading, onClick: () => onGrammarCheck() }, grammarLoading ? "Checking…" : "Check grammar"),

frontend/src/App.tsx

@@ -18,6 +18,7 @@ import type { PlanCard } from "./supabase";
 const LOGO_SRC = "/zuzu-logo.png";
 const LOGO_FALLBACK = "/favicon.svg";
 const MAX_CHARS = 50000;
+const GRAMMAR_MAX_CHARS = 12000;
 
 type ProductId = "writer" | "grammar";
 
@@ -621,6 +622,7 @@ export default function App() {
   const [grammarLanguage, setGrammarLanguage] = useState("en-US");
   const [grammarIssues, setGrammarIssues] = useState<GrammarIssue[]>([]);
   const [grammarNote, setGrammarNote] = useState("");
+  const [grammarEngine, setGrammarEngine] = useState("");
   const [grammarLoading, setGrammarLoading] = useState(false);
   const [grammarError, setGrammarError] = useState("");
   const [grammarMeta, setGrammarMeta] = useState("");
@@ -694,13 +696,16 @@ export default function App() {
       setGrammarError("Paste some text first — or try the sample.");
       return;
     }
-    if (text.length > MAX_CHARS) {
-      setGrammarError(`Text is too long (${text.length.toLocaleString()} chars).`);
+    if (text.length > GRAMMAR_MAX_CHARS) {
+      setGrammarError(
+        `Text is too long for grammar check (${text.length.toLocaleString()} chars). Max is ${GRAMMAR_MAX_CHARS.toLocaleString()} — shorten or split into sections.`,
+      );
       return;
     }
     setGrammarLoading(true);
     setGrammarError("");
     setGrammarMeta("Checking…");
+    setGrammarEngine("");
     try {
       const result = await checkGrammar(text, {
         language: grammarLanguage,
@@ -708,6 +713,7 @@ export default function App() {
       });
       setGrammarIssues(result.issues);
       setGrammarNote(result.note ?? "");
+      setGrammarEngine(result.engine || "");
       setGrammarMeta(
         result.issues.length
           ? `${result.issues.length} issue${result.issues.length === 1 ? "" : "s"} · ${result.input_words} words · ${result.language ?? grammarLanguage}`
@@ -717,6 +723,7 @@ export default function App() {
       const apiErr = err as ApiError;
       setGrammarError(apiErr.message || "Grammar check failed.");
       setGrammarMeta("");
+      setGrammarEngine("");
       setGrammarIssues([]);
     } finally {
       setGrammarLoading(false);
@@ -967,8 +974,16 @@ export default function App() {
               <p className="grammar-lead">
                 Self-hosted LanguageTool checks full sentence grammar for{" "}
                 <strong>{GRAMMAR_LANGUAGES.find((l) => l.id === grammarLanguage)?.label ?? grammarLanguage}</strong>
-                . If LanguageTool is offline, basic local rules are used instead.
+                . Long text is checked in small chunks. If LanguageTool is offline, basic local rules are used instead.
               </p>
+              {grammarEngine ? (
+                <span
+                  className={`engine-badge engine-${grammarEngine}`}
+                  title={grammarNote || undefined}
+                >
+                  Engine: {grammarEngine === "languagetool" ? "LanguageTool" : grammarEngine === "rules" ? "Local rules" : grammarEngine}
+                </span>
+              ) : null}
             </div>
             <div className="toolbar-actions">
               <button
@@ -980,6 +995,7 @@ export default function App() {
                   setGrammarMeta("");
                   setGrammarError("");
                   setGrammarNote("");
+                  setGrammarEngine("");
                 }}
                 disabled={grammarLoading}
               >

frontend/src/index.css

@@ -318,6 +318,33 @@ textarea {
   line-height: 1.45;
 }
 
+.engine-badge {
+  display: inline-flex;
+  align-self: flex-start;
+  margin-top: 0.35rem;
+  font-size: 0.72rem;
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  padding: 0.25rem 0.55rem;
+  border-radius: 999px;
+  border: 1px solid var(--panel-edge);
+  background: rgba(255, 255, 255, 0.75);
+  color: var(--ink-soft);
+}
+
+.engine-badge.engine-languagetool {
+  border-color: rgba(15, 122, 95, 0.35);
+  background: rgba(15, 122, 95, 0.1);
+  color: var(--accent);
+}
+
+.engine-badge.engine-rules {
+  border-color: rgba(226, 90, 60, 0.35);
+  background: rgba(226, 90, 60, 0.1);
+  color: var(--coral);
+}
+
 .grammar-lang {
   flex-wrap: wrap;
 }

scripts/start.sh

@@ -1,47 +1,52 @@
-#!/usr/bin/env bash
-# Start self-hosted LanguageTool (optional) then the ZuZu API.
-set -euo pipefail
-
-LT_HOME="${LANGUAGETOOL_HOME:-/opt/languagetool}"
-LT_PORT="${LANGUAGETOOL_PORT:-8010}"
-LT_JAVA_OPTS="${LANGUAGETOOL_JAVA_OPTS:--Xms256m -Xmx768m}"
-
-start_languagetool() {
-  if [[ "${LANGUAGE_TOOL_EMBEDDED:-true}" != "true" ]]; then
-    echo "[zuzu] Embedded LanguageTool disabled (LANGUAGE_TOOL_EMBEDDED=${LANGUAGE_TOOL_EMBEDDED:-})"
-    return 0
-  fi
-  if [[ ! -f "${LT_HOME}/languagetool-server.jar" ]]; then
-    echo "[zuzu] LanguageTool jar not found at ${LT_HOME}; grammar will use local rules only"
-    return 0
-  fi
-
-  echo "[zuzu] Starting LanguageTool on :${LT_PORT} …"
-  # shellcheck disable=SC2086
-  java ${LT_JAVA_OPTS} -cp "${LT_HOME}/languagetool-server.jar" \
-    org.languagetool.server.HTTPServer \
-    --port "${LT_PORT}" \
-    --public \
-    --allow-origin "*" \
-    >/tmp/languagetool.log 2>&1 &
-  echo $! >/tmp/languagetool.pid
-
-  export LANGUAGE_TOOL_URL="${LANGUAGE_TOOL_URL:-http://127.0.0.1:${LT_PORT}}"
-  export LANGUAGE_TOOL_ENABLED="${LANGUAGE_TOOL_ENABLED:-true}"
-
-  for i in $(seq 1 90); do
-    if curl -fsS "http://127.0.0.1:${LT_PORT}/v2/languages" >/dev/null 2>&1; then
-      echo "[zuzu] LanguageTool ready (attempt ${i})"
-      return 0
-    fi
-    sleep 2
-  done
-  echo "[zuzu] WARNING: LanguageTool did not become ready; see /tmp/languagetool.log"
-  echo "[zuzu] Grammar will fall back to local rules until LT is up"
-}
-
-start_languagetool
-
-HOST="${HOST:-0.0.0.0}"
-PORT="${PORT:-7860}"
-exec uvicorn app.main:app --host "${HOST}" --port "${PORT}"
+#!/usr/bin/env bash
+# Start self-hosted LanguageTool (optional) then the ZuZu API.
+set -euo pipefail
+
+LT_HOME="${LANGUAGETOOL_HOME:-/opt/languagetool}"
+LT_PORT="${LANGUAGETOOL_PORT:-8010}"
+LT_JAVA_OPTS="${LANGUAGETOOL_JAVA_OPTS:--Xms256m -Xmx1024m}"
+
+start_languagetool() {
+  if [[ "${LANGUAGE_TOOL_EMBEDDED:-true}" != "true" ]]; then
+    echo "[zuzu] Embedded LanguageTool disabled (LANGUAGE_TOOL_EMBEDDED=${LANGUAGE_TOOL_EMBEDDED:-})"
+    return 0
+  fi
+  if [[ ! -f "${LT_HOME}/languagetool-server.jar" ]]; then
+    echo "[zuzu] LanguageTool jar not found at ${LT_HOME}; grammar will use local rules only"
+    return 0
+  fi
+
+  echo "[zuzu] Starting LanguageTool on :${LT_PORT} ..."
+  # shellcheck disable=SC2086
+  java ${LT_JAVA_OPTS} -cp "${LT_HOME}/languagetool-server.jar" \
+    org.languagetool.server.HTTPServer \
+    --port "${LT_PORT}" \
+    --public \
+    --allow-origin "*" \
+    >/tmp/languagetool.log 2>&1 &
+  echo $! >/tmp/languagetool.pid
+
+  export LANGUAGE_TOOL_URL="${LANGUAGE_TOOL_URL:-http://127.0.0.1:${LT_PORT}}"
+  export LANGUAGE_TOOL_ENABLED="${LANGUAGE_TOOL_ENABLED:-true}"
+
+  for i in $(seq 1 90); do
+    if curl -fsS "http://127.0.0.1:${LT_PORT}/v2/languages" >/dev/null 2>&1; then
+      echo "[zuzu] LanguageTool HTTP up (attempt ${i}) — prewarming check..."
+      curl -fsS -X POST "http://127.0.0.1:${LT_PORT}/v2/check" \
+        --data-urlencode "language=en-US" \
+        --data-urlencode "text=She go to the store yesterday." \
+        >/dev/null 2>&1 || true
+      echo "[zuzu] LanguageTool ready"
+      return 0
+    fi
+    sleep 2
+  done
+  echo "[zuzu] WARNING: LanguageTool did not become ready; see /tmp/languagetool.log"
+  echo "[zuzu] Grammar will fall back to local rules until LT is up"
+}
+
+start_languagetool
+
+HOST="${HOST:-0.0.0.0}"
+PORT="${PORT:-7860}"
+exec uvicorn app.main:app --host "${HOST}" --port "${PORT}"