@dbx-tools/shared-generator 0.0.0-stage → 0.9.136

package/lib/src/brand.js

@@ -0,0 +1,212 @@
+/**
+ * Browser-safe contracts and client for AppKit brand generation.
+ *
+ * @module
+ */
+import { BrandContextSchema } from "@dbx-tools/shared-core/brand-utils";
+import { z } from "zod";
+const nonBlankString = z.string().trim().min(1);
+/** Registered AppKit generator plugin name. */
+export const GENERATOR_PLUGIN_NAME = "generator";
+/** Default route prefix published by the generator plugin. */
+export const GENERATOR_BASE_PATH = `/api/${GENERATOR_PLUGIN_NAME}`;
+/** Mount-relative route segments owned by the generator plugin. */
+export const GENERATOR_ROUTES = {
+    generateBrand: "/brand/generate",
+};
+/** Input accepted by brand generation. */
+export const BrandGenerationRequestSchema = z
+    .object({
+    name: nonBlankString
+        .max(200)
+        .optional()
+        .describe("Known brand, organization, or product name."),
+    prompt: nonBlankString
+        .max(2_000)
+        .optional()
+        .describe("Open-ended brand brief used for research and generation."),
+    website: z
+        .string()
+        .url()
+        .refine((value) => new URL(value).protocol === "https:", "Expected an HTTPS website URL.")
+        .optional()
+        .describe("Known official website used to disambiguate the brand."),
+})
+    .strict()
+    .refine((value) => value.name !== undefined || value.prompt !== undefined, {
+    message: "Brand generation requires a name or prompt.",
+})
+    .describe("Request to research one brand and generate its portable branding package.");
+/** A cited source and whether its page content was available to synthesis. */
+export const BrandPackageSourceSchema = z
+    .object({
+    url: z.string().url().describe("Source URL used during brand research."),
+    title: nonBlankString.optional().describe("Source page title, when available."),
+    snippet: nonBlankString.optional().describe("Search-result excerpt, when available."),
+    fetched: z
+        .boolean()
+        .describe("True when web_fetch returned page content used during synthesis."),
+})
+    .strict()
+    .describe("Web source used to research the generated brand.");
+/** One fetched mobile-app image used as visual brand research. */
+export const BrandVisualImageSchema = z
+    .object({
+    url: z.string().url().describe("Original mobile-store image URL."),
+    contentType: z.string().optional().describe("Fetched image media type."),
+    localPath: z
+        .string()
+        .optional()
+        .describe("Package-relative exported image path, when written by a CLI."),
+})
+    .strict()
+    .describe("Mobile-store image reference used for brand inspiration.");
+/** App Store or Play Store page and its visual references. */
+export const BrandVisualReferenceSchema = z
+    .object({
+    platform: z.enum(["ios", "android"]).describe("Mobile application platform."),
+    appName: nonBlankString.describe("Application name read from the store page."),
+    pageUrl: z.string().url().describe("Official application-store page."),
+    images: z.array(BrandVisualImageSchema).describe("Fetched app icon or screenshots."),
+})
+    .strict()
+    .describe("Mobile application visuals consulted during brand research.");
+/** Portable generated brand context with research provenance. */
+export const BrandPackageSchema = z
+    .object({
+    brand: BrandContextSchema.describe("Portable brand context ready for @dbx-tools UI and email consumers."),
+    sources: z
+        .array(BrandPackageSourceSchema)
+        .describe("Deduplicated web sources used to generate this package."),
+    visualReferences: z
+        .array(BrandVisualReferenceSchema)
+        .default([])
+        .describe("iOS and Android application visuals used for inspiration."),
+})
+    .strict()
+    .describe("Generated branding package and its web research provenance.");
+/** Observable stages in one brand-generation workflow. */
+export const BrandGenerationStageSchema = z.enum([
+    "search",
+    "fetch",
+    "visuals",
+    "assets",
+    "synthesize",
+]);
+/** Progress emitted while the backend researches and synthesizes a brand. */
+export const BrandGenerationProgressEventSchema = z
+    .object({
+    type: z.literal("progress"),
+    stage: BrandGenerationStageSchema.describe("Current workflow stage."),
+    message: nonBlankString.describe("Short user-facing progress message."),
+    current: z.number().int().nonnegative().optional().describe("Completed items in this stage."),
+    total: z.number().int().positive().optional().describe("Total items in this stage."),
+})
+    .strict()
+    .describe("Progress update from a running brand generation.");
+/** Final successful brand-generation event. */
+export const BrandGenerationResultEventSchema = z
+    .object({
+    type: z.literal("result"),
+    package: BrandPackageSchema.describe("Completed portable branding package."),
+})
+    .strict()
+    .describe("Successful completion of brand generation.");
+/** Final error event from a started brand-generation stream. */
+export const BrandGenerationErrorEventSchema = z
+    .object({
+    type: z.literal("error"),
+    message: nonBlankString.describe("Actionable generation failure message."),
+})
+    .strict()
+    .describe("Failure emitted after a brand-generation stream started.");
+/** Every server-sent event emitted by brand generation. */
+export const BrandGenerationEventSchema = z.discriminatedUnion("type", [
+    BrandGenerationProgressEventSchema,
+    BrandGenerationResultEventSchema,
+    BrandGenerationErrorEventSchema,
+]);
+/** Browser-safe route configuration published by the AppKit generator plugin. */
+export const GeneratorClientConfigSchema = z
+    .object({
+    basePath: nonBlankString.describe("Mounted API route prefix for the generator plugin."),
+})
+    .strict()
+    .describe("Browser configuration published by the AppKit generator plugin.");
+/** Build the brand endpoint from the generator plugin's published base path. */
+export function brandGenerateUrl(basePath = GENERATOR_BASE_PATH) {
+    return `${basePath.replace(/\/+$/, "")}${GENERATOR_ROUTES.generateBrand}`;
+}
+/** Parse one complete SSE frame into its validated brand event. */
+function parseEventFrame(frame) {
+    const data = frame
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(5).trimStart())
+        .join("\n");
+    if (!data)
+        return undefined;
+    const value = JSON.parse(data);
+    return BrandGenerationEventSchema.parse(value);
+}
+/** Read a failed HTTP response without trusting its payload shape. */
+async function responseError(response) {
+    const value = await response
+        .clone()
+        .json()
+        .catch(() => undefined);
+    if (typeof value === "object" && value !== null && "error" in value) {
+        const message = value.error;
+        if (typeof message === "string" && message.trim())
+            return message.trim();
+    }
+    const text = await response.text().catch(() => "");
+    return text.trim() || `Brand generation failed (${response.status}).`;
+}
+/** Browser client for the generator plugin's streamed routes. */
+export class GeneratorPluginClient {
+    config;
+    /** Create a client from the plugin's published `clientConfig()` payload. */
+    constructor(config) {
+        this.config = GeneratorClientConfigSchema.parse(config);
+    }
+    /** Generate a brand while yielding validated progress and terminal events. */
+    async *generate(input, options = {}) {
+        const request = BrandGenerationRequestSchema.parse(input);
+        const fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+        const response = await fetcher(brandGenerateUrl(this.config.basePath), {
+            method: "POST",
+            headers: {
+                Accept: "text/event-stream",
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(request),
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        if (!response.ok)
+            throw new Error(await responseError(response));
+        if (!response.body)
+            throw new Error("Brand generation returned no event stream.");
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        for (;;) {
+            const { done, value } = await reader.read();
+            buffer += decoder.decode(value, { stream: !done }).replaceAll("\r\n", "\n");
+            let boundary = buffer.indexOf("\n\n");
+            while (boundary >= 0) {
+                const event = parseEventFrame(buffer.slice(0, boundary));
+                if (event)
+                    yield event;
+                buffer = buffer.slice(boundary + 2);
+                boundary = buffer.indexOf("\n\n");
+            }
+            if (done)
+                break;
+        }
+        const event = parseEventFrame(buffer.trim());
+        if (event)
+            yield event;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"brand.js","sourceRoot":"","sources":["../../src/brand.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browser-safe contracts and client for AppKit brand generation.\n *\n * @module\n */\n\nimport { BrandContextSchema } from \"@dbx-tools/shared-core/brand-utils\";\nimport { z } from \"zod\";\n\nconst nonBlankString = z.string().trim().min(1);\n\n/** Registered AppKit generator plugin name. */\nexport const GENERATOR_PLUGIN_NAME = \"generator\";\n\n/** Default route prefix published by the generator plugin. */\nexport const GENERATOR_BASE_PATH = `/api/${GENERATOR_PLUGIN_NAME}`;\n\n/** Mount-relative route segments owned by the generator plugin. */\nexport const GENERATOR_ROUTES = {\n  generateBrand: \"/brand/generate\",\n} as const;\n\n/** Input accepted by brand generation. */\nexport const BrandGenerationRequestSchema = z\n  .object({\n    name: nonBlankString\n      .max(200)\n      .optional()\n      .describe(\"Known brand, organization, or product name.\"),\n    prompt: nonBlankString\n      .max(2_000)\n      .optional()\n      .describe(\"Open-ended brand brief used for research and generation.\"),\n    website: z\n      .string()\n      .url()\n      .refine((value) => new URL(value).protocol === \"https:\", \"Expected an HTTPS website URL.\")\n      .optional()\n      .describe(\"Known official website used to disambiguate the brand.\"),\n  })\n  .strict()\n  .refine((value) => value.name !== undefined || value.prompt !== undefined, {\n    message: \"Brand generation requires a name or prompt.\",\n  })\n  .describe(\"Request to research one brand and generate its portable branding package.\");\n\n/** Validated brand-generation request. */\nexport type BrandGenerationRequest = z.infer<typeof BrandGenerationRequestSchema>;\n\n/** A cited source and whether its page content was available to synthesis. */\nexport const BrandPackageSourceSchema = z\n  .object({\n    url: z.string().url().describe(\"Source URL used during brand research.\"),\n    title: nonBlankString.optional().describe(\"Source page title, when available.\"),\n    snippet: nonBlankString.optional().describe(\"Search-result excerpt, when available.\"),\n    fetched: z\n      .boolean()\n      .describe(\"True when web_fetch returned page content used during synthesis.\"),\n  })\n  .strict()\n  .describe(\"Web source used to research the generated brand.\");\n\n/** Source provenance included in a generated branding package. */\nexport type BrandPackageSource = z.infer<typeof BrandPackageSourceSchema>;\n\n/** One fetched mobile-app image used as visual brand research. */\nexport const BrandVisualImageSchema = z\n  .object({\n    url: z.string().url().describe(\"Original mobile-store image URL.\"),\n    contentType: z.string().optional().describe(\"Fetched image media type.\"),\n    localPath: z\n      .string()\n      .optional()\n      .describe(\"Package-relative exported image path, when written by a CLI.\"),\n  })\n  .strict()\n  .describe(\"Mobile-store image reference used for brand inspiration.\");\n\n/** Mobile-store image used as visual brand research. */\nexport type BrandVisualImage = z.infer<typeof BrandVisualImageSchema>;\n\n/** App Store or Play Store page and its visual references. */\nexport const BrandVisualReferenceSchema = z\n  .object({\n    platform: z.enum([\"ios\", \"android\"]).describe(\"Mobile application platform.\"),\n    appName: nonBlankString.describe(\"Application name read from the store page.\"),\n    pageUrl: z.string().url().describe(\"Official application-store page.\"),\n    images: z.array(BrandVisualImageSchema).describe(\"Fetched app icon or screenshots.\"),\n  })\n  .strict()\n  .describe(\"Mobile application visuals consulted during brand research.\");\n\n/** Mobile-store brand research reference. */\nexport type BrandVisualReference = z.infer<typeof BrandVisualReferenceSchema>;\n\n/** Portable generated brand context with research provenance. */\nexport const BrandPackageSchema = z\n  .object({\n    brand: BrandContextSchema.describe(\n      \"Portable brand context ready for @dbx-tools UI and email consumers.\",\n    ),\n    sources: z\n      .array(BrandPackageSourceSchema)\n      .describe(\"Deduplicated web sources used to generate this package.\"),\n    visualReferences: z\n      .array(BrandVisualReferenceSchema)\n      .default([])\n      .describe(\"iOS and Android application visuals used for inspiration.\"),\n  })\n  .strict()\n  .describe(\"Generated branding package and its web research provenance.\");\n\n/** Generated branding package. */\nexport type BrandPackage = z.infer<typeof BrandPackageSchema>;\n\n/** Observable stages in one brand-generation workflow. */\nexport const BrandGenerationStageSchema = z.enum([\n  \"search\",\n  \"fetch\",\n  \"visuals\",\n  \"assets\",\n  \"synthesize\",\n]);\n\n/** Observable brand-generation stage. */\nexport type BrandGenerationStage = z.infer<typeof BrandGenerationStageSchema>;\n\n/** Progress emitted while the backend researches and synthesizes a brand. */\nexport const BrandGenerationProgressEventSchema = z\n  .object({\n    type: z.literal(\"progress\"),\n    stage: BrandGenerationStageSchema.describe(\"Current workflow stage.\"),\n    message: nonBlankString.describe(\"Short user-facing progress message.\"),\n    current: z.number().int().nonnegative().optional().describe(\"Completed items in this stage.\"),\n    total: z.number().int().positive().optional().describe(\"Total items in this stage.\"),\n  })\n  .strict()\n  .describe(\"Progress update from a running brand generation.\");\n\n/** Progress event emitted during brand generation. */\nexport type BrandGenerationProgressEvent = z.infer<typeof BrandGenerationProgressEventSchema>;\n\n/** Final successful brand-generation event. */\nexport const BrandGenerationResultEventSchema = z\n  .object({\n    type: z.literal(\"result\"),\n    package: BrandPackageSchema.describe(\"Completed portable branding package.\"),\n  })\n  .strict()\n  .describe(\"Successful completion of brand generation.\");\n\n/** Final successful brand-generation event. */\nexport type BrandGenerationResultEvent = z.infer<typeof BrandGenerationResultEventSchema>;\n\n/** Final error event from a started brand-generation stream. */\nexport const BrandGenerationErrorEventSchema = z\n  .object({\n    type: z.literal(\"error\"),\n    message: nonBlankString.describe(\"Actionable generation failure message.\"),\n  })\n  .strict()\n  .describe(\"Failure emitted after a brand-generation stream started.\");\n\n/** Final error event from a started brand-generation stream. */\nexport type BrandGenerationErrorEvent = z.infer<typeof BrandGenerationErrorEventSchema>;\n\n/** Every server-sent event emitted by brand generation. */\nexport const BrandGenerationEventSchema = z.discriminatedUnion(\"type\", [\n  BrandGenerationProgressEventSchema,\n  BrandGenerationResultEventSchema,\n  BrandGenerationErrorEventSchema,\n]);\n\n/** Server-sent event emitted by brand generation. */\nexport type BrandGenerationEvent = z.infer<typeof BrandGenerationEventSchema>;\n\n/** Browser-safe route configuration published by the AppKit generator plugin. */\nexport const GeneratorClientConfigSchema = z\n  .object({\n    basePath: nonBlankString.describe(\"Mounted API route prefix for the generator plugin.\"),\n  })\n  .strict()\n  .describe(\"Browser configuration published by the AppKit generator plugin.\");\n\n/** Browser-safe generator plugin route configuration. */\nexport type GeneratorClientConfig = z.infer<typeof GeneratorClientConfigSchema>;\n\n/** Options for one browser brand-generation stream. */\nexport interface BrandGenerationStreamOptions {\n  /** Cancels the request and response stream. */\n  signal?: AbortSignal;\n  /** Fetch implementation. Defaults to the browser global. */\n  fetch?: typeof globalThis.fetch;\n}\n\n/** Build the brand endpoint from the generator plugin's published base path. */\nexport function brandGenerateUrl(basePath: string = GENERATOR_BASE_PATH): string {\n  return `${basePath.replace(/\\/+$/, \"\")}${GENERATOR_ROUTES.generateBrand}`;\n}\n\n/** Parse one complete SSE frame into its validated brand event. */\nfunction parseEventFrame(frame: string): BrandGenerationEvent | undefined {\n  const data = frame\n    .split(\"\\n\")\n    .filter((line) => line.startsWith(\"data:\"))\n    .map((line) => line.slice(5).trimStart())\n    .join(\"\\n\");\n  if (!data) return undefined;\n  const value: unknown = JSON.parse(data);\n  return BrandGenerationEventSchema.parse(value);\n}\n\n/** Read a failed HTTP response without trusting its payload shape. */\nasync function responseError(response: Response): Promise<string> {\n  const value: unknown = await response\n    .clone()\n    .json()\n    .catch(() => undefined);\n  if (typeof value === \"object\" && value !== null && \"error\" in value) {\n    const message = value.error;\n    if (typeof message === \"string\" && message.trim()) return message.trim();\n  }\n  const text = await response.text().catch(() => \"\");\n  return text.trim() || `Brand generation failed (${response.status}).`;\n}\n\n/** Browser client for the generator plugin's streamed routes. */\nexport class GeneratorPluginClient {\n  private readonly config: GeneratorClientConfig;\n\n  /** Create a client from the plugin's published `clientConfig()` payload. */\n  constructor(config: GeneratorClientConfig) {\n    this.config = GeneratorClientConfigSchema.parse(config);\n  }\n\n  /** Generate a brand while yielding validated progress and terminal events. */\n  async *generate(\n    input: BrandGenerationRequest,\n    options: BrandGenerationStreamOptions = {},\n  ): AsyncGenerator<BrandGenerationEvent> {\n    const request = BrandGenerationRequestSchema.parse(input);\n    const fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);\n    const response = await fetcher(brandGenerateUrl(this.config.basePath), {\n      method: \"POST\",\n      headers: {\n        Accept: \"text/event-stream\",\n        \"Content-Type\": \"application/json\",\n      },\n      body: JSON.stringify(request),\n      ...(options.signal ? { signal: options.signal } : {}),\n    });\n    if (!response.ok) throw new Error(await responseError(response));\n    if (!response.body) throw new Error(\"Brand generation returned no event stream.\");\n\n    const reader = response.body.getReader();\n    const decoder = new TextDecoder();\n    let buffer = \"\";\n    for (;;) {\n      const { done, value } = await reader.read();\n      buffer += decoder.decode(value, { stream: !done }).replaceAll(\"\\r\\n\", \"\\n\");\n      let boundary = buffer.indexOf(\"\\n\\n\");\n      while (boundary >= 0) {\n        const event = parseEventFrame(buffer.slice(0, boundary));\n        if (event) yield event;\n        buffer = buffer.slice(boundary + 2);\n        boundary = buffer.indexOf(\"\\n\\n\");\n      }\n      if (done) break;\n    }\n    const event = parseEventFrame(buffer.trim());\n    if (event) yield event;\n  }\n}\n"]}

package/lib/src/kpi.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Browser-safe KPI research contracts.
+ *
+ * @module
+ */
+import { z } from "zod";
+/** One evidence-backed KPI used to shape generated data and presentation. */
+export declare const ResearchedKpiSchema: z.ZodObject<{
+    name: z.ZodString;
+    label: z.ZodString;
+    definition: z.ZodString;
+    unit: z.ZodEnum<{
+        number: "number";
+        currency: "currency";
+        percent: "percent";
+        duration: "duration";
+    }>;
+    targetDirection: z.ZodEnum<{
+        higher: "higher";
+        lower: "lower";
+        neutral: "neutral";
+    }>;
+    sourceUrls: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** Evidence-backed KPI. */
+export type ResearchedKpi = z.infer<typeof ResearchedKpiSchema>;
+/** KPI research request independent of any mutation workflow. */
+export declare const KpiResearchRequestSchema: z.ZodObject<{
+    company: z.ZodString;
+    purpose: z.ZodString;
+    queries: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/** KPI research request. */
+export type KpiResearchRequest = z.infer<typeof KpiResearchRequestSchema>;
+/** KPI research result and its source provenance. */
+export declare const KpiResearchResultSchema: z.ZodObject<{
+    kpis: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        label: z.ZodString;
+        definition: z.ZodString;
+        unit: z.ZodEnum<{
+            number: "number";
+            currency: "currency";
+            percent: "percent";
+            duration: "duration";
+        }>;
+        targetDirection: z.ZodEnum<{
+            higher: "higher";
+            lower: "lower";
+            neutral: "neutral";
+        }>;
+        sourceUrls: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    sources: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        fetched: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** KPI research result. */
+export type KpiResearchResult = z.infer<typeof KpiResearchResultSchema>;

package/lib/src/kpi.js

@@ -0,0 +1,56 @@
+/**
+ * Browser-safe KPI research contracts.
+ *
+ * @module
+ */
+import { z } from "zod";
+const nonBlankString = z.string().trim().min(1);
+const identifier = z.string().regex(/^[a-z][a-z0-9_]*$/);
+/** One evidence-backed KPI used to shape generated data and presentation. */
+export const ResearchedKpiSchema = z
+    .object({
+    name: identifier.describe("Stable snake_case KPI identifier."),
+    label: nonBlankString.describe("Human-readable KPI label."),
+    definition: nonBlankString.describe("Business definition supported by cited research."),
+    unit: z
+        .enum(["number", "currency", "percent", "duration"])
+        .describe("Display unit and formatting family."),
+    targetDirection: z
+        .enum(["higher", "lower", "neutral"])
+        .describe("Whether higher or lower values represent improvement."),
+    sourceUrls: z
+        .array(z.string().url())
+        .describe("Research sources supporting the KPI definition."),
+})
+    .strict()
+    .describe("Evidence-backed KPI selected for generated demo data.");
+/** KPI research request independent of any mutation workflow. */
+export const KpiResearchRequestSchema = z
+    .object({
+    company: nonBlankString.max(200).describe("Company or brand being modeled."),
+    purpose: nonBlankString.max(200).describe("Purpose of the generated demonstration."),
+    queries: z
+        .array(nonBlankString.max(500))
+        .min(1)
+        .max(10)
+        .describe("Natural-language questions the generated data should answer."),
+})
+    .strict()
+    .describe("Request for web-researched KPIs that shape generated demo data.");
+/** KPI research result and its source provenance. */
+export const KpiResearchResultSchema = z
+    .object({
+    kpis: z.array(ResearchedKpiSchema).min(1).max(8).describe("Selected KPI definitions."),
+    sources: z
+        .array(z
+        .object({
+        url: z.string().url().describe("Research source URL."),
+        title: nonBlankString.optional().describe("Source title, when available."),
+        fetched: z.boolean().describe("Whether page content was read."),
+    })
+        .strict())
+        .describe("Deduplicated KPI research sources."),
+})
+    .strict()
+    .describe("Evidence-backed KPI research output.");
+//# sourceMappingURL=data:application/json;base64,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