@blokkli/editor 2.0.0-alpha.35 → 2.0.0-alpha.37

package/dist/modules/agent/runtime/server/default-skills/fixReadability.js

@@ -0,0 +1,69 @@
+import { defineBlokkliAgentSkill } from "../skills/index.js";
+export default defineBlokkliAgentSkill({
+  name: "fix-readability",
+  label: { en: "Fix Readability", de: "Lesbarkeit verbessern" },
+  description: "Load this skill when asked to check, fix, or improve readability of texts on the page.",
+  getContents: () => `
+# Fix Readability - Iterative Workflow
+
+Fixing readability is an **iterative process**. You must verify your rewrites actually improved the scores before moving on.
+
+## Step 1: Analyze
+
+Call \`get_readability_issues\` to get current issues.
+
+The result is an object keyed by paragraph UUID, then by field name:
+\`\`\`
+{
+  "<uuid>": {
+    "<fieldName>": {
+      "fieldValue": "current text",
+      "issues": [
+        { "text": "flagged segment", "impact": "critical", "scores": { "lix": 85 } }
+      ]
+    }
+  }
+}
+\`\`\`
+
+- \`fieldValue\` is the full editable field content.
+- Each issue is a text segment within the field that was flagged, with its own scores.
+- A field can have multiple issues (e.g. a rich text field with several hard-to-read paragraphs).
+
+## Step 2: Pre-check with \`check_readability_for_texts\`
+
+Before applying a rewrite, use \`check_readability_for_texts\` to verify your rewritten text actually scores better. Pass the proposed new text and check that the scores improved compared to the original.
+
+This is cheap and fast \u2014 use it to iterate on your wording before committing a rewrite.
+
+## Step 3: Rewrite
+
+Use \`batch_rewrite_text\` to apply the improved texts. The UUID and field name from the analyze result map directly to the batch_rewrite_text input:
+\`\`\`
+{ "uuids": { "<uuid>": { "<fieldName>": "improved text" } } }
+\`\`\`
+
+When rewriting:
+- Use shorter sentences and simpler words.
+- Keep the original meaning and tone.
+- Focus on fields with "critical" and "serious" impact first.
+
+## Step 4: Verify
+
+After the rewrites are applied, call \`get_readability_issues\` **again** to check if the issues are resolved.
+
+- If issues remain: rewrite again with different wording.
+- If new issues appeared: fix those too.
+- Repeat until no more readability issues are reported.
+
+**Do NOT skip the verification step.** A rewrite can easily make readability worse if sentences become longer or more complex.
+
+## Important
+
+- Always pre-check with \`check_readability_for_texts\` before applying rewrites.
+- Always verify with \`get_readability_issues\` after applying rewrites.
+- Never assume a rewrite fixed the issue.
+- The scores (LIX, CLI, ARI) measure sentence length and word complexity. Lower is easier to read.
+- LIX above 60 is flagged. Above 70 is critical.
+`
+});

package/dist/modules/agent/runtime/server/default-system-prompts/page-context.js

@@ -51,6 +51,34 @@ export default defineBlokkliAgentSystemPrompt({
         lines.push(formatContentField(field));
       }
     }
+    if (pageContext.contentSearchTabs?.length) {
+      lines.push(
+        "",
+        "## Content Search Tabs",
+        "",
+        "Use the `search_content` tool with one of these tab IDs to search for content:",
+        ""
+      );
+      for (const tab of pageContext.contentSearchTabs) {
+        const typesDescription = tab.types.map((t) => `${t.type} (${t.bundles.join(", ")})`).join(", ");
+        lines.push(`- **\`${tab.id}\`** \u2014 ${tab.title}: ${typesDescription}`);
+      }
+    }
+    if (pageContext.analyzers?.length) {
+      lines.push(
+        "",
+        "## Available Analyzers",
+        "",
+        "Use `get_readability_issues` to run all readability analyzers. The following analyzers are available:",
+        ""
+      );
+      for (const a of pageContext.analyzers) {
+        const parts = [`- **\`${a.id}\`**`];
+        if (a.label) parts.push(`\u2014 ${a.label}`);
+        if (a.description) parts.push(`: ${a.description}`);
+        lines.push(parts.join(""));
+      }
+    }
     const editModeDescription = getEditModeDescription(pageContext.editMode);
     if (editModeDescription) {
       lines.push("", "## Edit Mode", "", editModeDescription);

package/dist/modules/agent/runtime/server/server-tools/index.d.ts

@@ -23,7 +23,10 @@ export type ToolResultEntry = {
 export type ToolDefinitionContext = {
     resolvedSkills: ResolvedSkill[];
     plan: ServerPlan | null;
-    unloadedLazyTools: ClientToolDefinition[];
+    unloadedLazyTools: {
+        name: string;
+        description: string;
+    }[];
 };
 /**
  * Context passed to `handle()` — provides access to session state
@@ -33,7 +36,7 @@ export type ServerToolContext = {
     toolUseId: string;
     send: (message: ServerMessage) => void;
     resolvedSkills: ResolvedSkill[];
-    lazyTools: ClientToolDefinition[];
+    lazyToolNames: string[];
     activatedLazyTools: Set<string>;
     loadedSkills: Set<string>;
     plan: ServerPlan | null;
@@ -79,6 +82,11 @@ export type ServerSideTool<T extends z.ZodType = z.ZodType> = {
  * Identity function for type inference when defining a server-side tool.
  */
 export declare function defineServerSideTool<T extends z.ZodType>(tool: ServerSideTool<T>): ServerSideTool<T>;
+/**
+ * Recursively strip $schema and additionalProperties from a JSON Schema object.
+ * These are unnecessary for the LLM and waste context window tokens.
+ */
+export declare function stripSchemaOverhead(obj: unknown): unknown;
 /**
  * Build a ClientToolDefinition from a ServerSideTool for a given context.
  * Returns null when the tool should not be offered this turn.

package/dist/modules/agent/runtime/server/server-tools/index.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 export function defineServerSideTool(tool) {
   return tool;
 }
-function stripSchemaOverhead(obj) {
+export function stripSchemaOverhead(obj) {
   if (Array.isArray(obj)) {
     return obj.map(stripSchemaOverhead);
   }

package/dist/modules/agent/runtime/server/server-tools/load_tools/index.js

@@ -18,7 +18,7 @@ export default defineServerSideTool({
   handle(ctx, input) {
     const loaded = [];
     for (const name of input.tools) {
-      if (ctx.lazyTools.some((t) => t.name === name)) {
+      if (ctx.lazyToolNames.includes(name)) {
         ctx.activatedLazyTools.add(name);
         loaded.push(name);
       }

package/dist/modules/agent/runtime/shared/types.d.ts

@@ -113,6 +113,21 @@ export type BlockBundle = {
  * Edit mode determines what actions the user is allowed to perform.
  */
 export type EditMode = 'readonly' | 'editing' | 'translating' | 'review';
+/**
+ * Server-side tool metadata extracted at build time.
+ * Contains only static properties needed by the server — no execute(), label(),
+ * component, or other runtime-only fields.
+ */
+export type ServerToolMetadata = {
+    name: string;
+    description: string;
+    category: 'query' | 'mutation';
+    modes: EditMode[];
+    paramsSchema: z.ZodType;
+    lazy?: boolean;
+    volatile?: boolean;
+    requiredAdapterMethods?: string[];
+};
 /**
  * Fragment definition for reusable content blocks.
  */
@@ -152,6 +167,22 @@ export type PageContext = {
     fragments: Fragment[];
     /** Content fields on the page entity itself (e.g., lead text, hero image) */
     entityContentFields: BlockBundleContentField[];
+    /** Available content search tabs (for the search_content tool) */
+    contentSearchTabs?: {
+        id: string;
+        title: string;
+        types: {
+            type: string;
+            bundles: string[];
+        }[];
+    }[];
+    /** Available content analyzers (for the get_readability_issues tool) */
+    analyzers?: {
+        id: string;
+        type?: string;
+        label?: string;
+        description?: string;
+    }[];
 };
 /**
  * Classified error categories for AI provider errors.
@@ -204,6 +235,40 @@ export type UsageTurn = {
     cacheReadInputTokens: number;
     pricing: UsagePricing | null;
 };
+/**
+ * A single system prompt entry in the structured transcript.
+ */
+export type TranscriptSystemPrompt = {
+    id: string;
+    name: string;
+    content: string;
+};
+/**
+ * A single message in the structured transcript.
+ * `seen` is the pruned content actually sent to the LLM.
+ * `full` is the pre-pruned content, omitted when identical to `seen`.
+ */
+export type TranscriptMessage = {
+    type: 'agent' | 'user';
+    seen: string | GenericContentBlock[];
+    full?: string | GenericContentBlock[];
+};
+/**
+ * Tool definition as included in the transcript.
+ */
+export type TranscriptToolDefinition = {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+};
+/**
+ * Structured transcript of the current conversation state.
+ */
+export type Transcript = {
+    system: TranscriptSystemPrompt[];
+    messages: TranscriptMessage[];
+    tools: TranscriptToolDefinition[];
+};
 /**
  * Tool definition sent from client to server on init.
  */
@@ -232,17 +297,7 @@ export declare const clientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     authToken: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"init">;
-    tools: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        description: z.ZodString;
-        input_schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        lazy: z.ZodOptional<z.ZodBoolean>;
-        category: z.ZodOptional<z.ZodEnum<{
-            query: "query";
-            mutation: "mutation";
-        }>>;
-        volatile: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
+    toolNames: z.ZodArray<z.ZodString>;
     pageContext: z.ZodObject<{
         title: z.ZodString;
         entityType: z.ZodString;
@@ -313,6 +368,20 @@ export declare const clientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 bundles: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>]>>;
+        contentSearchTabs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            types: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+                bundles: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        analyzers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"start">;
@@ -404,7 +473,7 @@ export type ServerMessage = {
     retryable?: boolean;
 } | {
     type: 'transcript';
-    content: string;
+    transcript: Transcript;
 } | {
     type: 'server_tool_result';
     tool: 'load_skill' | 'load_tools' | 'create_plan' | 'complete_plan_step';

package/dist/modules/agent/runtime/shared/types.js

@@ -66,7 +66,27 @@ const pageContextSchema = z.object({
   isPublished: z.boolean().nullable(),
   editMode: z.enum(["readonly", "editing", "translating", "review"]),
   fragments: z.array(fragmentSchema),
-  entityContentFields: z.array(blockBundleContentFieldSchema)
+  entityContentFields: z.array(blockBundleContentFieldSchema),
+  contentSearchTabs: z.array(
+    z.object({
+      id: z.string(),
+      title: z.string(),
+      types: z.array(
+        z.object({
+          type: z.string(),
+          bundles: z.array(z.string())
+        })
+      )
+    })
+  ).optional(),
+  analyzers: z.array(
+    z.object({
+      id: z.string(),
+      type: z.string().optional(),
+      label: z.string().optional(),
+      description: z.string().optional()
+    })
+  ).optional()
 });
 const pageStructureBlockSchema = z.lazy(
   () => z.object({
@@ -81,14 +101,6 @@ export const pageStructureSchema = z.object({
   fields: z.record(z.string(), z.array(pageStructureBlockSchema)),
   entityContentFields: z.record(z.string(), z.string()).optional()
 });
-const clientToolDefinitionSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  input_schema: z.record(z.string(), z.unknown()),
-  lazy: z.boolean().optional(),
-  category: z.enum(["query", "mutation"]).optional(),
-  volatile: z.boolean().optional()
-});
 const genericContentBlockSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("text"), text: z.string() }),
   z.object({ type: z.literal("skill"), name: z.string(), text: z.string() }),
@@ -118,7 +130,7 @@ export const clientMessageSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("authenticate"), authToken: z.string() }),
   z.object({
     type: z.literal("init"),
-    tools: z.array(clientToolDefinitionSchema),
+    toolNames: z.array(z.string()),
     pageContext: pageContextSchema
   }),
   z.object({

package/dist/modules/charts/index.d.mts

@@ -0,0 +1,35 @@
+import { B as BlokkliModule } from '../../shared/editor.BdBm1Z7C.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
+import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
+
+type ChartColor = {
+    /**
+     * A valid CSS color value, e.g. '#ff0000', 'rgb(255, 0, 0)',
+     * or 'rgb(var(--theme-color-primary))' for CSS custom properties.
+     */
+    color: string;
+    /**
+     * The label of the color.
+     */
+    label: string;
+};
+type ChartsModuleOptions = {
+    /**
+     * Provide the path to a custom component to render charts.
+     *
+     * @todo not yet implemented
+     */
+    chartRenderComponent?: string;
+    /**
+     * The available chart colors.
+     */
+    colors: Record<string, ChartColor>;
+};
+
+declare const _default: (options: ChartsModuleOptions) => BlokkliModule<ChartsModuleOptions>;
+
+export { _default as default };

package/dist/modules/charts/index.mjs

@@ -0,0 +1,57 @@
+import { createResolver } from '@nuxt/kit';
+import { d as defineBlokkliModule } from '../../shared/editor.CGf7C_0M.mjs';
+import { fileURLToPath } from 'node:url';
+import { d as defineCodeTemplate } from '../../shared/editor.6D5vApr0.mjs';
+
+function chartsConfigTemplate(options) {
+  return defineCodeTemplate(
+    "charts-config",
+    () => {
+      return `
+export const COLORS = ${JSON.stringify(options.colors)}
+`;
+    },
+    () => {
+      return `
+import type { ChartColor } from '#blokkli/charts/types'
+
+export const COLORS: Record<string, ChartColor>
+`;
+    },
+    {
+      context: "both",
+      write: true
+    }
+  );
+}
+
+const resolve = createResolver(
+  fileURLToPath(new URL("./", import.meta.url))
+).resolve;
+const index = defineBlokkliModule({
+  alterOptions(options) {
+    options.blokkliDirs ??= [];
+    options.blokkliDirs.push(resolve("./runtime/blokkli"));
+  },
+  setup({ context, helper, $t }, options) {
+    context.features.addFile(resolve("./runtime/features/charts/index.vue"));
+    context.addTemplate(chartsConfigTemplate(options));
+    helper.addAlias("#blokkli/charts/types", resolve("./runtime/types"));
+    helper.addAlias(
+      "#blokkli/charts/components",
+      resolve("./runtime/components")
+    );
+    context.registerComplexOptionType({
+      id: "chart",
+      typeName: "BlokkliChartData",
+      typePath: resolve("./runtime/types"),
+      editorComponentPath: resolve(
+        "./runtime/features/charts/Editor/index.vue"
+      ),
+      editorButtonLabel: $t("chartsEditButton", "Edit chart..."),
+      editorIcon: "bk_mdi_area_chart"
+    });
+  }
+});
+
+export { index as default };

package/dist/modules/charts/runtime/blokkli/skills/charts.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/charts/runtime/blokkli/skills/charts.js

@@ -0,0 +1,42 @@
+import { defineBlokkliAgentSkill } from "#blokkli/agent/server/skills";
+export default defineBlokkliAgentSkill({
+  name: "charts",
+  label: { en: "Working with charts", de: "Arbeiten mit Diagrammen" },
+  description: "How charts work in bl\xF6kkli. LOAD THIS when the user asks about charts or when you need to create or update a chart!",
+  getContents: () => `
+# Charts
+
+Charts are NOT a specific block bundle. Instead, charts are a **complex option type**: any block can have a JSON option with \`dataType: 'chart'\`. The chart data is stored as a JSON string in that option. The option key can be anything (e.g. "data", "chart", etc.) \u2014 the tools detect it automatically.
+
+## Key concept
+
+A "chart block" is any block whose definition has a JSON option with \`dataType: 'chart'\`. The chart tools automatically detect which option holds chart data, so you don't need to know the option key or bundle name.
+
+## Available tools
+
+- **get_chart_data**: Read the current chart data (type, categories, series, colors, typeOptions). Always call this first when modifying an existing chart!
+- **create_chart**: Create a new chart. Requires chart data (type, categories, series). The tool automatically finds which bundle in the target field has a chart option.
+- **update_chart**: Update an existing chart. Pass the block's UUID and only the properties you want to change (title, type, categories, series, categoryColors, footnotes, typeOptions).
+- **get_chart_type_options**: Get available typeOptions for a chart type. Call this to discover which rendering options exist (e.g. stacked, horizontal for bar charts) before setting typeOptions.
+
+## Workflow
+
+1. To **read** a chart's current state: use get_chart_data with the paragraph UUID.
+2. To **create** a chart: use create_chart with the data. The tool finds the right bundle automatically from the target field's allowed bundles.
+3. To **modify** a chart: first call get_chart_data to see the current state, then use update_chart with only the properties you want to change.
+4. To **change rendering options** (e.g. stacked bars, smooth lines, grid lines): first call get_chart_type_options with the chart type to see available options, then use update_chart with the typeOptions property.
+
+## Chart types
+
+bar, line, pie, area, donut, heatmap, radialBar, radar.
+
+- pie, donut, radialBar: Single-series charts where each category gets its own color (categoryColors).
+- bar, line, area, heatmap, radar: Multi-series charts where each series has its own color.
+
+Each chart type has different options!
+
+## Colors
+
+Series colors and category colors use color IDs defined in the project configuration. They are auto-assigned if omitted. The valid color IDs are part of the tool schemas (enum values).
+`
+});

package/dist/modules/charts/runtime/blokkli/tools/chart_schemas.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import type { BlokkliChartData, ChartColor } from '#blokkli/charts/types';
+import type { McpToolContext } from '#blokkli/agent/app/types';
+export declare const chartTypeEnum: z.ZodEnum<{
+    bar: "bar";
+    line: "line";
+    area: "area";
+    pie: "pie";
+    donut: "donut";
+    heatmap: "heatmap";
+    radialBar: "radialBar";
+    radar: "radar";
+}>;
+export declare const chartColorEnum: z.ZodEnum<{
+    [x: string]: string;
+}>;
+export declare const chartSeriesSchema: z.ZodObject<{
+    name: z.ZodString;
+    color: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+    data: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const chartDataSchema: z.ZodObject<{
+    title: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    type: z.ZodEnum<{
+        bar: "bar";
+        line: "line";
+        area: "area";
+        pie: "pie";
+        donut: "donut";
+        heatmap: "heatmap";
+        radialBar: "radialBar";
+        radar: "radar";
+    }>;
+    categories: z.ZodArray<z.ZodString>;
+    series: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        color: z.ZodOptional<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+        data: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    categoryColors: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>>;
+    footnotes: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    typeOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodBoolean, z.ZodNumber]>>>;
+}, z.core.$strip>;
+/**
+ * Validate and normalize chart data.
+ *
+ * - Checks series data length matches categories length
+ * - Auto-assigns missing series colors
+ * - Auto-assigns categoryColors for pie/donut/radialBar
+ * - Validates color IDs exist in the provided colors map
+ * - Validates typeOptions keys against the chart type definition
+ * - Fills typeOptions defaults
+ */
+export declare function validateChartData(data: BlokkliChartData, colors: Record<string, ChartColor>): {
+    error: string;
+} | {
+    data: BlokkliChartData;
+};
+/**
+ * Find the option key for a chart option on a block.
+ *
+ * Charts are stored as a JSON option with `dataType: 'chart'` on any block.
+ * This helper looks up the block's definition and returns the option key.
+ */
+export declare function findChartOptionKey(ctx: McpToolContext, uuid: string): {
+    key: string;
+} | {
+    error: string;
+};
+/**
+ * Find a bundle that has a chart option among a field's allowed bundles.
+ *
+ * Returns the bundle name and the option key for the chart data.
+ */
+export declare function findChartBundle(ctx: McpToolContext, allowedBundles: string[]): {
+    bundle: string;
+    key: string;
+} | {
+    error: string;
+};