@promptbook/cli 0.114.0-2 → 0.114.0-21

package/src/utils/agent-message-runtime/resolveAgentMessageTouchedProjectNames.ts

@@ -0,0 +1,147 @@
+import { AGENT_PROJECTS_DIRECTORY_PATH } from '../../book-3.0/agentFolderPaths';
+import type { AgentMessageRuntimeLogEvent } from './parseAgentMessageRuntimeLogEvents';
+import { parseAgentMessageRuntimeLogEvents } from './parseAgentMessageRuntimeLogEvents';
+
+/**
+ * Matches one project directory name following the agent `projects/` folder in a file path or command.
+ *
+ * Both path separators are accepted because the local runner answers messages on Unix and Windows,
+ * and JSON-encoded payloads escape backslashes.
+ *
+ * @private internal constant of agent-message touched projects
+ */
+const TOUCHED_PROJECT_PATH_REGEX = new RegExp(`${AGENT_PROJECTS_DIRECTORY_PATH}[\\\\/]+([^\\\\/"'\\s,;:]+)`, 'giu');
+
+/**
+ * Resolves which projects one coding harness touched while answering a single message.
+ *
+ * The runtime log streams what the harness really did, so a project counts as touched when the
+ * harness named it in a tool invocation — reading, searching, running, or editing files inside
+ * `projects/<project-name>/`. Only tool payloads are inspected: tool results and assistant
+ * narration are ignored so a project merely mentioned in the conversation is never reported.
+ *
+ * Every candidate is matched against the projects that really exist, which both filters prompt
+ * placeholders such as `projects/<project-name>/` and keeps the reported names canonical.
+ *
+ * @param options - Raw runtime log content and the project directory names of the agent.
+ * @returns Touched project names in the canonical spelling, ordered by first appearance.
+ * @private internal utility of the agent-message runtime
+ */
+export function resolveAgentMessageTouchedProjectNames(options: {
+    readonly logText: string | null | undefined;
+    readonly knownProjectNames: ReadonlyArray<string>;
+}): ReadonlyArray<string> {
+    const canonicalProjectNames = createCanonicalProjectNameLookup(options.knownProjectNames);
+    if (canonicalProjectNames.size === 0) {
+        return [];
+    }
+
+    const touchedProjectNames = new Set<string>();
+
+    for (const event of parseAgentMessageRuntimeLogEvents(options.logText)) {
+        for (const toolInvocationText of resolveRuntimeLogEventToolInvocationTexts(event)) {
+            for (const candidateProjectName of resolveCandidateProjectNames(toolInvocationText)) {
+                const canonicalProjectName = canonicalProjectNames.get(candidateProjectName.toLowerCase());
+
+                if (canonicalProjectName !== undefined) {
+                    touchedProjectNames.add(canonicalProjectName);
+                }
+            }
+        }
+    }
+
+    return Array.from(touchedProjectNames);
+}
+
+/**
+ * Indexes the existing project directory names by their lower-cased form.
+ *
+ * @param knownProjectNames - Project directory names of the agent.
+ * @returns Lookup from the lower-cased name to its canonical spelling.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function createCanonicalProjectNameLookup(knownProjectNames: ReadonlyArray<string>): Map<string, string> {
+    const canonicalProjectNames = new Map<string, string>();
+
+    for (const knownProjectName of knownProjectNames) {
+        const normalizedProjectName = knownProjectName.trim();
+
+        if (normalizedProjectName.length > 0) {
+            canonicalProjectNames.set(normalizedProjectName.toLowerCase(), normalizedProjectName);
+        }
+    }
+
+    return canonicalProjectNames;
+}
+
+/**
+ * Collects the texts of every tool invocation described by one runtime log event.
+ *
+ * Claude Code reports tool invocations as `tool_use` content blocks, while Codex reports executed
+ * commands and file changes as items — both carry the paths the harness worked with.
+ *
+ * @param event - One structured runtime log event.
+ * @returns Texts that may contain project paths.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function resolveRuntimeLogEventToolInvocationTexts(event: AgentMessageRuntimeLogEvent): ReadonlyArray<string> {
+    const toolInvocationTexts: Array<string> = [];
+
+    for (const contentBlock of event.message?.content || []) {
+        if (contentBlock.type === 'tool_use' && contentBlock.input) {
+            toolInvocationTexts.push(serializeToolInput(contentBlock.input));
+        }
+    }
+
+    if (typeof event.item?.command === 'string') {
+        toolInvocationTexts.push(event.item.command);
+    }
+
+    for (const fileChange of event.item?.changes || []) {
+        if (typeof fileChange.path === 'string') {
+            toolInvocationTexts.push(fileChange.path);
+        }
+    }
+
+    return toolInvocationTexts;
+}
+
+/**
+ * Serializes one tool input payload into scannable text.
+ *
+ * @param toolInput - Tool arguments of one harness tool invocation.
+ * @returns Serialized payload, or an empty string when it cannot be serialized.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function serializeToolInput(toolInput: Record<string, unknown>): string {
+    try {
+        return JSON.stringify(toolInput);
+    } catch {
+        return '';
+    }
+}
+
+/**
+ * Extracts every project directory name mentioned right after the agent `projects/` folder.
+ *
+ * @param toolInvocationText - One tool payload, command, or changed path.
+ * @returns Candidate project directory names.
+ * @private internal helper of `resolveAgentMessageTouchedProjectNames`
+ */
+function resolveCandidateProjectNames(toolInvocationText: string): ReadonlyArray<string> {
+    const candidateProjectNames: Array<string> = [];
+    const projectPathRegex = new RegExp(TOUCHED_PROJECT_PATH_REGEX.source, TOUCHED_PROJECT_PATH_REGEX.flags);
+    let projectPathMatch = projectPathRegex.exec(toolInvocationText);
+
+    while (projectPathMatch !== null) {
+        const candidateProjectName = projectPathMatch[1];
+
+        if (candidateProjectName) {
+            candidateProjectNames.push(candidateProjectName);
+        }
+
+        projectPathMatch = projectPathRegex.exec(toolInvocationText);
+    }
+
+    return candidateProjectNames;
+}

package/src/utils/agents/terminalAgentAvatarVisual.ts

@@ -6,6 +6,7 @@ import type { ResolvedAvatarRenderDefinition } from '../../avatars/renderAvatarV
 import { resolveAvatarRenderDefinition } from '../../avatars/renderAvatarVisual';
 import type { CreateCanvasForAsciiArt } from '../../avatars/renderAvatarVisualAsciiArt';
 import { renderAvatarVisualAsciiArt } from '../../avatars/renderAvatarVisualAsciiArt';
+import { renderAvatarVisualTerminalTextLines } from '../../avatars/renderAvatarVisualTerminalText';
 import type { AvatarDefinition } from '../../avatars/types/AvatarDefinition';
 import type { AvatarVisualId } from '../../avatars/types/AvatarVisualDefinition';
 import { resolveAvatarVisualId } from '../../avatars/visuals/avatarVisualRegistry';
@@ -127,9 +128,12 @@ export type CreateTerminalAgentAvatarVisualOptions = {
     readonly colorDepth?: AsciiArtColorDepth;
 
     /**
-     * Platform-specific canvas factory used to rasterize the visual.
+     * Platform-specific canvas factory used to rasterize pixel-based visuals.
+     *
+     * Character-based visuals such as `AsciiOctopus` paint the terminal grid directly, so they
+     * render without any canvas; a pixel-based visual renders an empty frame when it is missing.
      */
-    readonly createCanvas: CreateCanvasForAsciiArt;
+    readonly createCanvas?: CreateCanvasForAsciiArt;
 };
 
 /**
@@ -251,15 +255,39 @@ function resolveTerminalAgentAvatarVisualIdFromAgentBasicInformation(
 /**
  * Renders one terminal avatar frame through the shared avatar-to-ASCII pipeline.
  *
+ * Visuals which are made of characters themselves, for example `AsciiOctopus`, paint the terminal
+ * character grid directly, because rasterizing them into half-block ASCII art averages every glyph
+ * away and makes them indistinguishable from the other blob-shaped visuals.
+ *
  * @private shared helper for terminal avatar rendering
  */
 function renderTerminalAgentAvatarVisualFrame(
     options: TerminalAgentAvatarVisualRenderInputs & {
         readonly animationTimeMs: number;
         readonly colorDepth?: AsciiArtColorDepth;
-        readonly createCanvas: CreateCanvasForAsciiArt;
+        readonly createCanvas?: CreateCanvasForAsciiArt;
     },
 ): ReadonlyArray<string> {
+    const terminalTextLines = renderAvatarVisualTerminalTextLines({
+        avatarDefinition: options.avatarDefinition,
+        visualId: options.avatarVisualId,
+        surface: 'transparent',
+        columns: TERMINAL_AGENT_AVATAR_VISUAL_COLUMNS,
+        rows: TERMINAL_AGENT_AVATAR_VISUAL_ROWS,
+        colorDepth: options.colorDepth,
+        timeMs: options.animationTimeMs,
+        resolvedAvatarRenderDefinition: options.resolvedAvatarRenderDefinition,
+    });
+
+    if (terminalTextLines !== null) {
+        return terminalTextLines;
+    }
+
+    if (options.createCanvas === undefined) {
+        // Note: A pixel-based visual cannot be rasterized without a canvas, so the caller renders no avatar
+        return [];
+    }
+
     return renderAvatarVisualAsciiArt({
         avatarDefinition: options.avatarDefinition,
         visualId: options.avatarVisualId,

package/src/utils/ascii-art/convertImageDataToAsciiArt.ts

@@ -1,5 +1,7 @@
 import { spaceTrim } from 'spacetrim';
 import { UnexpectedError } from '../../errors/UnexpectedError';
+import type { AnsiRgbColor } from './createAnsiColorCode';
+import { ANSI_RESET, createAnsiBackgroundColorCode, createAnsiForegroundColorCode } from './createAnsiColorCode';
 
 /**
  * Color depth of the ANSI escape codes emitted by the ASCII-art conversion.
@@ -75,11 +77,11 @@ export type ConvertImageDataToAsciiArtOptions = {
 };
 
 /**
- * Default alpha channel value below which a half-cell is rendered as terminal background.
+ * Default alpha channel value below which a cell is rendered as terminal background.
  *
  * @private within the repository
  */
-const DEFAULT_ALPHA_THRESHOLD = 32;
+export const DEFAULT_ALPHA_THRESHOLD = 32;
 
 /**
  * Number of channels per pixel in an RGBA buffer.
@@ -102,57 +104,12 @@ const UPPER_HALF_BLOCK = '▀'; // <- ▀
  */
 const LOWER_HALF_BLOCK = '▄'; // <- ▄
 
-/**
- * ANSI escape sequence that resets all colors and attributes.
- *
- * @private within the repository
- */
-const ANSI_RESET = '\u001b[0m';
-
-/**
- * Maximum spread between RGB channels for a color to be treated as (nearly) achromatic gray.
- *
- * @private within the repository
- */
-const ANSI_256_ACHROMATIC_CHANNEL_SPREAD = 12;
-
-/**
- * Gray level above which an achromatic color maps to the pure white color-cube entry.
- *
- * @private within the repository
- */
-const ANSI_256_NEAR_WHITE_GRAY_LEVEL = 246;
-
-/**
- * Index of pure white inside the 6×6×6 ANSI color cube.
- *
- * @private within the repository
- */
-const ANSI_256_WHITE_INDEX = 231;
-
-/**
- * Brightness of the lightest entry of the ANSI 256 grayscale ramp.
- *
- * @private within the repository
- */
-const ANSI_256_GRAYSCALE_RAMP_MAX_LEVEL = 238;
-
-/**
- * Number of grayscale ramp steps above its first entry (ANSI indexes 232-255).
- *
- * @private within the repository
- */
-const ANSI_256_GRAYSCALE_RAMP_INDEX_SPAN = 23;
-
 /**
  * Area-averaged color of one half of a character cell.
  *
  * @private helper of `convertImageDataToAsciiArt`
  */
-type HalfCellColor = {
-    readonly red: number;
-    readonly green: number;
-    readonly blue: number;
+type HalfCellColor = AnsiRgbColor & {
     readonly isOpaque: boolean;
 };
 
@@ -231,15 +188,15 @@ export function convertImageDataToAsciiArt(options: ConvertImageDataToAsciiArtOp
 
             if (topHalfColor.isOpaque && bottomHalfColor.isOpaque) {
                 character = UPPER_HALF_BLOCK;
-                nextForegroundCode = createForegroundColorCode(topHalfColor, colorDepth);
-                nextBackgroundCode = createBackgroundColorCode(bottomHalfColor, colorDepth);
+                nextForegroundCode = createAnsiForegroundColorCode(topHalfColor, colorDepth);
+                nextBackgroundCode = createAnsiBackgroundColorCode(bottomHalfColor, colorDepth);
             } else if (topHalfColor.isOpaque) {
                 character = UPPER_HALF_BLOCK;
-                nextForegroundCode = createForegroundColorCode(topHalfColor, colorDepth);
+                nextForegroundCode = createAnsiForegroundColorCode(topHalfColor, colorDepth);
                 nextBackgroundCode = undefined;
             } else if (bottomHalfColor.isOpaque) {
                 character = LOWER_HALF_BLOCK;
-                nextForegroundCode = createForegroundColorCode(bottomHalfColor, colorDepth);
+                nextForegroundCode = createAnsiForegroundColorCode(bottomHalfColor, colorDepth);
                 nextBackgroundCode = undefined;
             } else {
                 character = ' ';
@@ -337,60 +294,3 @@ function computeHalfCellColor(
         isOpaque: true,
     };
 }
-
-/**
- * Creates the ANSI escape code that sets the foreground color of following characters.
- *
- * @private helper of `convertImageDataToAsciiArt`
- */
-function createForegroundColorCode(color: HalfCellColor, colorDepth: AsciiArtColorDepth): string {
-    if (colorDepth === 'TRUE_COLOR') {
-        return `\u001b[38;2;${color.red};${color.green};${color.blue}m`;
-    }
-
-    return `\u001b[38;5;${mapColorToAnsi256(color)}m`;
-}
-
-/**
- * Creates the ANSI escape code that sets the background color of following characters.
- *
- * @private helper of `convertImageDataToAsciiArt`
- */
-function createBackgroundColorCode(color: HalfCellColor, colorDepth: AsciiArtColorDepth): string {
-    if (colorDepth === 'TRUE_COLOR') {
-        return `\u001b[48;2;${color.red};${color.green};${color.blue}m`;
-    }
-
-    return `\u001b[48;5;${mapColorToAnsi256(color)}m`;
-}
-
-/**
- * Maps a 24-bit color onto the closest entry of the 256-color ANSI palette.
- *
- * Uses the 6×6×6 color cube (entries 16-231) and the grayscale ramp (entries 232-255).
- *
- * @private helper of `convertImageDataToAsciiArt`
- */
-function mapColorToAnsi256(color: HalfCellColor): number {
-    const { red, green, blue } = color;
-
-    // Note: Prefer the finer grayscale ramp when the color is (nearly) achromatic
-    const maxChannel = Math.max(red, green, blue);
-    const minChannel = Math.min(red, green, blue);
-    if (maxChannel - minChannel < ANSI_256_ACHROMATIC_CHANNEL_SPREAD) {
-        const gray = Math.round((red + green + blue) / 3);
-        if (gray < 4) {
-            return 16; // <- Note: Pure black lives in the color cube
-        }
-        if (gray > ANSI_256_NEAR_WHITE_GRAY_LEVEL) {
-            return ANSI_256_WHITE_INDEX; // <- Note: Pure white lives in the color cube
-        }
-        return 232 + Math.round(((gray - 8) / ANSI_256_GRAYSCALE_RAMP_MAX_LEVEL) * ANSI_256_GRAYSCALE_RAMP_INDEX_SPAN);
-    }
-
-    const redIndex = Math.round((red / 255) * 5);
-    const greenIndex = Math.round((green / 255) * 5);
-    const blueIndex = Math.round((blue / 255) * 5);
-
-    return 16 + 36 * redIndex + 6 * greenIndex + blueIndex;
-}

package/src/utils/ascii-art/createAnsiColorCode.ts

@@ -0,0 +1,132 @@
+import type { AsciiArtColorDepth } from './convertImageDataToAsciiArt';
+
+// Note: [💞] Ignore a discrepancy between file name and entity name
+
+/**
+ * ANSI escape sequence that resets all colors and attributes.
+ *
+ * @private within the repository
+ */
+export const ANSI_RESET = '\u001b[0m';
+
+/**
+ * Maximum spread between RGB channels for a color to be treated as (nearly) achromatic gray.
+ *
+ * @private within the repository
+ */
+const ANSI_256_ACHROMATIC_CHANNEL_SPREAD = 12;
+
+/**
+ * Gray level above which an achromatic color maps to the pure white color-cube entry.
+ *
+ * @private within the repository
+ */
+const ANSI_256_NEAR_WHITE_GRAY_LEVEL = 246;
+
+/**
+ * Index of pure white inside the 6×6×6 ANSI color cube.
+ *
+ * @private within the repository
+ */
+const ANSI_256_WHITE_INDEX = 231;
+
+/**
+ * Brightness of the lightest entry of the ANSI 256 grayscale ramp.
+ *
+ * @private within the repository
+ */
+const ANSI_256_GRAYSCALE_RAMP_MAX_LEVEL = 238;
+
+/**
+ * Number of grayscale ramp steps above its first entry (ANSI indexes 232-255).
+ *
+ * @private within the repository
+ */
+const ANSI_256_GRAYSCALE_RAMP_INDEX_SPAN = 23;
+
+/**
+ * One opaque 24-bit color which should be written into an ANSI escape sequence.
+ *
+ * @private within the repository
+ */
+export type AnsiRgbColor = {
+    /**
+     * Red channel in the range `[0, 255]`.
+     */
+    readonly red: number;
+
+    /**
+     * Green channel in the range `[0, 255]`.
+     */
+    readonly green: number;
+
+    /**
+     * Blue channel in the range `[0, 255]`.
+     */
+    readonly blue: number;
+};
+
+/**
+ * Creates the ANSI escape code that sets the foreground color of following characters.
+ *
+ * @param color Color painted onto the characters.
+ * @param colorDepth Color depth supported by the target terminal.
+ * @returns ANSI escape sequence.
+ *
+ * @private within the repository
+ */
+export function createAnsiForegroundColorCode(color: AnsiRgbColor, colorDepth: AsciiArtColorDepth): string {
+    if (colorDepth === 'TRUE_COLOR') {
+        return `\u001b[38;2;${color.red};${color.green};${color.blue}m`;
+    }
+
+    return `\u001b[38;5;${mapColorToAnsi256(color)}m`;
+}
+
+/**
+ * Creates the ANSI escape code that sets the background color of following characters.
+ *
+ * @param color Color painted behind the characters.
+ * @param colorDepth Color depth supported by the target terminal.
+ * @returns ANSI escape sequence.
+ *
+ * @private within the repository
+ */
+export function createAnsiBackgroundColorCode(color: AnsiRgbColor, colorDepth: AsciiArtColorDepth): string {
+    if (colorDepth === 'TRUE_COLOR') {
+        return `\u001b[48;2;${color.red};${color.green};${color.blue}m`;
+    }
+
+    return `\u001b[48;5;${mapColorToAnsi256(color)}m`;
+}
+
+/**
+ * Maps a 24-bit color onto the closest entry of the 256-color ANSI palette.
+ *
+ * Uses the 6×6×6 color cube (entries 16-231) and the grayscale ramp (entries 232-255).
+ *
+ * @private helper of `createAnsiForegroundColorCode` and `createAnsiBackgroundColorCode`
+ */
+function mapColorToAnsi256(color: AnsiRgbColor): number {
+    const { red, green, blue } = color;
+
+    // Note: Prefer the finer grayscale ramp when the color is (nearly) achromatic
+    const maxChannel = Math.max(red, green, blue);
+    const minChannel = Math.min(red, green, blue);
+    if (maxChannel - minChannel < ANSI_256_ACHROMATIC_CHANNEL_SPREAD) {
+        const gray = Math.round((red + green + blue) / 3);
+        if (gray < 4) {
+            return 16; // <- Note: Pure black lives in the color cube
+        }
+        if (gray > ANSI_256_NEAR_WHITE_GRAY_LEVEL) {
+            return ANSI_256_WHITE_INDEX; // <- Note: Pure white lives in the color cube
+        }
+        return 232 + Math.round(((gray - 8) / ANSI_256_GRAYSCALE_RAMP_MAX_LEVEL) * ANSI_256_GRAYSCALE_RAMP_INDEX_SPAN);
+    }
+
+    const redIndex = Math.round((red / 255) * 5);
+    const greenIndex = Math.round((green / 255) * 5);
+    const blueIndex = Math.round((blue / 255) * 5);
+
+    return 16 + 36 * redIndex + 6 * greenIndex + blueIndex;
+}

package/src/utils/misc/createLazyModuleLoader.ts

@@ -0,0 +1,27 @@
+/**
+ * Creates a loader which imports one module on the first call and reuses the very same module afterwards
+ *
+ * Note: [🐌] Heavy third-party dependencies are imported lazily to keep the startup of the Promptbook CLI fast.
+ *       A statically imported dependency is loaded every single time the bundle is loaded, even when the running
+ *       command never touches it. A lazily imported dependency is loaded only when the feature is really used.
+ *
+ * @example
+ * const loadJsdomModule = createLazyModuleLoader(() => import('jsdom'));
+ * const { JSDOM } = await loadJsdomModule();
+ *
+ * @private internal utility of Promptbook
+ */
+export function createLazyModuleLoader<TModule>(importModule: () => Promise<TModule>): () => Promise<TModule> {
+    let importedModulePromise: Promise<TModule> | null = null;
+
+    return function loadModule(): Promise<TModule> {
+        if (importedModulePromise === null) {
+            importedModulePromise = importModule();
+        }
+
+        return importedModulePromise;
+    };
+}
+
+// Note: [🐌] Do not convert the lazy `import(...)` calls back to static `import` statements, it would bring back the
+//       slow startup of the `ptbk` CLI utility

package/src/utils/misc/debounce.ts

@@ -1,14 +1,35 @@
 import type { TODO_any } from '../organization/TODO_any';
 
 /**
- * Handles debounce.
+ * Creates a debounced function that runs after calls have been quiet for the given delay.
  *
  * @public exported from `@promptbook/utils`
  */
-export function debounce<T extends (...args: TODO_any[]) => void>(fn: T, delay: number) {
+export function debounce<T extends (...args: TODO_any[]) => void>(
+    fn: T,
+    delay: number,
+): ((...args: Parameters<T>) => void) & { cancel: () => void } {
     let timeout: ReturnType<typeof setTimeout> | null = null;
-    return (...args: Parameters<T>) => {
-        if (timeout) clearTimeout(timeout);
-        timeout = setTimeout(() => fn(...args), delay);
+
+    const cancel = () => {
+        if (timeout === null) {
+            return;
+        }
+
+        clearTimeout(timeout);
+        timeout = null;
     };
+
+    const debounced = (...args: Parameters<T>) => {
+        cancel();
+
+        timeout = setTimeout(() => {
+            timeout = null;
+            fn(...args);
+        }, delay);
+    };
+
+    debounced.cancel = cancel;
+
+    return debounced;
 }

package/src/utils/random/$generateBookBoilerplate.ts

@@ -73,7 +73,7 @@ export function $generateBookBoilerplate(options?: GenerateBookBoilerplateOption
                 ${agentName}
     
                 
-                PERSONA ${block(personaDescription!)}
+                GOAL ${block(personaDescription!)}
                 ${block(initialRules.map((rule) => `RULE ${rule}`).join('\n'))}
                 CLOSED
             `,

package/src/version.ts

@@ -16,11 +16,11 @@ export const BOOK_LANGUAGE_VERSION: string_semantic_version = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-2';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-21';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.113.1-0`).
+ * It follows semantic versioning (e.g., `0.114.0-20`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1180,3 +1180,20 @@
 0.113.0
 0.113.1-0
 0.114.0-2
+0.114.0-3
+0.114.0-4
+0.114.0-5
+0.114.0-6
+0.114.0-8
+0.114.0-9
+0.114.0-10
+0.114.0-12
+0.114.0-13
+0.114.0-14
+0.114.0-15
+0.114.0-16
+0.114.0-17
+0.114.0-18
+0.114.0-19
+0.114.0-20
+0.114.0-21