@fraza/module-ai 0.0.0-stage → 0.4.22

package/dist/schema.js

@@ -0,0 +1,190 @@
+const TYPES = /* @__PURE__ */ new Set(["object", "string", "number", "integer", "boolean", "array", "null"]);
+const COMMON_KEYS = ["type", "title", "description"];
+const ALLOWED_KEYS = {
+  object: /* @__PURE__ */ new Set([...COMMON_KEYS, "properties", "required", "additionalProperties"]),
+  string: /* @__PURE__ */ new Set([...COMMON_KEYS, "enum", "maxLength", "format"]),
+  number: new Set(COMMON_KEYS),
+  integer: new Set(COMMON_KEYS),
+  boolean: new Set(COMMON_KEYS),
+  array: /* @__PURE__ */ new Set([...COMMON_KEYS, "items", "minItems", "maxItems"]),
+  null: new Set(COMMON_KEYS)
+};
+const MAX_DEPTH = 8;
+const KEPT_CONSTRAINTS = {
+  anthropic: /* @__PURE__ */ new Set(),
+  openai: /* @__PURE__ */ new Set(["minItems", "maxItems"]),
+  "openai-compatible": /* @__PURE__ */ new Set(),
+  google: /* @__PURE__ */ new Set(["minItems", "maxItems", "maxLength"]),
+  mistral: /* @__PURE__ */ new Set(),
+  ollama: /* @__PURE__ */ new Set(["minItems", "maxItems", "maxLength"])
+};
+const CONSTRAINTS = ["maxLength", "minItems", "maxItems"];
+const FORMATS = /* @__PURE__ */ new Set(["html"]);
+function typesOf(node) {
+  return Array.isArray(node.type) ? node.type : [node.type];
+}
+function mainType(node) {
+  return typesOf(node).find((type) => type !== "null") ?? "null";
+}
+function isNonNegativeInteger(value) {
+  return Number.isInteger(value) && value >= 0;
+}
+function typeProblems(node, at) {
+  const types = typesOf(node);
+  if (types.length === 0 || types.some((type) => !TYPES.has(type))) {
+    return [`${at}: type must be one of ${[...TYPES].join(", ")}`];
+  }
+  if (types.length > 2 || types.length === 2 && !types.includes("null") || new Set(types).size !== types.length) {
+    return [`${at}: a type array is a type and null, e.g. ['string', 'null']`];
+  }
+  return [];
+}
+function objectProblems(node, at, depth) {
+  const problems = [];
+  if (node.additionalProperties !== void 0 && node.additionalProperties !== false) {
+    problems.push(`${at}: additionalProperties may only be false`);
+  }
+  if (!node.properties || typeof node.properties !== "object" || Array.isArray(node.properties)) {
+    return [...problems, `${at}: an object needs its properties`];
+  }
+  const keys = Object.keys(node.properties);
+  if (keys.length === 0) problems.push(`${at}: an object needs at least one property`);
+  const required = node.required ?? [];
+  if (!Array.isArray(required) || keys.some((key) => !required.includes(key)) || required.some((key) => !keys.includes(key))) {
+    problems.push(`${at}: every property is listed in required; an optional value is a type with null`);
+  }
+  for (const key of keys) problems.push(...nodeProblems(node.properties[key], `${at}.${key}`, depth + 1));
+  return problems;
+}
+function stringProblems(node, at) {
+  const problems = [];
+  if (node.enum !== void 0) {
+    if (!Array.isArray(node.enum) || node.enum.length === 0 || node.enum.some((v) => typeof v !== "string")) {
+      problems.push(`${at}: enum is a non-empty array of strings`);
+    }
+  }
+  if (node.maxLength !== void 0 && !(Number.isInteger(node.maxLength) && node.maxLength > 0)) {
+    problems.push(`${at}: maxLength is a positive integer`);
+  }
+  if (node.format !== void 0 && !FORMATS.has(node.format)) problems.push(`${at}: format may only be 'html'`);
+  if (node.format !== void 0 && node.enum !== void 0) problems.push(`${at}: an enum has no format`);
+  return problems;
+}
+function arrayProblems(node, at, depth) {
+  const problems = [];
+  if (!node.items || typeof node.items !== "object" || Array.isArray(node.items)) {
+    return [`${at}: an array needs its items schema`];
+  }
+  for (const key of ["minItems", "maxItems"]) {
+    if (node[key] !== void 0 && !isNonNegativeInteger(node[key])) problems.push(`${at}: ${key} is a non-negative integer`);
+  }
+  if (isNonNegativeInteger(node.minItems) && isNonNegativeInteger(node.maxItems) && node.minItems > node.maxItems) {
+    problems.push(`${at}: minItems is above maxItems`);
+  }
+  problems.push(...nodeProblems(node.items, `${at}[]`, depth + 1));
+  return problems;
+}
+function nodeProblems(node, at, depth) {
+  if (depth > MAX_DEPTH) return [`${at}: the schema is nested more than ${MAX_DEPTH} levels`];
+  if (!node || typeof node !== "object" || Array.isArray(node)) return [`${at}: a schema is an object`];
+  const typeIssues = typeProblems(node, at);
+  if (typeIssues.length > 0) return typeIssues;
+  const type = mainType(node);
+  const unknown = Object.keys(node).filter((key) => !ALLOWED_KEYS[type].has(key));
+  if (unknown.length > 0) return [`${at}: ${unknown.join(", ")} is not supported on a ${type}`];
+  for (const key of ["title", "description"]) {
+    if (node[key] !== void 0 && typeof node[key] !== "string") return [`${at}: ${key} is a string`];
+  }
+  if (type === "object") return objectProblems(node, at, depth);
+  if (type === "string") return stringProblems(node, at);
+  if (type === "array") return arrayProblems(node, at, depth);
+  return [];
+}
+function checkSchema(schema, label = "schema") {
+  const problems = nodeProblems(schema, label, 0);
+  if (problems.length === 0 && mainType(schema) !== "object") problems.push(`${label}: the root of a schema is an object`);
+  if (problems.length > 0) throw new TypeError(`Invalid AI schema:
+  - ${problems.join("\n  - ")}`);
+}
+function constraintHint(node) {
+  const hints = [];
+  if (node.minItems !== void 0 && node.minItems === node.maxItems) hints.push(`Exactly ${node.minItems} items.`);
+  else {
+    if (node.minItems !== void 0) hints.push(`At least ${node.minItems} items.`);
+    if (node.maxItems !== void 0) hints.push(`At most ${node.maxItems} items.`);
+  }
+  if (node.maxLength !== void 0) hints.push(`At most ${node.maxLength} characters.`);
+  return hints.join(" ");
+}
+function normalizeNode(node, kept) {
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (CONSTRAINTS.includes(key)) {
+      if (kept.has(key)) out[key] = value;
+    } else if (key !== "properties" && key !== "items" && key !== "description" && key !== "format") {
+      out[key] = Array.isArray(value) ? [...value] : value;
+    }
+  }
+  const hint = constraintHint(node);
+  const description = [node.description, hint].filter(Boolean).join(" ");
+  if (description) out.description = description;
+  if (mainType(node) === "object") {
+    out.properties = Object.fromEntries(Object.entries(node.properties).map(([key, child]) => [key, normalizeNode(child, kept)]));
+    out.required = Object.keys(node.properties);
+    out.additionalProperties = false;
+  }
+  if (mainType(node) === "array") out.items = normalizeNode(node.items, kept);
+  return out;
+}
+function normalizeForProvider(schema, provider) {
+  return normalizeNode(schema, KEPT_CONSTRAINTS[provider] ?? /* @__PURE__ */ new Set());
+}
+function matchesType(type, value) {
+  switch (type) {
+    case "null":
+      return value === null;
+    case "object":
+      return value !== null && typeof value === "object" && !Array.isArray(value);
+    case "array":
+      return Array.isArray(value);
+    case "integer":
+      return Number.isInteger(value);
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    default:
+      return typeof value === type;
+  }
+}
+function valueProblems(node, value, at) {
+  const types = typesOf(node);
+  const type = types.find((candidate) => matchesType(candidate, value));
+  if (!type) return [`${at}: expected ${types.join(" or ")}`];
+  if (type === "string") {
+    if (node.enum && !node.enum.includes(value)) return [`${at}: expected one of ${node.enum.join(", ")}`];
+    if (node.maxLength !== void 0 && [...value].length > node.maxLength) return [`${at}: longer than ${node.maxLength} characters`];
+  }
+  if (type === "array") {
+    if (node.minItems !== void 0 && value.length < node.minItems) return [`${at}: fewer than ${node.minItems} items`];
+    if (node.maxItems !== void 0 && value.length > node.maxItems) return [`${at}: more than ${node.maxItems} items`];
+    return value.flatMap((item, index) => valueProblems(node.items, item, `${at}[${index}]`));
+  }
+  if (type === "object") {
+    const keys = Object.keys(node.properties);
+    const extra = Object.keys(value).filter((key) => !keys.includes(key));
+    const problems = extra.map((key) => `${at}.${key}: not expected`);
+    for (const key of keys) {
+      if (!Object.hasOwn(value, key)) problems.push(`${at}.${key}: missing`);
+      else problems.push(...valueProblems(node.properties[key], value[key], `${at}.${key}`));
+    }
+    return problems;
+  }
+  return [];
+}
+function validate(schema, value) {
+  return valueProblems(schema, value, "$");
+}
+export {
+  checkSchema,
+  normalizeForProvider,
+  validate
+};

package/dist/server.js

@@ -0,0 +1,19 @@
+import { definePrompt, customizePrompt, configureAi, listPrompts } from "./prompts.server.js";
+import { runPrompt } from "./run.server.js";
+import { saveResult, getResults, dismissResult, deleteResults } from "./results.server.js";
+import { getUsage } from "./runs.server.js";
+import { isAiConfigured, describeAiConfig } from "./config.server.js";
+export {
+  configureAi,
+  customizePrompt,
+  definePrompt,
+  deleteResults,
+  describeAiConfig,
+  dismissResult,
+  getResults,
+  getUsage,
+  isAiConfigured,
+  listPrompts,
+  runPrompt,
+  saveResult
+};

package/dist/source.js

@@ -0,0 +1,4 @@
+const SOURCE = "@fraza/module-ai";
+export {
+  SOURCE
+};

package/dist/studio.js

@@ -0,0 +1,205 @@
+const MAX_VARIANTS = 3;
+const REQUEST_MAX = 5e3;
+const MAX_ASKS = 20;
+const MAX_SUGGESTIONS = 8;
+const PLAN_TITLES = 3;
+const PLAN_SECTIONS = 12;
+const PLAN_TITLE_MAX = 200;
+const PLAN_SUMMARY_MAX = 400;
+const MAX_HINTS = 8;
+const STUDIO_INPUT = Object.freeze({
+  type: "object",
+  properties: {
+    request: { type: "string", maxLength: REQUEST_MAX, title: "Demande" }
+  },
+  required: ["request"]
+});
+const UNCHANGED = "null si tu ne changes pas ce texte.";
+function versionField(node) {
+  const free = node.type === "string" && node.enum === void 0;
+  if (!free) return node;
+  return { ...node, type: ["string", "null"], description: [node.description, UNCHANGED].filter(Boolean).join(" ") };
+}
+function studioOutput(output, variants) {
+  const properties = Object.fromEntries(Object.entries(output.properties).map(([key, node]) => [key, versionField(node)]));
+  return {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        maxLength: 600,
+        description: "Ta r\xE9ponse \xE0 la personne, une ou deux phrases dans sa langue : ce que tu as chang\xE9 et pourquoi."
+      },
+      versions: {
+        type: "array",
+        minItems: variants,
+        maxItems: variants,
+        items: { type: "object", properties, required: Object.keys(properties) }
+      }
+    },
+    required: ["message", "versions"]
+  };
+}
+function planOutput() {
+  const line = { type: "string", maxLength: PLAN_TITLE_MAX };
+  return {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        maxLength: 600,
+        description: "Ta r\xE9ponse \xE0 la personne, une ou deux phrases dans sa langue : l'angle du plan."
+      },
+      titles: {
+        type: "array",
+        minItems: PLAN_TITLES,
+        maxItems: PLAN_TITLES,
+        items: line,
+        description: "Des titres nettement diff\xE9rents les uns des autres, le meilleur d'abord."
+      },
+      sections: {
+        type: "array",
+        minItems: 1,
+        maxItems: PLAN_SECTIONS,
+        items: {
+          type: "object",
+          properties: {
+            title: { ...line, description: "L'intertitre de la section." },
+            summary: { type: "string", maxLength: PLAN_SUMMARY_MAX, description: "Une phrase : ce que la section couvre." }
+          },
+          required: ["title", "summary"]
+        }
+      }
+    },
+    required: ["message", "titles", "sections"]
+  };
+}
+function planText(plan) {
+  const lines = [];
+  if (plan.title) lines.push(`Titre retenu : ${plan.title}`);
+  lines.push("Sections, dans l'ordre :");
+  plan.sections.forEach((section, index) => {
+    lines.push(`${index + 1}. ${section.title}${section.summary ? ` : ${section.summary}` : ""}`);
+  });
+  return lines.join("\n");
+}
+function studioFollowUp({ asks = [], previous = null, variants, phase = null, plan = null }) {
+  const lines = [];
+  if (asks.length > 0) {
+    lines.push("Demandes pr\xE9c\xE9dentes, dans l'ordre :", ...asks.map((ask) => `- ${ask}`), "");
+  }
+  if (previous && Object.keys(previous).length > 0) {
+    lines.push(
+      "Ce que la personne a gard\xE9 de tes propositions, au format JSON (un champ absent est tel que dans le contenu actuel) :",
+      JSON.stringify(previous),
+      "",
+      "Pars de l\xE0 : applique la nouvelle demande \xE0 ce texte."
+    );
+  }
+  if (phase === "plan") {
+    if (plan) lines.push("Le plan actuel, tel que la personne l'a retouch\xE9 : pars de lui et de la demande.", planText(plan), "");
+    lines.push(
+      "Ne r\xE9dige pas encore le contenu. Propose d'abord son plan :",
+      `${PLAN_TITLES} titres nettement diff\xE9rents, puis les sections dans l'ordre, chacune avec son intertitre et une phrase qui dit ce qu'elle couvre.`,
+      "Pour un contenu d\xE9j\xE0 \xE9crit, pars de sa structure et propose celle qui le servirait le mieux."
+    );
+    return lines.join("\n");
+  }
+  if (plan) {
+    lines.push("Suis ce plan, valid\xE9 par la personne, section par section :", planText(plan), "");
+  }
+  lines.push(variants > 1 ? `Propose ${variants} versions nettement diff\xE9rentes les unes des autres.` : "Propose une version.");
+  lines.push("Dans chaque version, renvoie null pour un texte que tu ne changes pas.");
+  return lines.join("\n");
+}
+function checkSuggestions(suggestions, at) {
+  if (suggestions === void 0) return [];
+  if (!Array.isArray(suggestions) || suggestions.length > MAX_SUGGESTIONS) {
+    throw new TypeError(`${at}: suggestions is a list of ${MAX_SUGGESTIONS} at most`);
+  }
+  return suggestions.map((item, index) => {
+    const label = typeof (item == null ? void 0 : item.label) === "string" ? item.label.trim() : "";
+    const request = typeof (item == null ? void 0 : item.request) === "string" ? item.request.trim() : label;
+    const variants = (item == null ? void 0 : item.variants) ?? 1;
+    if (!label || label.length > 40) throw new TypeError(`${at}: suggestion ${index} needs a label of 40 characters at most`);
+    if (!request || request.length > REQUEST_MAX) throw new TypeError(`${at}: suggestion ${index} has an empty or too long request`);
+    if (!Number.isInteger(variants) || variants < 1 || variants > MAX_VARIANTS) {
+      throw new TypeError(`${at}: suggestion ${index} asks for 1 to ${MAX_VARIANTS} variants`);
+    }
+    return Object.freeze({ label, request, variants });
+  });
+}
+function checkHints(hints, at) {
+  if (hints === void 0) return [];
+  if (!Array.isArray(hints) || hints.length > MAX_HINTS) {
+    throw new TypeError(`${at}: hints is a list of ${MAX_HINTS} at most`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return hints.map((item, index) => {
+    var _a;
+    const label = typeof (item == null ? void 0 : item.label) === "string" ? item.label.trim() : "";
+    if (seen.has(label)) throw new TypeError(`${at}: hint ${index} repeats the label ${JSON.stringify(label)}`);
+    seen.add(label);
+    if ((item == null ? void 0 : item.text) !== void 0 && typeof item.text !== "string") throw new TypeError(`${at}: hint ${index} has a text that is not a string`);
+    const text = (item == null ? void 0 : item.text) === void 0 ? label : item.text.trim();
+    if (!label || label.length > 40) throw new TypeError(`${at}: hint ${index} needs a label of 40 characters at most`);
+    if (!text || text.length > 500) throw new TypeError(`${at}: hint ${index} has an empty or too long text`);
+    if ((item == null ? void 0 : item.group) !== void 0 && !(typeof item.group === "string" && item.group.trim() && item.group.trim().length <= 30)) {
+      throw new TypeError(`${at}: hint ${index} has a group that is not a name of 30 characters at most`);
+    }
+    return Object.freeze({ label, text, group: ((_a = item == null ? void 0 : item.group) == null ? void 0 : _a.trim()) ?? null });
+  });
+}
+function readPlan(plan) {
+  if (plan === null || plan === void 0) return null;
+  if (typeof plan !== "object" || Array.isArray(plan)) return void 0;
+  const title = plan.title ?? "";
+  const sections = plan.sections;
+  if (typeof title !== "string" || title.length > PLAN_TITLE_MAX) return void 0;
+  if (!Array.isArray(sections) || sections.length === 0 || sections.length > PLAN_SECTIONS) return void 0;
+  const checked = [];
+  for (const section of sections) {
+    const sectionTitle = section == null ? void 0 : section.title;
+    const summary = (section == null ? void 0 : section.summary) ?? "";
+    if (typeof sectionTitle !== "string" || !sectionTitle.trim() || sectionTitle.length > PLAN_TITLE_MAX) return void 0;
+    if (typeof summary !== "string" || summary.length > PLAN_SUMMARY_MAX) return void 0;
+    checked.push({ title: sectionTitle.trim(), summary: summary.trim() });
+  }
+  return { title: title.trim(), sections: checked };
+}
+function readTurn(body) {
+  const asks = (body == null ? void 0 : body.asks) ?? [];
+  const previous = (body == null ? void 0 : body.previous) ?? null;
+  const variants = (body == null ? void 0 : body.variants) ?? 1;
+  if (!Array.isArray(asks) || asks.length > MAX_ASKS) return null;
+  if (asks.some((ask) => typeof ask !== "string" || ask.length > REQUEST_MAX)) return null;
+  if (previous !== null && (typeof previous !== "object" || Array.isArray(previous))) return null;
+  if (!Number.isInteger(variants) || variants < 1 || variants > MAX_VARIANTS) return null;
+  const phase = (body == null ? void 0 : body.phase) ?? null;
+  if (phase !== null && phase !== "plan") return null;
+  const plan = readPlan(body == null ? void 0 : body.plan);
+  if (plan === void 0) return null;
+  return { asks, previous, variants, phase, plan };
+}
+function hasHtmlField(output) {
+  return Object.values((output == null ? void 0 : output.properties) ?? {}).some((node) => (node == null ? void 0 : node.format) === "html");
+}
+export {
+  MAX_ASKS,
+  MAX_HINTS,
+  MAX_SUGGESTIONS,
+  MAX_VARIANTS,
+  PLAN_SECTIONS,
+  PLAN_SUMMARY_MAX,
+  PLAN_TITLES,
+  PLAN_TITLE_MAX,
+  REQUEST_MAX,
+  STUDIO_INPUT,
+  checkHints,
+  checkSuggestions,
+  hasHtmlField,
+  planOutput,
+  readTurn,
+  studioFollowUp,
+  studioOutput
+};

package/dist/test-prompt.server.js

@@ -0,0 +1,24 @@
+import { definePrompt } from "./prompts.server.js";
+import { SOURCE } from "./source.js";
+const TEST_PROMPT = "ai.test";
+function defineTestPrompt() {
+  definePrompt({
+    name: TEST_PROMPT,
+    label: "Tester la configuration",
+    instructions: "R\xE9ponds par une courte phrase en fran\xE7ais qui confirme que tu fonctionnes.",
+    output: {
+      type: "object",
+      properties: {
+        message: { type: "string", maxLength: 200, description: "Une phrase de confirmation." }
+      },
+      required: ["message"]
+    },
+    // Room for the reasoning of a model that always thinks first.
+    maxTokens: 8e3,
+    build: ({ instructions }) => instructions
+  }, { source: SOURCE });
+}
+export {
+  TEST_PROMPT,
+  defineTestPrompt
+};

package/dist/version.js

@@ -0,0 +1,4 @@
+const MODULE_VERSION = "0.4.22";
+export {
+  MODULE_VERSION
+};

package/dist/widgets.server.js

@@ -0,0 +1,29 @@
+import { registerWidgetFetcher } from "@fraza/core/features/admin";
+import { AI_WIDGETS } from "./admin/widgets.js";
+import { describeAiConfig } from "./config.server.js";
+import { getUsage } from "./runs.server.js";
+import { SOURCE } from "./source.js";
+async function fetchUsage() {
+  const to = /* @__PURE__ */ new Date();
+  const from = new Date(Date.UTC(to.getUTCFullYear(), to.getUTCMonth(), 1));
+  const { totals } = await getUsage({ from, to });
+  const config = describeAiConfig();
+  return {
+    configured: config.configured,
+    provider: config.providerLabel,
+    model: config.model,
+    calls: totals.calls,
+    errors: totals.errors,
+    inputTokens: totals.inputTokens,
+    outputTokens: totals.outputTokens
+  };
+}
+function registerWidgetFetchers() {
+  registerWidgetFetcher(AI_WIDGETS.USAGE.id, fetchUsage, {
+    permission: AI_WIDGETS.USAGE.permission,
+    source: SOURCE
+  });
+}
+export {
+  registerWidgetFetchers
+};

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@fraza/module-ai",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.22",
+  "description": "Module d'intelligence artificielle pour Fraza : un fournisseur au choix, des prompts à réponse structurée, des boutons dans l'admin et des tâches en arrière-plan.",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "HYKO",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    },
+    "./admin": {
+      "import": "./dist/admin.js"
+    },
+    "./server": {
+      "import": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md",
+    "CHANGELOG.md",
+    "changelog.json"
+  ],
+  "keywords": [
+    "fraza-module"
+  ],
+  "scripts": {
+    "build": "fraza-module build",
+    "test": "node --import @fraza/core/tools/test/register --test test/",
+    "sync:version": "fraza-module sync-version",
+    "build:changelog": "fraza-module changelog",
+    "build:notices": "fraza-module notices",
+    "prepublishOnly": "fraza-module sync-version --check && npm run build && fraza-module check",
+    "audit": "npm audit --omit=dev --omit=peer",
+    "release": "fraza-module release",
+    "release:publish": "fraza-module publish"
+  },
+  "engines": {
+    "node": ">=20.12"
+  },
+  "devDependencies": {
+    "@fraza/icons": "*",
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.2"
+  },
+  "peerDependencies": {
+    "@fraza/core": "*",
+    "@fraza/icons": "*",
+    "next": ">=16.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "fraza": {
+    "contract": 1,
+    "breaking": false,
+    "action": [],
+    "envAdded": [],
+    "envRemoved": [],
+    "template": false,
+    "envRenamed": []
+  }
+}