wizards 0.2.16 → 0.2.18

package/node_modules/@engenty-wizards/plugin-sdk/dist/index.d.ts

@@ -188,6 +188,168 @@ export interface PluginIndex {
     /** Takes one key out, or without a key every entry of the plugin in the space. */
     remove(space: string, key?: string): Promise<void>;
 }
+/** A Kategorie of a space: a typed property set on pages, tables, rows and files of Wissen. */
+export interface PluginCategory {
+    name: string;
+    type: "choice" | "date" | "number" | "text" | "boolean";
+    /** A number's unit: `h`, `€`, `kg`. */
+    unit?: string;
+    /** A choice: several values per item. */
+    multiple?: boolean;
+    /** A choice whose values are ranked, in the order of `values`. */
+    ordered?: boolean;
+    /** Where its values come from, in a few words: "Kopfzeile", "Filter der Website". */
+    hint?: string;
+    /** A choice's values, known beforehand: a site's filter. Others are added as items bring them. */
+    values?: string[];
+    /** A column of a table the plugin wrote (by the table's key) whose cells are its values. */
+    column?: {
+        table: string;
+        column: string;
+    };
+}
+/**
+ * Kategorien of an item, by their names: a choice's value (or a list of them), a day as
+ * `YYYY-MM-DD`, a number, a short text, true or false. Null takes one off.
+ */
+export type PluginCategoryValues = Record<string, string | number | boolean | (string | number)[] | null>;
+/** The original an item was read from, kept as the evidence beside it. */
+export interface PluginOriginal {
+    name: string;
+    mime: string;
+    data: Uint8Array;
+}
+/** `written`: the plugin's version stands. `kept`: a person changed it, the plugin no longer writes it. */
+export type PluginItemState = "written" | "kept";
+export interface PluginPageInput {
+    space: string;
+    /** The plugin's own name for the page: the same key again rewrites it, never doubles it. */
+    key: string;
+    /** What the person knows its source as: "Tagesberichte". */
+    label?: string;
+    title: string;
+    markdown: string;
+    /** The key of a page the plugin wrote before, to stand under it as a sub-page. */
+    parent?: string;
+    position?: number;
+    original?: PluginOriginal;
+    categories?: PluginCategoryValues;
+    /** A model fills the space's Kategorien the page did not get from `categories`. */
+    fill?: boolean;
+    /** Why a person should look at it ("hardly readable"); shown in Wissen. */
+    review?: string | null;
+}
+export interface PluginTableInput {
+    space: string;
+    key: string;
+    label?: string;
+    title: string;
+    /** Typed columns, as a table of the space has them (`text`, `number`, `date`, `select` …). */
+    columns: unknown[];
+    /** Cells by column id. They replace the rows the key had. */
+    rows: Record<string, unknown>[];
+    /** `faq`: a question and its answer per row. */
+    format?: "faq";
+    original?: PluginOriginal;
+    categories?: PluginCategoryValues;
+    review?: string | null;
+}
+export interface PluginFileInput {
+    space: string;
+    key: string;
+    label?: string;
+    name: string;
+    mime: string;
+    data: Uint8Array;
+    /** What it is, in a sentence: a file that is no page is found by its name and this. */
+    description?: string;
+    /** What a step reads of it, when there is text. */
+    text?: string;
+    categories?: PluginCategoryValues;
+}
+export interface PluginDocumentInput {
+    space: string;
+    key: string;
+    label?: string;
+    name: string;
+    mime: string;
+    data: Uint8Array;
+    /** Set on what it becomes: its first page, its first table, or the file. */
+    categories?: PluginCategoryValues;
+    /** A model fills the space's Kategorien it did not get from `categories`. */
+    fill?: boolean;
+}
+/** What a document became: pages and tables (the first is the one it is found as), or a file. */
+export interface PluginDocumentResult {
+    /** The file, kept as the original. */
+    id: string;
+    path: string;
+    state: PluginItemState;
+    items: {
+        kind: "page" | "table";
+        id: string;
+        path: string;
+        title: string;
+    }[];
+    /** Why a person should look at it: hardly readable, or not readable at all. */
+    review: string | null;
+}
+/** What a plugin wrote into a space. */
+export interface PluginSpaceItem {
+    key: string;
+    kind: "page" | "table" | "file";
+    id: string;
+    title: string;
+    /** How a step names it: `pages/…`, `tables/…`, `files/…`. */
+    path: string;
+    state: PluginItemState;
+    review: string | null;
+    updatedAt: string;
+}
+/**
+ * Wissen of a space, written by a plugin: pages, tables and files under keys of its own, with
+ * their Kategorien. Every write is indexed: `project_search` finds it a moment later.
+ */
+export interface PluginSpaceData {
+    /**
+     * Adds Kategorien to the space, or values to ones it has. `proposed`: shown to the person to
+     * confirm, never filled before; a later call without it takes them.
+     */
+    putCategories(input: {
+        space: string;
+        categories: PluginCategory[];
+        proposed?: boolean;
+    }): Promise<void>;
+    putPage(input: PluginPageInput): Promise<{
+        id: string;
+        path: string;
+        state: PluginItemState;
+    }>;
+    putTable(input: PluginTableInput): Promise<{
+        id: string;
+        path: string;
+        state: PluginItemState;
+    }>;
+    putFile(input: PluginFileInput): Promise<{
+        id: string;
+        path: string;
+    }>;
+    /**
+     * A document read as an upload is: a page (sub-pages when it is long and has headings of its
+     * own), a table per sheet of a workbook, or a file when nothing reads it. The document stays as
+     * the original. The same key again reads it again, unless a person changed what it became.
+     */
+    putDocument(input: PluginDocumentInput): Promise<PluginDocumentResult>;
+    /** Everything the plugin wrote into the space. */
+    list(space: string): Promise<PluginSpaceItem[]>;
+    /** Takes out one key, or every item of the plugin in the space; what a person changed stays. */
+    remove(space: string, key?: string): Promise<number>;
+    /**
+     * Writes the Übersicht of values: of one, or of every value of a choice (or of every choice)
+     * that has three items or more. Returns how many were written. Costs a model call each.
+     */
+    summarize(space: string, category?: string, value?: string): Promise<number>;
+}
 /** What a tool of the space assistant knows about the turn that calls it. */
 export interface PluginAssistantContext {
     tenantId: string;
@@ -310,6 +472,8 @@ export interface PluginServerApi {
     every(name: string, everyMs: number, handler: (tick: PluginTick) => void | Promise<void>): void;
     /** The space's search index, which `project_search` asks. */
     index: PluginIndex;
+    /** Wissen of a space: pages, tables and files the plugin writes, with their Kategorien. */
+    spaceData: PluginSpaceData;
     web: PluginWeb;
     documents: PluginDocuments;
     /**

package/node_modules/@engenty-wizards/shared/dist/definition.d.ts

@@ -1429,5 +1429,15 @@ export interface ItemsTotals {
 }
 export declare function itemsTotals(field: Field, value: unknown, values: Record<string, unknown>): ItemsTotals;
 export declare function allFields(def: WizardDefinition): Field[];
+/**
+ * The language a wizard speaks to people, read from its own words (titles, labels, intro).
+ * A definition carries none; German where it is not clearly English.
+ */
+export declare function wizardLang(def: WizardDefinition): "de" | "en";
+/** The locale amounts and dates are written in for a wizard's language. */
+export declare const LOCALES: {
+    readonly de: "de-DE";
+    readonly en: "en-GB";
+};
 /** True when this app's schema reads the definition without losing anything of it. */
 export declare function readable(definition: unknown): boolean;

package/node_modules/@engenty-wizards/shared/dist/definition.js

@@ -796,6 +796,31 @@ function round2(n) {
 export function allFields(def) {
     return def.steps.flatMap((s) => (s.type === "page" ? s.fields : []));
 }
+const GERMAN = /\b(und|der|die|das|ist|nicht|für|mit|ein|eine|wird|zu|dein|deine|ihr|wir|was|wie|oder)\b|[äöüß]/gi;
+const ENGLISH = /\b(and|the|is|not|for|with|a|an|your|you|we|what|how|or|to|of)\b/gi;
+/**
+ * The language a wizard speaks to people, read from its own words (titles, labels, intro).
+ * A definition carries none; German where it is not clearly English.
+ */
+export function wizardLang(def) {
+    const text = [
+        def.title,
+        def.description,
+        def.intro,
+        ...def.steps.flatMap((s) => [
+            s.title,
+            s.description,
+            ...(s.type === "page" ? s.fields.flatMap((f) => [f.label, f.help, f.placeholder]) : []),
+        ]),
+    ]
+        .filter(Boolean)
+        .join(" ");
+    const de = text.match(GERMAN)?.length ?? 0;
+    const en = text.match(ENGLISH)?.length ?? 0;
+    return en > de ? "en" : "de";
+}
+/** The locale amounts and dates are written in for a wizard's language. */
+export const LOCALES = { de: "de-DE", en: "en-GB" };
 // --- can this app read a definition? ---------------------------------------------------------
 // The schema drops what it does not know. A definition written for a newer app would be read
 // without complaint and run wrongly, so it counts only when nothing of it is lost.

package/node_modules/@engenty-wizards/shared/dist/knowledge.d.ts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+/**
+ * Wissen: what a space holds for its wizards' steps to look up. Pages (Markdown, with sub-pages),
+ * tables (typed columns; FAQ is a format of one) and files that could not be read into either.
+ * Kategorien run across all of them: typed properties a step filters on before it searches.
+ */
+export declare const CATEGORY_TYPES: readonly ["choice", "date", "number", "text", "boolean"];
+export type CategoryType = (typeof CATEGORY_TYPES)[number];
+/** A value of a choice, how many items have it, and whether it has an Übersicht. */
+export interface CategoryValueInfo {
+    id: string;
+    value: string;
+    count: number;
+    summary: boolean;
+}
+export interface SpaceCategory {
+    id: string;
+    name: string;
+    type: CategoryType;
+    /** A number's unit: `h`, `€`, `kg`. */
+    unit: string | null;
+    /** A choice: several values per item. */
+    multiple: boolean;
+    /** A choice whose values are ranked: their order is the rank. */
+    ordered: boolean;
+    /** Where its values come from, in a few words. */
+    hint: string | null;
+    /** The plugin that brought it. */
+    origin: string | null;
+    /** Proposed, not taken yet: never filled until a person takes it. */
+    proposed: boolean;
+    /** A column of a table whose cells are its values. */
+    tableId: string | null;
+    columnId: string | null;
+    /** How many items have it. */
+    count: number;
+    /** A choice's values, in their order. */
+    values: CategoryValueInfo[];
+    /** A date's or a number's lowest and highest value (a date as `YYYY-MM-DD`). */
+    range: {
+        min: string | number;
+        max: string | number;
+    } | null;
+    /** Pairs of values that look like one written two ways ("Graz-Süd", "Graz Süd"), by id. */
+    alike: [string, string][];
+}
+/** A value as an item has it: a choice's value, a date as `YYYY-MM-DD`, a number, a text, yes/no. */
+export type CategoryCell = string | number | boolean;
+/** What an item has of one Kategorie. */
+export interface ItemCategory {
+    categoryId: string;
+    /** A choice with several values has several. */
+    values: CategoryCell[];
+    by: "person" | "origin" | "model";
+}
+/** What a writer sets: by the Kategorie's name; a list for a choice with several values. */
+export type CategoryInput = Record<string, CategoryCell | CategoryCell[] | null>;
+export type KnowledgeKind = "page" | "table" | "file";
+/** An item of Wissen, as lists show it. Sub-pages stand under their page, not in the list. */
+export interface KnowledgeItem {
+    /** `p:<id>`, `t:<id>`, `f:<id>`. */
+    key: string;
+    kind: KnowledgeKind;
+    id: string;
+    title: string;
+    /** How a step names it: `pages/handbuch/montage`, `tables/kettenprogramm`, `files/plan.dwg`. */
+    path: string;
+    /** A page's sub-pages. */
+    children: number;
+    /** A table's rows. */
+    rows: number | null;
+    format: "faq" | null;
+    /** What wrote it: a plugin's id and what it calls the source; null when a person did. */
+    origin: string | null;
+    originLabel: string | null;
+    /** A person changed what its origin wrote: the origin no longer writes it. */
+    kept: boolean;
+    /** Why a person should look at it; null when nothing is in doubt. */
+    review: string | null;
+    /** The file it was read from. */
+    fileId: string | null;
+    /** A file still being read, or that could not be read. */
+    status: "pending" | "ready" | "failed";
+    categories: ItemCategory[];
+    updatedAt: string;
+}
+export interface Knowledge {
+    items: KnowledgeItem[];
+    categories: SpaceCategory[];
+    /** The index finds by meaning too, not by keywords alone. */
+    embeddings: boolean;
+    /** A classifier checks what a search found. */
+    checked: boolean;
+}
+/** A value of a choice, opened: its Übersicht and its Inhaltsverzeichnis, the items that have it. */
+export interface KnowledgeValue {
+    id: string;
+    value: string;
+    category: {
+        id: string;
+        name: string;
+    };
+    summary: string | null;
+    summaryAt: string | null;
+    /** Pages (sub-pages too), tables and files that have the value. */
+    items: KnowledgeItem[];
+    /** Rows of tables that have it, by table. */
+    rows: {
+        tableId: string;
+        title: string;
+        count: number;
+    }[];
+}
+/** A page with what Wissen knows about it, as the studio opens it. */
+export interface KnowledgePage {
+    id: string;
+    path: string;
+    /** Its ancestors, outermost first. */
+    parents: {
+        id: string;
+        title: string;
+    }[];
+    children: {
+        id: string;
+        title: string;
+        path: string;
+    }[];
+    categories: ItemCategory[];
+    origin: string | null;
+    originLabel: string | null;
+    kept: boolean;
+    review: string | null;
+    file: {
+        id: string;
+        name: string;
+        mime: string;
+    } | null;
+}
+/**
+ * A filter on one Kategorie: a value (a choice is it, a text equals it, yes/no), one of several,
+ * or a range — numbers by `gte`/`lte`, dates by `after`/`before` (`YYYY-MM-DD`, both ends
+ * included), a text by `contains`, an ordered choice by `atLeast`.
+ */
+export declare const whereValueSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>, z.ZodObject<{
+    gte: z.ZodOptional<z.ZodNumber>;
+    lte: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    contains: z.ZodOptional<z.ZodString>;
+    atLeast: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+export type WhereValue = z.infer<typeof whereValueSchema>;
+/** Filters by the Kategorie's name; an item matches all of them. */
+export declare const whereSchema: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>, z.ZodObject<{
+    gte: z.ZodOptional<z.ZodNumber>;
+    lte: z.ZodOptional<z.ZodNumber>;
+    after: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    contains: z.ZodOptional<z.ZodString>;
+    atLeast: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>>;
+export type Where = z.infer<typeof whereSchema>;
+export interface KnowledgeHit {
+    /** `p:<id>`, `t:<id>` (a row of it), `f:<id>`, `v:<id>` (a value's Übersicht), `d:<id>` (a
+     * document read before Wissen had pages), `x:<plugin>:<key>` (a plugin's text). */
+    key: string;
+    kind: KnowledgeKind | "summary" | "document" | "plugin";
+    /** What the studio opens for it: `p:`, `t:` (a row's table), `f:`, `v:`; null for a plugin's text. */
+    open: string | null;
+    path: string;
+    title: string;
+    /** The Kategorien as `name: value`. */
+    categories: string[];
+    /** The best section's headings, outermost first, joined by " › ". */
+    heading: string | null;
+    /** The page of the original it stands on. */
+    sheet: number | null;
+    /** A row of a table: its id. */
+    rowId: string | null;
+    text: string;
+    /** P(relevant) the classifier gave; null when nothing checked it. */
+    relevance: number | null;
+    /** Where the studio shows a plugin's text. */
+    link: string | null;
+    plugin: string | null;
+}
+export interface KnowledgeSearch {
+    hits: KnowledgeHit[];
+    /** How many units the keywords and the vectors found together, before the classifier. */
+    candidates: number;
+    /** A classifier judged the candidates; false: they keep the order the index gave them. */
+    checked: boolean;
+    /** Items the filter left, when there was one. */
+    filtered: number | null;
+}
+/** A day as `YYYY-MM-DD` from what a person or a source wrote: ISO, `14.03.2026`, a timestamp. */
+export declare function dayOf(value: unknown): string | null;
+/** A slug for a path: lower case, `-` between words, umlauts spelled out. */
+export declare function slugOf(title: string): string;

package/node_modules/@engenty-wizards/shared/dist/knowledge.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+/**
+ * Wissen: what a space holds for its wizards' steps to look up. Pages (Markdown, with sub-pages),
+ * tables (typed columns; FAQ is a format of one) and files that could not be read into either.
+ * Kategorien run across all of them: typed properties a step filters on before it searches.
+ */
+export const CATEGORY_TYPES = ["choice", "date", "number", "text", "boolean"];
+// --- filters --------------------------------------------------------------------
+/**
+ * A filter on one Kategorie: a value (a choice is it, a text equals it, yes/no), one of several,
+ * or a range — numbers by `gte`/`lte`, dates by `after`/`before` (`YYYY-MM-DD`, both ends
+ * included), a text by `contains`, an ordered choice by `atLeast`.
+ */
+export const whereValueSchema = z.union([
+    z.string().max(200),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string().max(200), z.number()])).max(50),
+    z
+        .object({
+        gte: z.number().optional(),
+        lte: z.number().optional(),
+        after: z.string().max(40).optional(),
+        before: z.string().max(40).optional(),
+        contains: z.string().max(200).optional(),
+        atLeast: z.string().max(200).optional(),
+    })
+        .strict(),
+]);
+/** Filters by the Kategorie's name; an item matches all of them. */
+export const whereSchema = z.record(z.string().max(120), whereValueSchema);
+/** A day as `YYYY-MM-DD` from what a person or a source wrote: ISO, `14.03.2026`, a timestamp. */
+export function dayOf(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const d = new Date(value);
+        return Number.isNaN(d.getTime()) ? null : d.toISOString().slice(0, 10);
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const s = value.trim();
+    const iso = /^(\d{4})-(\d{2})-(\d{2})/.exec(s);
+    if (iso) {
+        return `${iso[1]}-${iso[2]}-${iso[3]}`;
+    }
+    const de = /^(\d{1,2})\.(\d{1,2})\.(\d{2,4})/.exec(s);
+    if (de) {
+        const year = de[3].length === 2 ? `20${de[3]}` : de[3];
+        return `${year}-${de[2].padStart(2, "0")}-${de[1].padStart(2, "0")}`;
+    }
+    return null;
+}
+/** A slug for a path: lower case, `-` between words, umlauts spelled out. */
+export function slugOf(title) {
+    return (title
+        .toLowerCase()
+        .replace(/ä/g, "ae")
+        .replace(/ö/g, "oe")
+        .replace(/ü/g, "ue")
+        .replace(/ß/g, "ss")
+        .replace(/§/g, "p")
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60)
+        .replace(/-+$/, "") || "seite");
+}

package/node_modules/@engenty-wizards/shared/dist/projects.d.ts

@@ -52,7 +52,7 @@ export declare const PROJECT_LIMITS: {
     readonly files: {
         readonly logo: 8;
         readonly asset: 100;
-        readonly document: 50;
+        readonly document: 2000;
     };
     readonly bytes: {
         readonly logo: 5000000;
@@ -63,18 +63,3 @@ export declare const PROJECT_LIMITS: {
 };
 /** The largest file of a kind and type a project takes. */
 export declare function projectFileLimit(kind: ProjectFileKind, mime: string): number;
-/** One passage the document index found for a question. */
-export interface ProjectSearchHit {
-    /** The document the passage is of; null for a plugin's text. */
-    fileId: string | null;
-    /** The plugin whose text it is; null for a document. */
-    plugin: string | null;
-    /** The document's name, or the title of the plugin's text. */
-    name: string;
-    /** Where the studio shows a plugin's text. */
-    link: string | null;
-    /** The passage's place in its document, from 0. */
-    index: number;
-    text: string;
-    score: number;
-}

package/node_modules/@engenty-wizards/shared/dist/projects.js

@@ -84,7 +84,7 @@ export const PROJECT_FILE_KINDS = ["logo", "asset", "document"];
 export const PROJECT_LIMITS = {
     facts: 100,
     colors: 12,
-    files: { logo: 8, asset: 100, document: 50 },
+    files: { logo: 8, asset: 100, document: 2000 },
     bytes: { logo: 5_000_000, asset: 15_000_000, video: 80_000_000, document: 30_000_000 },
 };
 /** The largest file of a kind and type a project takes. */