@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/forms/variantGrid.js

@@ -0,0 +1,283 @@
+import { contextFrom, findRows, mappedValues, parseTarget, slug, startingValue, targetField, toWriteValues, } from "./shared.js";
+const comboKey = (values) => JSON.stringify(values);
+/**
+ * Split pasted lists on commas, trim, drop blanks and repeats
+ * (case-insensitively), keep the order.
+ */
+export function cleanValues(values) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of values.flatMap((value) => value.split(','))) {
+        const value = raw.trim();
+        const folded = value.toLowerCase();
+        if (!value || seen.has(folded))
+            continue;
+        seen.add(folded);
+        out.push(value);
+    }
+    return out;
+}
+/**
+ * Every combination of the axes' values, rows in axis order. An axis with no
+ * values is left out, so a product with only sizes still gets a cell per size;
+ * no values anywhere means no cells.
+ */
+export function combinations(axes) {
+    const used = axes
+        .map((axis) => ({ name: axis.name, values: cleanValues(axis.values) }))
+        .filter((axis) => axis.values.length > 0);
+    if (used.length === 0)
+        return [];
+    let combos = [[]];
+    for (const axis of used) {
+        combos = combos.flatMap((prefix) => axis.values.map((value) => [...prefix, { name: axis.name, value }]));
+    }
+    return combos.map((parts) => ({
+        key: comboKey(parts.map((p) => p.value)),
+        attributes: Object.fromEntries(parts.map((p) => [p.name, p.value])),
+        values: parts.map((p) => p.value),
+    }));
+}
+/** The grid's combinations for its current state. */
+export function gridCombos(form, state) {
+    return combinations(form.axes.map((axis) => ({
+        name: axis.name,
+        values: state.axes[axis.name] ?? [],
+    })));
+}
+/** Product inputs plus the per-cell inputs the extensions add. */
+export function gridParts(active) {
+    return {
+        productFields: active.form.fields,
+        cellFields: active.extensions.flatMap((ext) => ext.fields ?? []),
+        cellRecords: active.extensions.flatMap((ext) => ext.records ?? []),
+    };
+}
+/** Product inputs with the catalog field they map onto, for rendering. */
+export function gridProductInputs(active, models) {
+    return active.form.fields.map((field) => ({
+        field,
+        catalogField: targetField(field, [active.form.product], models),
+    }));
+}
+/** Cell inputs with the catalog field they map onto. */
+export function gridCellInputs(active, models) {
+    const { cellFields, cellRecords } = gridParts(active);
+    const records = [skuRecord(active.form), ...cellRecords];
+    return cellFields.map((field) => ({
+        field,
+        catalogField: targetField(field, records, models),
+    }));
+}
+const skuRecord = (form) => ({
+    as: 'sku',
+    model: form.skus,
+});
+/** An empty grid: starting values for the product inputs and every axis. */
+export function blankGrid(active, models) {
+    return {
+        values: Object.fromEntries(gridProductInputs(active, models).map(({ field, catalogField }) => [
+            field.id,
+            startingValue(field, catalogField),
+        ])),
+        axes: Object.fromEntries(active.form.axes.map((axis) => [axis.name, [...axis.values]])),
+        cells: {},
+    };
+}
+/** The starting inputs of one cell. */
+export function blankCell(active, models) {
+    return Object.fromEntries(gridCellInputs(active, models).map(({ field, catalogField }) => [
+        field.id,
+        startingValue(field, catalogField),
+    ]));
+}
+/** Parse a JSON-string field (`allowedValues`, `attributes`), leniently. */
+export function parseJson(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function attributesOf(sku) {
+    const parsed = parseJson(sku.attributes);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : {};
+}
+function skuKey(form, sku) {
+    const attributes = attributesOf(sku);
+    const parts = form.axes
+        .filter((axis) => axis.name in attributes)
+        .map((axis) => String(attributes[axis.name]));
+    return parts.length ? comboKey(parts) : undefined;
+}
+/** Load an existing product into a grid: its axes, then a cell per Sku. */
+export async function loadGrid(source, active, models, productId) {
+    const { form } = active;
+    const product = await source.get(models(form.product.model), productId);
+    if (!product)
+        return undefined;
+    const variants = (await source.list(models(form.variants))).filter((row) => row.productId === productId);
+    const skus = (await source.list(models(form.skus))).filter((row) => row.productId === productId);
+    const state = blankGrid(active, models);
+    for (const input of gridProductInputs(active, models)) {
+        const { field } = parseTarget(input.field.to);
+        const value = product[field];
+        if (value !== undefined)
+            state.values[input.field.id] = value;
+    }
+    for (const axis of form.axes) {
+        const row = variants.find((v) => v.axisName === axis.name);
+        const stored = parseJson(row?.allowedValues);
+        state.axes[axis.name] = row
+            ? Array.isArray(stored)
+                ? cleanValues(stored.map(String))
+                : []
+            : [];
+    }
+    const { cellFields, cellRecords } = gridParts(active);
+    const blank = blankCell(active, models);
+    for (const sku of skus) {
+        const key = skuKey(form, sku);
+        if (!key)
+            continue;
+        const rows = await findRows(source, [skuRecord(form), ...cellRecords], { product, sku }, models);
+        state.cells[key] = Object.fromEntries(cellFields.map((field) => {
+            const { alias, field: name } = parseTarget(field.to);
+            const value = rows[alias]?.[name];
+            return [field.id, value === undefined ? blank[field.id] : value];
+        }));
+    }
+    return { state, existing: { productId, variants, skus } };
+}
+/** The Sku code of a new cell: product, then each value, upper-cased. */
+export function skuCode(productName, combo) {
+    return [slug(productName) || 'SKU', ...combo.values.map(slug)]
+        .filter(Boolean)
+        .join('-');
+}
+/**
+ * The related writes that save a variant grid: the product, one
+ * `ProductVariant` per axis that has values (and a delete for one that no
+ * longer does), a `Sku` per combination with its `attributes` pinned (Skus of
+ * combinations that went away are deleted with the rows the extensions keep
+ * under them), then each extension's rows per cell. Pure; `apply` runs it
+ * all or nothing.
+ */
+export function planGridSave(active, models, state, existing) {
+    const { form } = active;
+    const { cellFields, cellRecords } = gridParts(active);
+    const writes = [];
+    const productContext = contextFrom(form.fields, state.values);
+    const productValues = mappedValues(form.fields, form.product.as, state.values);
+    writes.push({
+        op: 'save',
+        as: 'product',
+        model: models(form.product.model),
+        ...(existing ? { id: existing.productId } : {}),
+        onCreate: toWriteValues(form.product.values, productContext),
+        values: productValues,
+    });
+    const variantModel = models(form.variants);
+    form.axes.forEach((axis, index) => {
+        const values = cleanValues(state.axes[axis.name] ?? []);
+        const match = { productId: { ref: 'product' }, axisName: axis.name };
+        if (values.length === 0) {
+            writes.push({ op: 'delete', model: variantModel, match });
+            return;
+        }
+        writes.push({
+            op: 'save',
+            model: variantModel,
+            match,
+            onCreate: { label: axis.label.replace(/s$/i, '') },
+            values: { allowedValues: JSON.stringify(values), sortOrder: index },
+        });
+    });
+    const skuModel = models(form.skus);
+    const combos = gridCombos(form, state);
+    const wanted = new Set(combos.map((c) => c.key));
+    const byKey = new Map((existing?.skus ?? []).flatMap((sku) => {
+        const key = skuKey(form, sku);
+        return key ? [[key, sku]] : [];
+    }));
+    // Skus whose combination left the grid go, with what hangs off them.
+    for (const sku of existing?.skus ?? []) {
+        const key = skuKey(form, sku);
+        if (key && wanted.has(key))
+            continue;
+        for (const record of cellRecords) {
+            const match = Object.fromEntries(Object.entries(record.match ?? {}).flatMap(([field, value]) => typeof value === 'object' && value?.ref === 'sku'
+                ? [[field, sku.id]]
+                : []));
+            if (Object.keys(match).length) {
+                writes.push({ op: 'delete', model: models(record.model), match });
+            }
+        }
+        writes.push({ op: 'delete', model: skuModel, id: sku.id });
+    }
+    const productName = productContext['product.name'];
+    // Codes stay unique in the plan: values that slug alike get a numeric suffix
+    // instead of being found-and-merged as one Sku.
+    const usedCodes = new Set((existing?.skus ?? [])
+        .filter((row) => wanted.has(skuKey(form, row) ?? ''))
+        .map((row) => String(row.code ?? '')));
+    combos.forEach((combo, i) => {
+        const current = byKey.get(combo.key);
+        const label = combo.values.join(' / ');
+        const name = `${String(productName ?? '').trim() || 'Item'} (${label})`;
+        const baseCode = skuCode(productName, combo);
+        let code = baseCode;
+        for (let n = 2; !current && usedCodes.has(code); n++) {
+            code = `${baseCode}-${n}`;
+        }
+        usedCodes.add(code);
+        const skuAlias = `sku#${i}`;
+        const values = {
+            name,
+            attributes: JSON.stringify(combo.attributes),
+        };
+        writes.push(current
+            ? { op: 'save', as: skuAlias, model: skuModel, id: current.id, values }
+            : {
+                op: 'save',
+                as: skuAlias,
+                model: skuModel,
+                match: { productId: { ref: 'product' }, code },
+                onCreate: { active: true },
+                values,
+            });
+        const cell = {
+            ...blankCell(active, models),
+            ...(state.cells[combo.key] ?? {}),
+        };
+        const rename = (alias) => alias === 'product'
+            ? alias
+            : alias === 'sku'
+                ? skuAlias
+                : `${alias}#${i}`;
+        const context = {
+            ...productContext,
+            'sku.name': name,
+            'sku.code': current ? String(current.code ?? code) : code,
+        };
+        for (const record of cellRecords) {
+            const mapped = mappedValues(cellFields, record.as, cell);
+            writes.push({
+                op: 'save',
+                as: rename(record.as),
+                model: models(record.model),
+                ...(record.match
+                    ? { match: toWriteValues(record.match, context, rename) }
+                    : {}),
+                onCreate: toWriteValues(record.values, context, rename),
+                values: mapped,
+            });
+        }
+    });
+    return writes;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * smrt planner as a package: mount the `Planner` component in a host layout,
+ * drive it with the typed command set (`./commands` has no UI in it), and read
+ * its plan as a compact snapshot.
+ *
+ * @module
+ */
+export { type ByoPresetDefinition, type ConfigResult, type CredentialPersistence, type InferenceConfig, type InferenceMode, loadInferenceConfig, parseInferenceConfig, } from './inference/config.ts';
+export { createHostChat, type HostChatOptions, type HostRequest, } from './inference/host.ts';
+export { createOpenAIChat, testConnection } from './inference/openai.ts';
+export { type KitchenConfig, type KitchenEndpoint, type KitchenOutcome, type KitchenResult, parseKitchenConfig, sendToKitchen, } from './kitchen/client.ts';
+export { KITCHEN_FRAGMENT_KEY, type KitchenFragment, readKitchenFragment, } from './kitchen/fragment.ts';
+export { createPlannerAssistant, type PlannerAssistant, type PlannerChatInference, type PlannerConfigInference, type PlannerInference, } from './planner/assistant.ts';
+export * from './planner/commands/index.ts';
+export { plannerController } from './planner/instance.ts';
+export { default as Planner } from './planner/Planner.svelte';
+export type { PlannerHandle, PlannerProps } from './planner/types.ts';

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * smrt planner as a package: mount the `Planner` component in a host layout,
+ * drive it with the typed command set (`./commands` has no UI in it), and read
+ * its plan as a compact snapshot.
+ *
+ * @module
+ */
+export { loadInferenceConfig, parseInferenceConfig, } from "./inference/config.js";
+export { createHostChat, } from "./inference/host.js";
+export { createOpenAIChat, testConnection } from "./inference/openai.js";
+export { parseKitchenConfig, sendToKitchen, } from "./kitchen/client.js";
+export { KITCHEN_FRAGMENT_KEY, readKitchenFragment, } from "./kitchen/fragment.js";
+export { createPlannerAssistant, } from "./planner/assistant.js";
+export * from "./planner/commands/index.js";
+export { plannerController } from "./planner/instance.js";
+export { default as Planner } from './planner/Planner.svelte';

package/dist/inference/byo.svelte.d.ts

@@ -0,0 +1,90 @@
+import type { ChatModel } from '../assistant/transport.ts';
+import type { ByoPresetDefinition, CredentialPersistence } from './config.ts';
+import { type ConnectionResult } from './openai.ts';
+/** Choices (not the key): which endpoint, its address and model, and whether it is in use. */
+export declare const BYO_PREFS_KEY = "smrt-planner:inference:v1";
+/** The keys, apart from the choices so nothing that copies prefs copies a key. */
+export declare const BYO_KEYS_KEY = "smrt-planner:inference-key:v1";
+export interface ByoEntry {
+    baseUrl: string;
+    model: string;
+}
+interface ByoPrefs {
+    preset: string;
+    active: boolean;
+    entries: Record<string, ByoEntry>;
+}
+export declare function loadByoPrefs(storage: Storage | null): ByoPrefs;
+/** A saved key and the origin (scheme, host, port) it was entered for. */
+export interface ByoKey {
+    origin: string;
+    key: string;
+}
+export declare function loadByoKeys(storage: Storage | null): Record<string, ByoKey>;
+export type ByoTestStatus = 'idle' | 'testing' | 'ok' | 'failed';
+export interface ByoOptions {
+    storage: Storage | null;
+    /** Credentials default to local storage for compatibility; hosted apps use memory. */
+    credentialPersistence?: CredentialPersistence;
+    /** The config's `byo.presets`; default all built-ins. */
+    presets?: readonly (string | ByoPresetDefinition)[];
+    fetch?: typeof fetch;
+    /** Called after "use" or "stop using", so the assistant follows. */
+    onChange?: () => void;
+}
+/**
+ * The visitor's own OpenAI-compatible endpoint: the preset they picked, its
+ * address, model and key, a connection test, and whether the assistant uses
+ * it. The key lives in the configured credential store (tab memory for hosted
+ * policies, localStorage for the compatible standalone default) and is only
+ * ever sent as the Authorization header to the chosen address.
+ */
+export declare class ByoModel {
+    readonly presets: ByoPresetDefinition[];
+    presetId: string;
+    entries: Record<string, ByoEntry>;
+    keys: Record<string, ByoKey>;
+    active: boolean;
+    testStatus: ByoTestStatus;
+    testMessage: string;
+    private readonly options;
+    private readonly credentialStorage;
+    constructor(options: ByoOptions);
+    get preset(): ByoPresetDefinition | undefined;
+    get baseUrl(): string;
+    get model(): string;
+    /**
+     * The saved key, only while the address is the origin it was entered for:
+     * changing the address (or a config that reuses a preset id for another
+     * address) never sends the key somewhere new.
+     */
+    get key(): string;
+    /** A key is saved for this preset, but for another address. */
+    get keyForOtherAddress(): boolean;
+    /** Address valid, model named, and a key where the preset needs one (sendable there). */
+    get complete(): boolean;
+    select(id: string): void;
+    setBaseUrl(baseUrl: string): void;
+    setModel(model: string): void;
+    setKey(key: string): void;
+    /** Remove the saved key for the selected preset. */
+    forgetKey(): void;
+    /** The chat model for what is entered, or null while it is incomplete. */
+    chat(): ChatModel | null;
+    test(): Promise<ConnectionResult>;
+    /** Make the assistant use this endpoint. */
+    use(): boolean;
+    /** Stop using it; the entered values stay. */
+    stop(): void;
+    private resetTest;
+    /** An edit invalidates the last test and, if in use, what is in use. */
+    private edited;
+    private save;
+}
+/**
+ * The chat model for the endpoint a visitor already connected in this browser
+ * (a mounted `Planner` in byo mode has no AI page of its own). Null when none
+ * is connected or what was saved is incomplete.
+ */
+export declare function savedByoChat(storage: Storage | null, presets?: readonly (string | ByoPresetDefinition)[], fetcher?: typeof fetch, credentialPersistence?: CredentialPersistence): ChatModel | null;
+export {};