@jsm-mit/sultana-agent-tools-package 0.2.0

package/dist/tools/promos.js

@@ -0,0 +1,438 @@
+import { MAX_ACTIVE_PROMOS_PER_SALON, MAX_PROMOS_PER_SALON } from "@jsm-mit/sultana-core-motoko-package";
+import { toToolError } from "../errors.js";
+import { err, needsConfirmation, ok } from "../types.js";
+import { ArgumentError, phrasesMatch, readBoolean, readOptionalNumber, readOptionalString, readOptionalStringArray, readString, } from "./args.js";
+const MAX_PROMO_NAME_LENGTH = 60;
+const MAX_TEXT_LINES = 2;
+const MAX_CHIPS = 2;
+const CONFIRMED_FIELD = {
+    type: "boolean",
+    description: "false dla podglądu: narzędzie nic nie zapisze i odda opis zmiany do zatwierdzenia przez właściciela. true dopiero po potwierdzeniu.",
+};
+export function createPromoTools(port) {
+    return [
+        listMediaTool(port),
+        listPromosTool(port),
+        addPromoTool(port),
+        updatePromoTool(port),
+        setPromoActiveTool(port),
+        removePromoTool(port),
+        listDiscountCodesTool(port),
+        addDiscountCodeTool(port),
+        removeDiscountCodeTool(port),
+    ];
+}
+function listMediaTool(port) {
+    return {
+        name: "list_media",
+        progress: "Sprawdzam bibliotekę materiałów…",
+        description: "Zwraca gotowe materiały z biblioteki salonu (zdjęcia i filmy) wraz z ich assetId. Promocję da się założyć wyłącznie na takim materiale — bez niego trzeba poprosić właściciela o wgranie pliku w panelu.",
+        parameters: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+            try {
+                const media = (await port.listMedia()).filter((item) => item.kind !== "audio");
+                if (media.length === 0) {
+                    return ok("Biblioteka salonu jest pusta — nie ma na czym założyć promocji. Poproś właściciela o wgranie zdjęcia lub filmu w panelu.", []);
+                }
+                return ok(`W bibliotece jest ${media.length} materiał(ów).`, media);
+            }
+            catch (error) {
+                return toToolError(error, "Nie udało się odczytać biblioteki materiałów.");
+            }
+        },
+    };
+}
+/** As with services: a public read holds no drafts, so its texts must not speak of a library the
+ * model cannot see. */
+const LIST_PROMOS_TEXT = {
+    owner: {
+        description: "Zwraca promocje salonu: id, nazwę, czy jest aktywna, materiał, teksty i kod rabatowy.",
+        empty: "Salon nie ma jeszcze żadnej promocji.",
+        count: (promos) => {
+            const active = promos.filter((promo) => promo.active).length;
+            return `Salon ma ${promos.length} promocji (limit ${MAX_PROMOS_PER_SALON}), aktywnych ${active} z ${MAX_ACTIVE_PROMOS_PER_SALON}.`;
+        },
+    },
+    public: {
+        description: "Zwraca AKTYWNE promocje salonu — te, które widać w kanale: id, nazwę, materiał, teksty i kod rabatowy. Wyłączonych promocji tu nie ma.",
+        empty: "Salon nie ma żadnej aktywnej promocji.",
+        count: (promos) => `Aktywne promocje salonu: ${promos.length}.`,
+    },
+};
+/** `access` must match the port: `"public"` only for a port read anonymously, because the canister
+ * gives the salon's owner the whole library whatever the port calls. */
+export function listPromosTool(port, access = "owner") {
+    const text = LIST_PROMOS_TEXT[access];
+    return {
+        name: "list_promos",
+        progress: "Sprawdzam promocje…",
+        description: text.description,
+        parameters: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+            try {
+                const promos = await port.listPromos();
+                if (promos.length === 0)
+                    return ok(text.empty, []);
+                return ok(text.count(promos), promos);
+            }
+            catch (error) {
+                return toToolError(error, "Nie udało się odczytać promocji.");
+            }
+        },
+    };
+}
+function addPromoTool(port) {
+    return {
+        name: "add_promo",
+        progress: "Zakładam promocję…",
+        description: "Zakłada nową promocję na materiale z biblioteki. Najpierw wywołaj list_media i wybierz assetId. Nowa promocja jest nieaktywna — włącz ją potem przez set_promo_active.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: `Nazwa kampanii, maksymalnie ${MAX_PROMO_NAME_LENGTH} znaków.` },
+                assetId: { type: "string", description: "Id materiału z list_media (zdjęcie albo film)." },
+                textLines: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: `Do ${MAX_TEXT_LINES} linii tekstu na materiale.`,
+                },
+                chips: { type: "array", items: { type: "string" }, description: `Do ${MAX_CHIPS} krótkich etykiet.` },
+                buttonLabel: { type: "string", description: "Napis na przycisku. Pominięty — domyślny napis aplikacji." },
+                discountCode: { type: "string", description: "Kod rabatowy salonu do rozgłoszenia. Musi już istnieć." },
+                targetServiceId: { type: "string", description: "Usługa, do której prowadzi kliknięcie. Pominięta — cały salon." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["name", "assetId", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const input = await buildPromoInput(port, args, null);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Założę promocję ${await describePromo(port, input)}.`, { ...args, confirmed: true });
+                }
+                const promoId = await port.addPromo(input);
+                return ok(`Założono promocję „${input.name}”. Jest jeszcze nieaktywna.`, { promoId });
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się założyć promocji.");
+            }
+        },
+    };
+}
+function updatePromoTool(port) {
+    return {
+        name: "update_promo",
+        progress: "Zmieniam promocję…",
+        description: "Zmienia istniejącą promocję. Podaj tylko pola, które mają się zmienić — reszta zostanie zachowana. Promocja zachowuje swoje miejsce w kanale, więc poprawka nie restartuje kampanii.",
+        parameters: {
+            type: "object",
+            properties: {
+                promoId: { type: "string", description: "Id promocji z list_promos." },
+                name: { type: "string", description: "Nowa nazwa kampanii." },
+                assetId: { type: "string", description: "Nowy materiał z list_media." },
+                textLines: { type: "array", items: { type: "string" }, description: "Nowe linie tekstu." },
+                chips: { type: "array", items: { type: "string" }, description: "Nowe etykiety." },
+                buttonLabel: { type: "string", description: "Nowy napis na przycisku." },
+                discountCode: { type: "string", description: "Nowy kod rabatowy." },
+                targetServiceId: { type: "string", description: "Nowy cel kliknięcia." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["promoId", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const promoId = readString(args, "promoId");
+                const current = await findPromo(port, promoId);
+                if (!current)
+                    return err("not_found", `W tym salonie nie ma promocji o id ${promoId}.`);
+                const input = await buildPromoInput(port, args, current);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Zmienię promocję „${current.name}” na: ${await describePromo(port, input)}.`, {
+                        ...args,
+                        confirmed: true,
+                    });
+                }
+                await port.updatePromo(promoId, input);
+                return ok(`Zmieniono promocję „${input.name}”.`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się zmienić promocji.");
+            }
+        },
+    };
+}
+function setPromoActiveTool(port) {
+    return {
+        name: "set_promo_active",
+        progress: "Zmieniam status promocji…",
+        description: `Włącza promocję w kanale albo ją wyłącza. Naraz może być aktywnych najwyżej ${MAX_ACTIVE_PROMOS_PER_SALON} — żeby włączyć kolejną, najpierw wyłącz inną.`,
+        parameters: {
+            type: "object",
+            properties: {
+                promoId: { type: "string", description: "Id promocji z list_promos." },
+                active: { type: "boolean", description: "true włącza, false wyłącza." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["promoId", "active", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const promoId = readString(args, "promoId");
+                const current = await findPromo(port, promoId);
+                if (!current)
+                    return err("not_found", `W tym salonie nie ma promocji o id ${promoId}.`);
+                const active = readBoolean(args, "active");
+                const verb = active ? "włączę" : "wyłączę";
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`${verb[0].toUpperCase()}${verb.slice(1)} promocję „${current.name}”.`, {
+                        ...args,
+                        confirmed: true,
+                    });
+                }
+                await port.setPromoActive(promoId, active);
+                return ok(`Promocja „${current.name}” jest teraz ${active ? "aktywna" : "wyłączona"}.`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się zmienić statusu promocji.");
+            }
+        },
+    };
+}
+function removePromoTool(port) {
+    return {
+        name: "remove_promo",
+        progress: "Kasuję promocję…",
+        description: "Kasuje promocję z biblioteki. Nieodwracalne — właściciel musi przepisać jej nazwę w confirmationPhrase. Żeby tylko zdjąć ją z kanału, użyj set_promo_active.",
+        parameters: {
+            type: "object",
+            properties: {
+                promoId: { type: "string", description: "Id promocji z list_promos." },
+                confirmationPhrase: { type: "string", description: "Dokładna nazwa kasowanej promocji." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["promoId", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const promoId = readString(args, "promoId");
+                const current = await findPromo(port, promoId);
+                if (!current)
+                    return err("not_found", `W tym salonie nie ma promocji o id ${promoId}.`);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Skasuję promocję „${current.name}”. Tego nie da się cofnąć — poproś właściciela o przepisanie nazwy. Jeśli chodzi tylko o zdjęcie z kanału, lepiej ją wyłączyć.`, { promoId, confirmationPhrase: current.name, confirmed: true });
+                }
+                const phrase = readOptionalString(args, "confirmationPhrase");
+                if (!phrase || !phrasesMatch(phrase, current.name)) {
+                    return err("invalid_arguments", `Aby skasować promocję, właściciel musi przepisać jej nazwę: „${current.name}”.`);
+                }
+                await port.removePromo(promoId);
+                return ok(`Skasowano promocję „${current.name}”.`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się skasować promocji.");
+            }
+        },
+    };
+}
+function listDiscountCodesTool(port) {
+    return {
+        name: "list_discount_codes",
+        progress: "Sprawdzam kody rabatowe…",
+        description: "Zwraca kody rabatowe salonu: treść kodu, wartość i zasięg.",
+        parameters: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+            try {
+                const codes = await port.listDiscountCodes();
+                if (codes.length === 0)
+                    return ok("Salon nie ma jeszcze żadnego kodu rabatowego.", []);
+                return ok(`Salon ma ${codes.length} kod(ów) rabatowych.`, codes);
+            }
+            catch (error) {
+                return toToolError(error, "Nie udało się odczytać kodów rabatowych.");
+            }
+        },
+    };
+}
+function addDiscountCodeTool(port) {
+    return {
+        name: "add_discount_code",
+        progress: "Dodaję kod rabatowy…",
+        description: "Dodaje kod rabatowy salonu. Podaj albo percent, albo amountPln — nie oba. Kod nie ma daty ważności ani limitu użyć; działa, dopóki go nie usuniesz.",
+        parameters: {
+            type: "object",
+            properties: {
+                code: { type: "string", description: "Treść kodu, którą wpisze klientka." },
+                percent: { type: "integer", description: "Rabat procentowy, 1-100." },
+                amountPln: { type: "integer", description: "Rabat kwotowy w pełnych złotych." },
+                scopeServiceId: { type: "string", description: "Ogranicz kod do jednej usługi. Pominięty — cały salon." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["code", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const code = readString(args, "code");
+                const percent = readOptionalNumber(args, "percent");
+                const amountPln = readOptionalNumber(args, "amountPln");
+                if ((percent === undefined) === (amountPln === undefined)) {
+                    throw new ArgumentError("Podaj dokładnie jedno: percent albo amountPln.");
+                }
+                if (percent !== undefined && (!Number.isInteger(percent) || percent < 1 || percent > 100)) {
+                    throw new ArgumentError("Rabat procentowy musi być liczbą całkowitą z zakresu 1-100.");
+                }
+                if (amountPln !== undefined && (!Number.isInteger(amountPln) || amountPln < 1)) {
+                    throw new ArgumentError("Rabat kwotowy musi być dodatnią liczbą całkowitą złotych.");
+                }
+                const scopeServiceId = readOptionalString(args, "scopeServiceId");
+                await assertKnownService(port, scopeServiceId);
+                const value = percent !== undefined ? `${percent}%` : `${amountPln} zł`;
+                const scope = scopeServiceId ? "na jedną usługę" : "na cały salon";
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Dodam kod rabatowy „${code}”: ${value}, ${scope}.`, { ...args, confirmed: true });
+                }
+                await port.addDiscountCode({ code, percent, amountPln, scopeServiceId });
+                return ok(`Dodano kod rabatowy „${code}” (${value}, ${scope}).`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się dodać kodu rabatowego.");
+            }
+        },
+    };
+}
+function removeDiscountCodeTool(port) {
+    return {
+        name: "remove_discount_code",
+        progress: "Usuwam kod rabatowy…",
+        description: "Usuwa kod rabatowy salonu. Kanister odmówi, dopóki jakakolwiek promocja ten kod rozgłasza — wtedy najpierw zmień promocję.",
+        parameters: {
+            type: "object",
+            properties: {
+                code: { type: "string", description: "Treść kodu z list_discount_codes." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["code", "confirmed"],
+            additionalProperties: false,
+        },
+        // No confirmation phrase here, unlike a service or a promo: a removed code can simply be
+        // added back with the same text, and nothing else in the salon points at it.
+        execute: async (args) => {
+            try {
+                const code = readString(args, "code");
+                const codes = await port.listDiscountCodes();
+                if (!codes.some((entry) => entry.code === code))
+                    return err("not_found", `Salon nie ma kodu „${code}”.`);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Usunę kod rabatowy „${code}”.`, { ...args, confirmed: true });
+                }
+                await port.removeDiscountCode(code);
+                return ok(`Usunięto kod rabatowy „${code}”.`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się usunąć kodu rabatowego.");
+            }
+        },
+    };
+}
+/**
+ * Builds the whole promo record. As with a service, `updatePromo` replaces everything — including
+ * the music render — so an edit merges onto the current promo and carries `music` through
+ * untouched.
+ */
+async function buildPromoInput(port, args, current) {
+    const name = current ? (readOptionalString(args, "name") ?? current.name) : readString(args, "name");
+    if (name.length > MAX_PROMO_NAME_LENGTH) {
+        throw new ArgumentError(`Nazwa promocji może mieć najwyżej ${MAX_PROMO_NAME_LENGTH} znaków.`);
+    }
+    const assetId = current ? (readOptionalString(args, "assetId") ?? current.assetId) : readString(args, "assetId");
+    await assertUsableMedia(port, assetId, current?.assetId);
+    // A music promo's media IS the render made from its source; swapping it would leave the music
+    // record pointing at a different asset, which the canister then refuses. Say so plainly
+    // instead of letting the owner discover it as a validation error.
+    if (current?.hasMusic && assetId !== current.assetId) {
+        throw new ArgumentError("Ta promocja jest zmontowana z muzyką — materiału nie da się podmienić w rozmowie. Zrób to w panelu.");
+    }
+    const textLines = readOptionalStringArray(args, "textLines") ?? current?.textLines ?? [];
+    if (textLines.length > MAX_TEXT_LINES)
+        throw new ArgumentError(`Promocja może mieć najwyżej ${MAX_TEXT_LINES} linie tekstu.`);
+    const chips = readOptionalStringArray(args, "chips") ?? current?.chips ?? [];
+    if (chips.length > MAX_CHIPS)
+        throw new ArgumentError(`Promocja może mieć najwyżej ${MAX_CHIPS} etykiety.`);
+    const buttonLabel = readOptionalString(args, "buttonLabel") ?? current?.buttonLabel;
+    const discountCode = readOptionalString(args, "discountCode") ?? current?.discountCode;
+    await assertKnownDiscountCode(port, discountCode, current?.discountCode);
+    const targetServiceId = readOptionalString(args, "targetServiceId") ?? current?.targetServiceId;
+    await assertKnownService(port, targetServiceId);
+    // `music` is never model-visible; it is read back from the current promo so an edit cannot
+    // silently undo a render.
+    return { name, assetId, textLines, chips, buttonLabel, discountCode, targetServiceId, music: current?.music };
+}
+async function assertUsableMedia(port, assetId, currentAssetId) {
+    if (assetId === currentAssetId)
+        return;
+    const media = await port.listMedia();
+    const asset = media.find((item) => item.assetId === assetId);
+    if (!asset) {
+        throw new ArgumentError(`W bibliotece salonu nie ma gotowego materiału o id ${assetId}. Użyj list_media.`);
+    }
+    if (asset.kind === "audio")
+        throw new ArgumentError("Promocji nie da się założyć na ścieżce dźwiękowej — wybierz zdjęcie albo film.");
+}
+async function assertKnownDiscountCode(port, code, currentCode) {
+    if (code === undefined || code === currentCode)
+        return;
+    const codes = await port.listDiscountCodes();
+    if (!codes.some((entry) => entry.code === code)) {
+        throw new ArgumentError(`Salon nie ma kodu rabatowego „${code}”. Najpierw dodaj go przez add_discount_code.`);
+    }
+}
+async function assertKnownService(port, serviceId) {
+    if (serviceId === undefined)
+        return;
+    const services = await port.listServices();
+    if (!services.some((service) => service.id === serviceId)) {
+        throw new ArgumentError(`W tym salonie nie ma usługi o id ${serviceId}. Użyj list_services.`);
+    }
+}
+async function describePromo(port, input) {
+    const media = await port.listMedia();
+    const asset = media.find((item) => item.assetId === input.assetId);
+    const parts = [`„${input.name}”`, `materiał: ${asset ? asset.name : input.assetId}`];
+    if (input.textLines.length > 0)
+        parts.push(`tekst: ${input.textLines.join(" / ")}`);
+    if (input.chips.length > 0)
+        parts.push(`etykiety: ${input.chips.join(", ")}`);
+    if (input.buttonLabel)
+        parts.push(`przycisk: ${input.buttonLabel}`);
+    if (input.discountCode)
+        parts.push(`kod: ${input.discountCode}`);
+    if (input.targetServiceId) {
+        const services = await port.listServices();
+        const service = services.find((candidate) => candidate.id === input.targetServiceId);
+        parts.push(`prowadzi do usługi: ${service ? service.name : input.targetServiceId}`);
+    }
+    else {
+        parts.push("prowadzi do salonu");
+    }
+    return parts.join(", ");
+}
+async function findPromo(port, promoId) {
+    const promos = await port.listPromos();
+    return promos.find((promo) => promo.id === promoId) ?? null;
+}

package/dist/tools/schedule.d.ts

@@ -0,0 +1,4 @@
+import type { SalonCorePort } from "../salon-core-port.js";
+import { type AgentTool } from "../types.js";
+export declare function createScheduleTools(port: SalonCorePort): AgentTool[];
+//# sourceMappingURL=schedule.d.ts.map

package/dist/tools/schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule.d.ts","sourceRoot":"","sources":["../../src/tools/schedule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAyB,MAAM,uBAAuB,CAAC;AAClF,OAAO,EAA8B,KAAK,SAAS,EAAmB,MAAM,aAAa,CAAC;AAqB1F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,CASpE"}