@manta-eu/horns-client 0.1.3 → 0.2.0

package/dist/lib/manta/studio-conversation.d.ts

@@ -0,0 +1,241 @@
+import type { Horn } from "@manta-eu/horns";
+import { type StudioStep } from "../studio-progress";
+export type StudioConversationState = {
+    draft: Horn | null;
+};
+export type StudioTurn = {
+    reply: string;
+    horn: Horn | undefined;
+};
+/** One Studio conversation. The draft is the object's and arrives through state sync. */
+export type StudioConversationArgs = {
+    datastoreId: string;
+    conversation: string;
+    /** Draws the Horn as it stands and says what is wrong with it. The page is the only thing that can. */
+    look: (why: string) => Promise<string>;
+};
+export declare function useStudioConversation(args: StudioConversationArgs): {
+    ask: (said: string) => Promise<StudioTurn>;
+    open: (horn: Horn) => Promise<void>;
+    steps: readonly StudioStep[];
+    draft: {
+        iri: string;
+        slug: string;
+        title: string;
+        datastoreId: string;
+        realm: "hiremanta-com" | "journey-travel";
+        schemaVersion: 1;
+        revision: number;
+        layout: {
+            kind: "grid";
+            columns: 12;
+            items: {
+                viewId: string;
+                x: number;
+                y: number;
+                w: number;
+                h: number;
+            }[];
+        };
+        variables: {
+            id: string;
+            label: string;
+            type: "string" | "number" | "date" | "iri" | "enum" | "dateRange";
+            default?: import("zod").JSONType | undefined;
+            options?: {
+                values: import("zod").JSONType[];
+            } | {
+                binding: {
+                    kind: "select";
+                    sparql: string;
+                    params: string[];
+                    limit: number;
+                    derivations: string[];
+                    columns: {
+                        name: string;
+                        type: "string" | "number" | "boolean" | "date" | "iri";
+                    }[];
+                } | {
+                    kind: "lens";
+                    classIri: string;
+                    limit: number;
+                    derivations: string[];
+                    fields: {
+                        name: string;
+                        path: string;
+                        type: "string" | "number" | "boolean" | "date" | "iri";
+                    }[];
+                    rows?: "value" | "entity" | undefined;
+                } | {
+                    kind: "query";
+                    query: {
+                        item: string;
+                        revision: string;
+                        hash: string;
+                    };
+                    params: string[];
+                    limit: number;
+                };
+            } | undefined;
+            urlParam?: string | undefined;
+        }[];
+        views: ({
+            id: string;
+            title: string;
+            binding: {
+                kind: "select";
+                sparql: string;
+                params: string[];
+                limit: number;
+                derivations: string[];
+                columns: {
+                    name: string;
+                    type: "string" | "number" | "boolean" | "date" | "iri";
+                }[];
+            } | {
+                kind: "lens";
+                classIri: string;
+                limit: number;
+                derivations: string[];
+                fields: {
+                    name: string;
+                    path: string;
+                    type: "string" | "number" | "boolean" | "date" | "iri";
+                }[];
+                rows?: "value" | "entity" | undefined;
+            } | {
+                kind: "query";
+                query: {
+                    item: string;
+                    revision: string;
+                    hash: string;
+                };
+                params: string[];
+                limit: number;
+            };
+            render: {
+                kind: "component";
+                component: {
+                    item: string;
+                    revision: string;
+                    hash: string;
+                };
+                props: import("zod").JSONType;
+            } | {
+                kind: "tsx";
+                source: string;
+                reviewed?: {
+                    hash: string;
+                    at: string;
+                } | undefined;
+            };
+            emits?: {
+                event: string;
+                setsVariable: string;
+            }[] | undefined;
+        } | {
+            id: string;
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        })[];
+        derivations: ({
+            id: string;
+            predicateIri: string;
+            appliesTo: string;
+            datatype: string;
+            pattern: string;
+            status: "query" | "staged" | "materialized";
+            promotedRuleIri?: string | undefined;
+        } | {
+            id: string;
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        })[];
+        actions: ({
+            kind: "kg-update";
+            insert: string;
+            allowedPredicates: string[];
+            allowedClasses: string[];
+            id: string;
+            label: string;
+            params: {
+                id: string;
+                type: "string" | "number" | "date" | "iri" | "enum";
+                required: boolean;
+                classIri?: string | undefined;
+                values?: import("zod").JSONType[] | undefined;
+            }[];
+            confirm: true;
+            delete?: string | undefined;
+            where?: string | undefined;
+            criteria?: {
+                ask: string;
+            } | undefined;
+        } | {
+            kind: "action-shape";
+            actionShapeIri: string;
+            operation: "update" | "addition";
+            mapping: Record<string, string>;
+            id: string;
+            label: string;
+            params: {
+                id: string;
+                type: "string" | "number" | "date" | "iri" | "enum";
+                required: boolean;
+                classIri?: string | undefined;
+                values?: import("zod").JSONType[] | undefined;
+            }[];
+            confirm: true;
+            criteria?: {
+                ask: string;
+            } | undefined;
+        } | {
+            id: string;
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        })[];
+        dependencies: {
+            kind: "view" | "action" | "query" | "component" | "derivation" | "horn";
+            ref: {
+                item: string;
+                revision: string;
+                hash: string;
+            };
+        }[];
+        lock: {
+            lockVersion: 1;
+            entries: {
+                kind: "view" | "action" | "query" | "component" | "derivation" | "horn";
+                ref: {
+                    item: string;
+                    revision: string;
+                    hash: string;
+                };
+                requiredBy: string[];
+            }[];
+        };
+        runtime: {
+            kit: string;
+        };
+        summary?: string | undefined;
+        audience?: string | undefined;
+        about?: string[] | undefined;
+        baseRevision?: number | undefined;
+        style?: {
+            theme?: "light" | "dark" | undefined;
+            accent?: "blue" | "orange" | "green" | "amber" | "pink" | "forest" | "indigo" | "red" | undefined;
+            density?: "compact" | "comfortable" | undefined;
+            radius?: "sharp" | "soft" | "round" | undefined;
+        } | undefined;
+    } | undefined;
+    pending: boolean;
+};

package/dist/lib/manta/studio-conversation.js

@@ -0,0 +1,83 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useAgent } from "agents/react";
+import { useAgentChat } from "agents/chat/react";
+import { isPresent } from "@manta-eu/lib/present";
+import { studioReplyOf, studioStepsOf } from "../studio-progress";
+// One array, so a turn with no steps does not re-render the page every tick.
+const emptySteps = [];
+/** The reply and the draft arrive separately; the stream finishes first. */
+const draftGraceMs = 3_000;
+export function useStudioConversation(args) {
+    // No leading slash: the socket client builds `${host}/${basePath}` and adds the separator itself.
+    const at = `api/d/${encodeURIComponent(args.datastoreId)}/studio/${encodeURIComponent(args.conversation)}`;
+    const agent = useAgent({ agent: "studio", name: args.conversation, basePath: at });
+    const look = useRef(args.look);
+    look.current = args.look;
+    const chat = useAgentChat({
+        agent,
+        credentials: "include",
+        getInitialMessages: null,
+        resume: true,
+        tools: {
+            look_at_it: {
+                execute: (input) => {
+                    const why = typeof input === "object" && input !== null && "why" in input ? String(input.why) : "";
+                    return look.current(why);
+                },
+            },
+        },
+    });
+    const [tick, setTick] = useState(0);
+    const waiting = useRef(undefined);
+    const before = useRef(chat.status);
+    const drawn = useRef(undefined);
+    if (isPresent(agent.state?.draft))
+        drawn.current = agent.state.draft;
+    useEffect(() => {
+        const held = waiting.current;
+        if (!isPresent(held)) {
+            before.current = chat.status;
+            return;
+        }
+        const settled = chat.status === "ready" || chat.status === "error";
+        if (!settled) {
+            before.current = chat.status;
+            return;
+        }
+        if (chat.status === "error") {
+            waiting.current = undefined;
+            held.reject(new Error("The Studio could not answer."));
+            return;
+        }
+        held.settledAt ??= Date.now();
+        const changed = drawn.current !== held.before;
+        if (!changed && Date.now() - held.settledAt < draftGraceMs) {
+            const again = setTimeout(() => setTick((count) => count + 1), 120);
+            before.current = chat.status;
+            return () => clearTimeout(again);
+        }
+        waiting.current = undefined;
+        const last = [...chat.messages].reverse().find((message) => message.role === "assistant");
+        held.resolve({ reply: studioReplyOf(last?.parts ?? []), horn: drawn.current });
+        before.current = chat.status;
+        return;
+    }, [chat.status, chat.messages, tick, agent.state]);
+    /** Tells the object which Horn it is about. */
+    const open = useCallback(async (horn) => {
+        const response = await fetch(`/${at}/open`, {
+            method: "POST",
+            credentials: "include",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ horn }),
+        });
+        if (!response.ok)
+            throw new Error("This Horn could not be opened in the Studio.");
+    }, [at]);
+    const ask = useCallback((said) => new Promise((resolve, reject) => {
+        waiting.current = { resolve, reject, before: drawn.current };
+        void chat.sendMessage({ text: said });
+    }), [chat]);
+    const running = chat.status === "ready" ? undefined : [...chat.messages].reverse()[0];
+    const steps = running?.role === "assistant" ? studioStepsOf(running.parts ?? []) : emptySteps;
+    return { ask, open, steps, draft: agent.state?.draft ?? undefined, pending: chat.status !== "ready" };
+}

package/dist/lib/studio-progress.d.ts

@@ -3,5 +3,12 @@ export type StudioStep = {
     title: string;
     detail?: string;
 };
-/** One line for one streamed event, or nothing for an event not worth a line of its own. */
-export declare function studioProgressLine(line: Record<string, unknown>): StudioStep | undefined;
+export type MessagePart = {
+    type: string;
+    toolName?: unknown;
+    text?: unknown;
+};
+/** What the turn has done so far. The same tool twice running is one line with a count. */
+export declare function studioStepsOf(parts: readonly MessagePart[]): StudioStep[];
+/** The answer: what was said after the last tool call. Anything before it is narration. */
+export declare function studioReplyOf(parts: readonly MessagePart[]): string;

package/dist/lib/studio-progress.js

@@ -1,38 +1,63 @@
-import { match } from "ts-pattern";
-import { isRecord } from "@manta-eu/horns";
-// What a Horn turn is doing, in words, from the events the route streams. A tool name is the model's
-// vocabulary; the person watching wants to know what is being looked at.
 const toolLines = {
     list_classes: "Looking at what this datastore holds",
     describe_class: "Reading how a kind of thing is described",
     components_for_class: "Looking for components that already fit",
+    find_components: "Looking through the design system",
+    read_component_api: "Reading how a component works",
+    list_computed: "Looking at what Manta works out",
+    list_rules: "Reading the rules",
     run_sparql: "Querying the datastore",
     investigate_data: "Investigating the data",
+    ask_manta_for_rule: "Asking Manta for a rule",
     propose_horn_patch: "Changing the Horn",
+    propose_plan: "Putting a plan up",
     propose_library_item: "Offering a part for the library",
     report_harness_issue: "Noting a problem with the tools",
+    look_at_it: "Looking at what it drew",
 };
-// A turn can start a loop of its own. Its steps are the same steps, said by somebody else.
-const agentNames = { investigate: "Investigating" };
-/** One line for one streamed event, or nothing for an event not worth a line of its own. */
-export function studioProgressLine(line) {
-    const event = line["event"];
-    if (!isRecord(event))
-        return undefined;
-    const name = typeof event["name"] === "string" ? event["name"] : "";
-    const detail = typeof event["detail"] === "string" ? event["detail"] : undefined;
-    const agent = typeof event["agent"] === "string" ? (agentNames[event["agent"]] ?? event["agent"]) : undefined;
-    const step = (title) => title === undefined
-        ? undefined
-        : { title: agent === undefined ? title : `${agent} · ${title}`, ...(detail === undefined ? {} : { detail }) };
-    return match(event["type"])
-        .with("reading", () => step("Reading the Horn and the data behind it"))
-        .with("round", () => (event["step"] === 1 && agent === undefined ? step("Thinking") : undefined))
-        .with("tool-call", () => event["repeated"] === true || name === "propose_horn_patch"
-        ? undefined
-        : step(toolLines[name] ?? `Using ${name}`))
-        .with("proposal-accepted", () => (name === "propose_horn_patch" ? step("Changed the Horn") : undefined))
-        .with("proposal-rejected", () => step("That change did not hold up against the data, trying again"))
-        .with("rehydrated", () => step("Starting over from the Horn as it stands"))
-        .otherwise(() => undefined);
+// A dynamic tool part carries its name separately.
+function toolNameOf(part) {
+    if (typeof part.toolName === "string")
+        return part.toolName;
+    return part.type.startsWith("tool-") ? part.type.slice("tool-".length) : undefined;
+}
+const narrationLimit = 240;
+function wordsOf(part) {
+    return typeof part.text === "string" ? part.text.trim() : "";
+}
+/** What the turn has done so far. The same tool twice running is one line with a count. */
+export function studioStepsOf(parts) {
+    const steps = [];
+    let repeats = 0;
+    let narration = "";
+    for (const part of parts) {
+        const name = toolNameOf(part);
+        if (name === undefined) {
+            const said = wordsOf(part);
+            if (said !== "")
+                narration = said;
+            continue;
+        }
+        const title = toolLines[name] ?? `Using ${name}`;
+        const detail = narration === "" ? undefined : narration.slice(0, narrationLimit);
+        narration = "";
+        const last = steps[steps.length - 1];
+        if (last?.title === title && detail === undefined) {
+            repeats += 1;
+            last.detail = `${repeats + 1} times`;
+            continue;
+        }
+        repeats = 0;
+        steps.push({ title, ...(detail === undefined ? {} : { detail }) });
+    }
+    return steps;
+}
+/** The answer: what was said after the last tool call. Anything before it is narration. */
+export function studioReplyOf(parts) {
+    const lastTool = parts.map((part) => toolNameOf(part) !== undefined).lastIndexOf(true);
+    return parts
+        .slice(lastTool + 1)
+        .map(wordsOf)
+        .filter((said) => said !== "")
+        .join("\n\n");
 }