@cloudgrid-io/mcp 0.13.0 → 0.15.0

package/src/corpus/templates/semantic-search/services/web/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "semantic-search-web",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.3.1",
+    "vite": "^5.4.0"
+  }
+}

package/src/corpus/templates/semantic-search/services/web/src/App.jsx

@@ -0,0 +1,55 @@
+import React, { useEffect, useState } from "react";
+import * as api from "./api.js";
+import SearchView from "./components/SearchView.jsx";
+import ManagerLogin from "./components/ManagerLogin.jsx";
+import Settings from "./components/Settings.jsx";
+import Dashboard from "./components/Dashboard.jsx";
+
+export default function App() {
+  const [view, setView] = useState("search");
+  const [status, setStatus] = useState(null);
+  const [loggedIn, setLoggedIn] = useState(api.isLoggedIn());
+
+  useEffect(() => {
+    api.getStatus().then(setStatus).catch(() => setStatus({ mongo: false }));
+  }, []);
+
+  function logout() {
+    api.setToken(null);
+    setLoggedIn(false);
+    setView("search");
+  }
+
+  return (
+    <div className="container">
+      <header className="site">
+        <h1>Document Search</h1>
+        <p>Search across your documents — by word, by meaning, and by date or collection</p>
+        <nav className="top">
+          <a onClick={() => setView("search")}>Search</a>
+          {loggedIn ? (
+            <>
+              <a onClick={() => setView("settings")}>Settings</a>
+              <a onClick={() => setView("dashboard")}>Dashboard</a>
+              <a onClick={logout}>Sign out</a>
+            </>
+          ) : (
+            <a onClick={() => setView("login")}>Manager sign-in</a>
+          )}
+        </nav>
+      </header>
+
+      {view === "search" && <SearchView status={status} />}
+      {view === "login" && (
+        <ManagerLogin
+          onLoggedIn={() => {
+            setLoggedIn(true);
+            setView("settings");
+          }}
+        />
+      )}
+      {view === "settings" && loggedIn && <Settings />}
+      {view === "dashboard" && loggedIn && <Dashboard />}
+    </div>
+  );
+}

package/src/corpus/templates/semantic-search/services/web/src/api.js

@@ -0,0 +1,125 @@
+// Backend base URL baked in at build time. The backend is mounted at /backend on
+// the same entity, so same-origin "" works in production. Override with
+// VITE_BACKEND_URL for split-origin local dev.
+const BASE = import.meta.env.VITE_BACKEND_URL || "";
+
+function url(path) {
+  return `${BASE}${path}`;
+}
+
+let token = localStorage.getItem("mgr_token") || null;
+export function setToken(t) {
+  token = t;
+  if (t) localStorage.setItem("mgr_token", t);
+  else localStorage.removeItem("mgr_token");
+}
+export function isLoggedIn() {
+  return !!token;
+}
+function authHeaders() {
+  return token ? { Authorization: `Bearer ${token}` } : {};
+}
+
+export async function getStatus() {
+  const r = await fetch(url("/backend/status"));
+  return r.json();
+}
+
+export async function search(params) {
+  const qs = new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v !== "" && v != null)
+  );
+  const r = await fetch(url(`/backend/search?${qs}`));
+  return r.json();
+}
+
+export async function count(params) {
+  const qs = new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v !== "" && v != null)
+  );
+  const r = await fetch(url(`/backend/count?${qs}`));
+  return r.json();
+}
+
+export async function listCollections() {
+  const r = await fetch(url("/backend/collections"));
+  return r.json();
+}
+
+export async function answer(question) {
+  const r = await fetch(url("/backend/answer"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ question }),
+  });
+  return r.json();
+}
+
+export function downloadUrl(documentId) {
+  return url(`/backend/documents/${documentId}/download`);
+}
+
+// ── manager ──
+export async function login(password) {
+  const r = await fetch(url("/backend/admin/login"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ password }),
+  });
+  if (!r.ok) throw new Error((await r.json()).detail || "Login failed");
+  const data = await r.json();
+  setToken(data.token);
+  return data;
+}
+
+export async function getSettings() {
+  const r = await fetch(url("/backend/admin/settings"), { headers: authHeaders() });
+  if (!r.ok) throw new Error("Not authorized");
+  return r.json();
+}
+
+export async function updateSettings(body) {
+  const r = await fetch(url("/backend/admin/settings"), {
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...authHeaders() },
+    body: JSON.stringify(body),
+  });
+  return r.json();
+}
+
+export async function updateSynonyms(map) {
+  const r = await fetch(url("/backend/admin/synonyms"), {
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...authHeaders() },
+    body: JSON.stringify({ map }),
+  });
+  return r.json();
+}
+
+export async function changePassword(current, nw) {
+  const r = await fetch(url("/backend/admin/password"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...authHeaders() },
+    body: JSON.stringify({ current, new: nw }),
+  });
+  return r.json();
+}
+
+export async function indexReport() {
+  const r = await fetch(url("/backend/admin/index-report"), { headers: authHeaders() });
+  return r.json();
+}
+
+export async function refreshNow() {
+  const r = await fetch(url("/backend/admin/refresh"), {
+    method: "POST",
+    headers: authHeaders(),
+  });
+  return r.json();
+}
+
+export async function usage() {
+  const r = await fetch(url("/backend/admin/usage"), { headers: authHeaders() });
+  if (!r.ok) throw new Error("Not authorized");
+  return r.json();
+}

package/src/corpus/templates/semantic-search/services/web/src/components/Dashboard.jsx

@@ -0,0 +1,61 @@
+import React, { useEffect, useState } from "react";
+import * as api from "../api.js";
+
+export default function Dashboard() {
+  const [u, setU] = useState(null);
+  const [err, setErr] = useState(null);
+
+  useEffect(() => {
+    api.usage().then(setU).catch((e) => setErr(e.message));
+  }, []);
+
+  if (err) return <div className="card note">{err}</div>;
+  if (!u) return <div className="card">Loading…</div>;
+
+  return (
+    <div>
+      <div className="card">
+        <h3>Usage overview</h3>
+        <div className="stat-grid">
+          <div className="stat"><div className="num">{u.total_searches}</div><div className="lbl">Searches</div></div>
+          <div className="stat"><div className="num">{u.unique_users}</div><div className="lbl">Unique users</div></div>
+          <div className="stat"><div className="num">{u.indexed_documents}</div><div className="lbl">Indexed documents</div></div>
+        </div>
+        <p className="note">Last refresh: {u.last_refresh || "never"}</p>
+      </div>
+
+      <div className="card">
+        <h3>Searches by mode</h3>
+        <table className="usage">
+          <tbody>
+            {Object.entries(u.by_mode || {}).map(([mode, n]) => (
+              <tr key={mode}><td>{mode}</td><td>{n}</td></tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      <div className="card">
+        <h3>Top queries</h3>
+        <table className="usage">
+          <tbody>
+            {(u.top_queries || []).map((q, i) => (
+              <tr key={i}><td>{q.query}</td><td>{q.count}</td></tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+
+      <div className="card">
+        <h3>Zero-result queries</h3>
+        <table className="usage">
+          <tbody>
+            {(u.zero_result_queries || []).map((q, i) => (
+              <tr key={i}><td>{q.query}</td><td>{q.count}</td></tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  );
+}

package/src/corpus/templates/semantic-search/services/web/src/components/ManagerLogin.jsx

@@ -0,0 +1,39 @@
+import React, { useState } from "react";
+import * as api from "../api.js";
+
+export default function ManagerLogin({ onLoggedIn }) {
+  const [password, setPassword] = useState("");
+  const [err, setErr] = useState(null);
+  const [busy, setBusy] = useState(false);
+
+  async function submit(e) {
+    e.preventDefault();
+    setBusy(true);
+    setErr(null);
+    try {
+      await api.login(password);
+      onLoggedIn();
+    } catch (ex) {
+      setErr(ex.message);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <form className="card" onSubmit={submit}>
+      <h3>Manager sign-in</h3>
+      <label className="field">Password</label>
+      <input
+        className="text-input"
+        type="password"
+        value={password}
+        onChange={(e) => setPassword(e.target.value)}
+      />
+      {err && <p className="note" style={{ color: "#b00" }}>{err}</p>}
+      <div style={{ marginTop: 12 }}>
+        <button disabled={busy}>{busy ? "Signing in…" : "Sign in"}</button>
+      </div>
+    </form>
+  );
+}

package/src/corpus/templates/semantic-search/services/web/src/components/SearchView.jsx

@@ -0,0 +1,166 @@
+import React, { useEffect, useState } from "react";
+import * as api from "../api.js";
+
+const MODES = [
+  { id: "hybrid", label: "Hybrid" },
+  { id: "lexical", label: "Exact / keyword" },
+  { id: "semantic", label: "Semantic" },
+  { id: "metadata", label: "By date / collection" },
+];
+
+// Render «...» highlight markers from the backend as <mark>.
+function Passage({ text }) {
+  if (!text) return null;
+  const parts = text.split(/(«[^»]*»)/g);
+  return (
+    <div className="passage">
+      {parts.map((p, i) =>
+        p.startsWith("«") && p.endsWith("»") ? (
+          <mark key={i}>{p.slice(1, -1)}</mark>
+        ) : (
+          <span key={i}>{p}</span>
+        )
+      )}
+    </div>
+  );
+}
+
+export default function SearchView({ status }) {
+  const [q, setQ] = useState("");
+  const [mode, setMode] = useState("hybrid");
+  const [collection, setCollection] = useState("");
+  const [dateFrom, setDateFrom] = useState("");
+  const [dateTo, setDateTo] = useState("");
+  const [collectionList, setCollectionList] = useState([]);
+  const [res, setRes] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [answerMode, setAnswerMode] = useState(false);
+  const [answerRes, setAnswerRes] = useState(null);
+
+  useEffect(() => {
+    api.listCollections().then((d) => setCollectionList(d.collections || [])).catch(() => {});
+  }, []);
+
+  async function runSearch(e) {
+    e && e.preventDefault();
+    setLoading(true);
+    setAnswerRes(null);
+    try {
+      if (answerMode && q.trim()) {
+        setAnswerRes(await api.answer(q));
+      }
+      const params = { q, mode, collection, date_from: dateFrom, date_to: dateTo };
+      setRes(await api.search(params));
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  const notIndexed = status && status.indexed_documents === 0;
+  const answerEnabled = status && status.answer_mode_enabled;
+
+  return (
+    <div>
+      {status && !status.mongo && (
+        <div className="banner">The service is not connected to the database right now.</div>
+      )}
+      {notIndexed && status.mongo && (
+        <div className="banner">
+          The catalog is not indexed yet
+          {!status.source_configured &&
+            ` (source "${status.source_type}" is not configured)`}
+          {status.source_configured && !status.embeddings_configured &&
+            " — semantic search will be available once the embeddings key is set"}
+          .
+        </div>
+      )}
+
+      <form className="card" onSubmit={runSearch}>
+        <div className="searchbar">
+          <input
+            type="text"
+            placeholder="Search a word, phrase, or idea…"
+            value={q}
+            onChange={(e) => setQ(e.target.value)}
+          />
+          <button type="submit" disabled={loading}>
+            {loading ? "Searching…" : "Search"}
+          </button>
+        </div>
+
+        <div className="modes">
+          {MODES.map((m) => (
+            <span
+              key={m.id}
+              className={`chip ${mode === m.id ? "active" : ""}`}
+              onClick={() => setMode(m.id)}
+            >
+              {m.label}
+            </span>
+          ))}
+        </div>
+
+        <div className="filters">
+          <select value={collection} onChange={(e) => setCollection(e.target.value)}>
+            <option value="">All collections</option>
+            {collectionList.map((c) => (
+              <option key={c} value={c}>{c}</option>
+            ))}
+          </select>
+          <input type="date" value={dateFrom} onChange={(e) => setDateFrom(e.target.value)} />
+          <input type="date" value={dateTo} onChange={(e) => setDateTo(e.target.value)} />
+        </div>
+
+        {answerEnabled && (
+          <div className="toggle" style={{ marginTop: 12 }}>
+            <input
+              id="answerMode"
+              type="checkbox"
+              checked={answerMode}
+              onChange={(e) => setAnswerMode(e.target.checked)}
+            />
+            <label htmlFor="answerMode">Grounded answer mode</label>
+          </div>
+        )}
+      </form>
+
+      {answerRes && (
+        <div className="card">
+          <h3>Grounded answer</h3>
+          {answerRes.answer ? (
+            <>
+              <div className="answer-box">{answerRes.answer}</div>
+              <div className="citations">
+                Sources: {answerRes.citations.map((c) => c.title).join(" · ")}
+              </div>
+            </>
+          ) : (
+            <p className="note">{answerRes.note}</p>
+          )}
+        </div>
+      )}
+
+      {res && (
+        <div className="card">
+          <div className="note" style={{ marginBottom: 10 }}>
+            {res.total_matching_documents} matching documents
+            {res.note ? ` — ${res.note}` : ""}
+          </div>
+          {res.results.length === 0 && <p className="note">No results found.</p>}
+          {res.results.map((r) => (
+            <div className="result" key={r.document_id}>
+              <h3>{r.title}</h3>
+              <div className="meta">
+                {r.collection && <span>Collection: {r.collection} · </span>}
+                {r.date && <span>{r.date} · </span>}
+                {r.has_media && <span>🎧 media · </span>}
+                <a href={api.downloadUrl(r.document_id)}>Download text</a>
+              </div>
+              <Passage text={r.best_passage} />
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

package/src/corpus/templates/semantic-search/services/web/src/components/Settings.jsx

@@ -0,0 +1,148 @@
+import React, { useEffect, useState } from "react";
+import * as api from "../api.js";
+
+export default function Settings() {
+  const [settings, setSettings] = useState(null);
+  const [synonymsText, setSynonymsText] = useState("");
+  const [report, setReport] = useState(null);
+  const [msg, setMsg] = useState(null);
+  const [refreshing, setRefreshing] = useState(false);
+  const [pw, setPw] = useState({ current: "", nw: "" });
+  const [pwResult, setPwResult] = useState(null);
+
+  async function load() {
+    const s = await api.getSettings();
+    setSettings(s);
+    setSynonymsText(
+      Object.entries(s.synonyms || {})
+        .map(([k, v]) => `${k}: ${v.join(", ")}`)
+        .join("\n")
+    );
+    setReport(await api.indexReport());
+  }
+  useEffect(() => {
+    load().catch((e) => setMsg(e.message));
+  }, []);
+
+  async function saveFeatures() {
+    await api.updateSettings({ answer_mode_enabled: settings.answer_mode_enabled });
+    setMsg("Settings saved");
+  }
+
+  async function saveSynonyms() {
+    const map = {};
+    synonymsText.split("\n").forEach((line) => {
+      const [k, rest] = line.split(":");
+      if (k && rest) map[k.trim()] = rest.split(",").map((x) => x.trim()).filter(Boolean);
+    });
+    await api.updateSynonyms(map);
+    setMsg("Synonyms saved");
+  }
+
+  async function doRefresh() {
+    setRefreshing(true);
+    try {
+      await api.refreshNow();
+      setReport(await api.indexReport());
+      setMsg("Sync complete");
+    } finally {
+      setRefreshing(false);
+    }
+  }
+
+  async function doChangePassword() {
+    const r = await api.changePassword(pw.current, pw.nw);
+    setPwResult(r);
+  }
+
+  if (!settings) return <div className="card">{msg || "Loading…"}</div>;
+
+  return (
+    <div>
+      {msg && <div className="banner">{msg}</div>}
+
+      <div className="card">
+        <h3>Index</h3>
+        <p className="note">
+          Re-index new and changed documents from the configured source. This is
+          the supported refresh path today. A scheduled (cron) refresh is a
+          follow-up, blocked on a platform issue — see AGENTS.md.
+        </p>
+        <button onClick={doRefresh} disabled={refreshing}>
+          {refreshing ? "Syncing…" : "Refresh now"}
+        </button>
+        <p className="note">Last refresh: {settings.last_refresh || "never"}</p>
+      </div>
+
+      <div className="card">
+        <h3>Answer mode</h3>
+        <div className="toggle">
+          <input
+            id="am"
+            type="checkbox"
+            checked={settings.answer_mode_enabled}
+            onChange={(e) => setSettings({ ...settings, answer_mode_enabled: e.target.checked })}
+          />
+          <label htmlFor="am">Enable grounded answer mode</label>
+        </div>
+        <button className="ghost" onClick={saveFeatures} style={{ marginTop: 8 }}>Save</button>
+      </div>
+
+      <div className="card">
+        <h3>Synonyms</h3>
+        <p className="note">One line per term, format: <code>term: synonym1, synonym2</code></p>
+        <textarea
+          className="text-input"
+          rows={5}
+          value={synonymsText}
+          onChange={(e) => setSynonymsText(e.target.value)}
+        />
+        <button className="ghost" onClick={saveSynonyms} style={{ marginTop: 8 }}>Save synonyms</button>
+      </div>
+
+      <div className="card">
+        <h3>Index report</h3>
+        {report && report.reports && report.reports.length > 0 ? (
+          report.reports.slice(0, 1).map((rep, i) => (
+            <div key={i}>
+              <p className="note">
+                {rep.status} — {rep.started_at}
+                {rep.note ? ` — ${rep.note}` : ""}
+              </p>
+              <table className="usage">
+                <tbody>
+                  {(rep.files || []).slice(0, 50).map((f, j) => (
+                    <tr key={j}>
+                      <td>{f.file}</td>
+                      <td>{f.result}</td>
+                      <td>{f.chunks ?? ""}</td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          ))
+        ) : (
+          <p className="note">No reports yet.</p>
+        )}
+      </div>
+
+      <div className="card">
+        <h3>Change password</h3>
+        <label className="field">Current password</label>
+        <input className="text-input" type="password"
+          value={pw.current} onChange={(e) => setPw({ ...pw, current: e.target.value })} />
+        <label className="field">New password</label>
+        <input className="text-input" type="password"
+          value={pw.nw} onChange={(e) => setPw({ ...pw, nw: e.target.value })} />
+        <button className="ghost" onClick={doChangePassword} style={{ marginTop: 8 }}>Change password</button>
+        {pwResult && (
+          <div className="banner" style={{ marginTop: 10 }}>
+            <div>{pwResult.note}</div>
+            <code style={{ wordBreak: "break-all" }}>MANAGER_PASSWORD_HASH={pwResult.new_hash}</code>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

package/src/corpus/templates/semantic-search/services/web/src/main.jsx

@@ -0,0 +1,10 @@
+import React from "react";
+import { createRoot } from "react-dom/client";
+import App from "./App.jsx";
+import "./styles.css";
+
+createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);