Spaces:
Paused
Paused
Download web/src/query/QueryPage.tsx from aios-loopable/cfo-os: direct link, hf CLI and curl.
- Browser
- Download file 14.5 kB
-
https://huggingface.co/spaces/aios-loopable/cfo-os/resolve/main/web/src/query/QueryPage.tsx
- Command line
-
hf download hf://spaces/aios-loopable/cfo-os/web/src/query/QueryPage.tsx
-
curl -L -o QueryPage.tsx https://huggingface.co/spaces/aios-loopable/cfo-os/resolve/main/web/src/query/QueryPage.tsx
14.5 kB
| // --------------------------------------------------------------------------- | |
| // query/QueryPage.tsx — WAVE 32 item 7 (ruling R1, contract C5): the Query module. | |
| // | |
| // Ask a question about ONE database you already have; the assistant answers with | |
| // a VIEW, you read what it will actually do, and you keep it or you do not. | |
| // | |
| // ⛔ CHROME, NOT A REGISTRY MODULE, and `granted` is why that is allowed. `nav.ts`'s | |
| // law for this set is one sentence — "A CHROME ROUTE RENDERS NOTHING THE SERVER DID | |
| // NOT ALREADY GRANT" — so the database picker is the nav's OWN entries, handed down | |
| // by the Shell, never a directory this page fetches. (A registry row would have been | |
| // worse than wrong: every provisioned tenant's `modules` list is `['analyst', | |
| // 'automation']`, so a registry key is silently OMITTED from the rail in every | |
| // tenant while every gate stays green.) | |
| // | |
| // ⛔ NO SECOND GRID. Opening a saved query NAVIGATES to that database and asks the | |
| // real surface to select the view (`VIEW_OPEN_EVENT`), which is how the view renders | |
| // in its declared kind without this file learning what a kanban is. That channel's | |
| // own contract says it: "the SHELL routes to the table and the GRID owns view | |
| // selection, so neither has to learn the other's state." | |
| // | |
| // ⭐ AND THIS IS ITS FIRST EMITTER. `VIEW_OPEN_EVENT` was added in wave 20 for an | |
| // alert's click-through and has had a LISTENER (`CustomerGrid`) and no sender ever | |
| // since — the deep link it was built for was never wired ([[artifact-with-no-importer]] | |
| // on the emit side). Two consequences handled here: the listener checks its own view | |
| // list first (`views.some(...)`), so an event that arrives before the target grid has | |
| // loaded is DROPPED, and there is no acknowledgement channel to wait on. So the emit | |
| // is repeated on a short bounded schedule and `selectView` early-returns once the view | |
| // is active, which makes a re-emit free rather than a flicker. | |
| // | |
| // ⚠ THE SENTENCE UNDER THE ANSWER IS THE LOAD-BEARING PART OF THIS PAGE. Measured in | |
| // the prototype (W32-T50 section 4d): a free model produced a spec whose every column | |
| // was real, every op legal, kind in the vocabulary and target granted — and which | |
| // answered a different question ("Revenue by Creator" against a database holding no | |
| // revenue). No server-side validation can see that class. So the server DERIVES a | |
| // read-back from the spec it accepted, this page shows it, and nothing is saved until | |
| // a person says so. Never shorten `explain` away to make the page tidier. | |
| // | |
| // ⚠ NO CLIENT UNION OVER `kind` — the server's vocabulary arrives as a string (the | |
| // wave-9 law), so a kind we do not have a label for renders as itself rather than | |
| // dropping the row. | |
| // --------------------------------------------------------------------------- | |
| import { useCallback, useEffect, useState } from "react"; | |
| import { VIEW_OPEN_EVENT, signal } from "../apiContract"; | |
| import { databaseEntries } from "../shell/nav"; | |
| import type { NavEntry } from "../shell/nav"; | |
| import { buildQuery, deleteQuery, fetchQueries, saveQuery } from "./queryApi"; | |
| import type { BuildResult, SavedQuery } from "./queryApi"; | |
| import "./query.css"; | |
| export interface QueryPageProps { | |
| /** | |
| * ⛔ REQUIRED, and it is the nav's own entries. An optional prop here would | |
| * degrade to "the feature does not exist" the first time a mount forgot it, | |
| * which is indistinguishable from never having been built (the PRD's words for | |
| * this wiring). The Shell already holds these — passing them is also what keeps | |
| * the chrome law true by construction rather than by promise. | |
| */ | |
| granted: NavEntry[]; | |
| } | |
| /** Human words for a kind. A kind absent from here renders as itself, never dropped. */ | |
| const KIND_LABEL: Record<string, string> = { | |
| grid: "Table", | |
| list: "List", | |
| chart: "Chart", | |
| kanban: "Board", | |
| calendar: "Calendar", | |
| timeseries: "Time series", | |
| map: "Map", | |
| }; | |
| /** | |
| * When the view is opened in another surface, the target grid may not have loaded its | |
| * views yet — and its listener drops an event naming a view it cannot see. Re-emit on | |
| * this schedule (ms); `selectView` is idempotent, so a late arrival costs nothing. | |
| */ | |
| export const OPEN_RETRIES = [0, 250, 700, 1500, 2600] as const; | |
| export function openSavedView(scope: string, viewId: string): void { | |
| if (typeof window === "undefined") return; | |
| if (window.location.hash.replace(/^#\/?/, "") !== scope) { | |
| window.location.hash = `#/${scope}`; | |
| } | |
| for (const delay of OPEN_RETRIES) { | |
| window.setTimeout(() => signal(VIEW_OPEN_EVENT, { topic: scope, viewId }), delay); | |
| } | |
| } | |
| /** | |
| * The answer block: a refusal, or the read-back plus the two ways out. | |
| * | |
| * ⚠ A NAMED EXPORT ON PURPOSE, so `verify_query`'s render leg can paint the three states | |
| * directly. `renderToString` does not run effects, so the states this page reaches only | |
| * AFTER a fetch would otherwise be unprovable without a browser — and the read-back and | |
| * the refusal sentence are precisely the parts that must not quietly stop rendering | |
| * ([[ui-invisible-to-assertions]]). | |
| */ | |
| export function QueryAnswer({ result, saving, onKeep, onDiscard }: { | |
| result: BuildResult; | |
| saving?: boolean; | |
| onKeep: () => void; | |
| onDiscard: () => void; | |
| }) { | |
| if (result.refused) { | |
| return ( | |
| <section className="qy-answer is-refused" role="status"> | |
| <p className="qy-answer-head">That is not a view this database can draw</p> | |
| <p className="qy-answer-body">{result.refused}</p> | |
| </section> | |
| ); | |
| } | |
| if (!result.spec) return null; | |
| return ( | |
| <section className="qy-answer"> | |
| <p className="qy-answer-head">Here is what that view would do</p> | |
| {/* ⛔ THE READ-BACK. Derived by the SERVER from the spec it accepted, so it | |
| describes what will be built rather than what the model meant. */} | |
| {result.explain ? <p className="qy-answer-body">{result.explain}</p> : null} | |
| {/* ⛔ THE FALLBACK NOTICE. Not decoration: the top rung of the server's ladder is the only | |
| one measured to REFUSE an unanswerable question honestly, so a spec built by a lower | |
| rung can be well-formed, plausible and about a different question entirely — and the | |
| read-back above describes what the spec DOES, which is exactly as convincing either | |
| way. This is the one signal that tells the reader to look harder before keeping it. | |
| ⚠ It never blocks the save: the person is the check, and taking the control away | |
| because the model was second-choice would be a worse product than saying so. */} | |
| {result.fallback ? ( | |
| <p className="qy-answer-note" role="status"> | |
| Built by a backup model — the usual one was busy. Read this back carefully before | |
| keeping it. | |
| </p> | |
| ) : null} | |
| <div className="qy-answer-acts"> | |
| <button type="button" className="qy-btn qy-btn--primary" disabled={saving} | |
| onClick={onKeep}> | |
| {saving ? "Saving…" : "Keep this view"} | |
| </button> | |
| <button type="button" className="qy-btn" onClick={onDiscard}> | |
| Discard | |
| </button> | |
| </div> | |
| </section> | |
| ); | |
| } | |
| /** One saved view. Named for the same reason as {@link QueryAnswer}. */ | |
| export function SavedQueryRow({ view, dbLabel, onOpen, onDelete }: { | |
| view: SavedQuery; | |
| dbLabel: string; | |
| onOpen: () => void; | |
| onDelete: () => void; | |
| }) { | |
| return ( | |
| <li className="qy-row"> | |
| <div className="qy-row-main"> | |
| <button type="button" className="qy-row-open" onClick={onOpen}> | |
| {view.name} | |
| </button> | |
| <span className="qy-row-meta"> | |
| {KIND_LABEL[view.kind] ?? view.kind} · {dbLabel} | |
| </span> | |
| </div> | |
| {view.question ? <p className="qy-row-q">“{view.question}”</p> : null} | |
| {view.explain ? <p className="qy-row-explain">{view.explain}</p> : null} | |
| <div className="qy-row-acts"> | |
| <button type="button" className="qy-btn" onClick={onOpen}> | |
| Open | |
| </button> | |
| <button type="button" className="qy-btn qy-btn--quiet" onClick={onDelete}> | |
| Delete | |
| </button> | |
| </div> | |
| </li> | |
| ); | |
| } | |
| export default function QueryPage({ granted }: QueryPageProps) { | |
| const [scope, setScope] = useState<string>(""); | |
| const [question, setQuestion] = useState(""); | |
| const [busy, setBusy] = useState(false); | |
| const [result, setResult] = useState<BuildResult | null>(null); | |
| const [problem, setProblem] = useState(""); | |
| const [saved, setSaved] = useState<SavedQuery[]>([]); | |
| const [builtins, setBuiltins] = useState<string[]>([]); | |
| const [saving, setSaving] = useState(false); | |
| const [loaded, setLoaded] = useState(false); | |
| /** | |
| * The databases this page may ASK ABOUT. | |
| * | |
| * `databaseEntries` drops SURFACE rows (that fact is decided where rows are built, not | |
| * re-derived here) and a group head has no destination. ⛔ BUT "granted and not a surface" is | |
| * WIDER THAN THE BUILD DOOR ACCEPTS: it takes any `ut_*` key plus the built-in topics it | |
| * publishes as `builtins`. Offering anything else would be a control that lies — the picker | |
| * would list a database and the build call would 404 on it. So the server's own accepted set is | |
| * mirrored, never guessed, and until it arrives only `ut_*` keys are offered (fail NARROW). | |
| */ | |
| const databases = databaseEntries(granted).filter( | |
| (e) => e.kind !== "group" && (e.key.startsWith("ut_") || builtins.includes(e.key)) | |
| ); | |
| // Keep the picker on a database that still exists: a grant can be withdrawn while | |
| // this page is open, and the server prunes on read, so the client must not pin a key | |
| // the payload no longer carries. | |
| useEffect(() => { | |
| if (databases.length && !databases.some((d) => d.key === scope)) { | |
| setScope(databases[0].key); | |
| } | |
| }, [databases, scope]); | |
| const reload = useCallback(async () => { | |
| const res = await fetchQueries(); | |
| setLoaded(true); | |
| if (res.ok) { | |
| setSaved(res.value.views); | |
| setBuiltins(res.value.builtins); | |
| } | |
| }, []); | |
| useEffect(() => { | |
| void reload(); | |
| }, [reload]); | |
| const ask = useCallback(async () => { | |
| const q = question.trim(); | |
| if (!q || !scope || busy) return; | |
| setBusy(true); | |
| setProblem(""); | |
| setResult(null); | |
| const res = await buildQuery(q, scope); | |
| setBusy(false); | |
| if (!res.ok) { | |
| setProblem(res.message); | |
| return; | |
| } | |
| setResult(res.value); | |
| }, [busy, question, scope]); | |
| const keep = useCallback(async () => { | |
| if (!result?.spec || saving) return; | |
| setSaving(true); | |
| const res = await saveQuery(question.trim(), scope, result.spec); | |
| setSaving(false); | |
| if (!res.ok) { | |
| setProblem(res.message); | |
| return; | |
| } | |
| setResult(null); | |
| setQuestion(""); | |
| await reload(); | |
| }, [question, reload, result, saving, scope]); | |
| const forget = useCallback(async (id: string) => { | |
| const res = await deleteQuery(id); | |
| if (!res.ok) { | |
| setProblem(res.message); | |
| return; | |
| } | |
| await reload(); | |
| }, [reload]); | |
| const labelOf = (key: string) => | |
| databases.find((d) => d.key === key)?.label ?? key; | |
| return ( | |
| <div className="qy-page"> | |
| <h1 className="qy-title">Query</h1> | |
| <p className="qy-lede"> | |
| Ask about one of your databases. You get a view you can read before you keep it — | |
| and a plain answer when the question is not one this product can draw. | |
| </p> | |
| {databases.length === 0 ? ( | |
| // ⚠ TWO DIFFERENT FACTS, TWO DIFFERENT SENTENCES. Before the index arrives the offerable | |
| // set is deliberately narrow (see `databases`), so "you have no database" would be a claim | |
| // this page cannot yet make. | |
| <p className="qy-note"> | |
| {loaded | |
| ? "You do not have a database to ask about yet. Create one from the Database menu, " | |
| + "then come back and ask about it." | |
| : "Loading your databases…"} | |
| </p> | |
| ) : ( | |
| <section className="qy-ask"> | |
| <label className="qy-field"> | |
| <span className="qy-label">Database</span> | |
| <select | |
| className="qy-select" | |
| value={scope} | |
| onChange={(e) => setScope(e.currentTarget.value)} | |
| > | |
| {databases.map((d) => ( | |
| <option key={d.key} value={d.key}> | |
| {d.label} | |
| </option> | |
| ))} | |
| </select> | |
| </label> | |
| <label className="qy-field qy-field--grow"> | |
| <span className="qy-label">Question</span> | |
| <input | |
| className="qy-input" | |
| value={question} | |
| placeholder="Everyone with more than 50,000 followers, biggest first" | |
| onChange={(e) => setQuestion(e.currentTarget.value)} | |
| onKeyDown={(e) => { | |
| if (e.key === "Enter") void ask(); | |
| }} | |
| /> | |
| </label> | |
| <button | |
| type="button" | |
| className="qy-btn qy-btn--primary" | |
| disabled={busy || !question.trim()} | |
| onClick={() => void ask()} | |
| > | |
| {busy ? "Working…" : "Build a view"} | |
| </button> | |
| </section> | |
| )} | |
| {problem ? ( | |
| <p className="qy-note is-warn" role="status"> | |
| {problem} | |
| </p> | |
| ) : null} | |
| {/* A REFUSAL IS AN ANSWER, and it gets the same weight as a success — a sentence, | |
| never an error page (R1's own words). Both states live in `QueryAnswer`. */} | |
| {result ? ( | |
| <QueryAnswer | |
| result={result} | |
| saving={saving} | |
| onKeep={() => void keep()} | |
| onDiscard={() => setResult(null)} | |
| /> | |
| ) : null} | |
| <h2 className="qy-sub">Your views</h2> | |
| {!loaded ? ( | |
| <p className="qy-note"> | |
| <span className="lp-spin" role="status" aria-label="Loading" /> | |
| </p> | |
| ) : saved.length === 0 ? ( | |
| <p className="qy-note"> | |
| Nothing yet. A view you keep lands here, and in the database it was built from. | |
| </p> | |
| ) : ( | |
| <ul className="qy-list"> | |
| {saved.map((v) => ( | |
| <SavedQueryRow | |
| key={v.id} | |
| view={v} | |
| dbLabel={labelOf(v.scope)} | |
| onOpen={() => openSavedView(v.scope, v.viewId)} | |
| onDelete={() => void forget(v.id)} | |
| /> | |
| ))} | |
| </ul> | |
| )} | |
| </div> | |
| ); | |
| } | |