@promptbook/cli 0.114.0-13 → 0.114.0-18

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

@@ -0,0 +1,183 @@
+/**
+ * One file an answered agent message created, edited or deleted inside one project.
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ *
+ * @private internal type of the agent-message runtime
+ */
+export type AgentMessageProjectChangedFile = {
+    /**
+     * Path of the file relative to the project root, using `/` separators.
+     */
+    readonly path: string;
+
+    /**
+     * Count of lines added to the file.
+     */
+    readonly insertionCount: number;
+
+    /**
+     * Count of lines removed from the file.
+     */
+    readonly deletionCount: number;
+};
+
+/**
+ * Everything answering one single message changed inside one agent project.
+ *
+ * Each agent project is a git repository and every answer which modifies it is committed there
+ * automatically, so this describes exactly one such commit — the trace of what one message really
+ * did to one project, which a chat can show below the answer that did it.
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ *
+ * @private internal type of the agent-message runtime
+ */
+export type AgentMessageProjectChange = {
+    /**
+     * Directory name of the changed project inside the agent `projects/` folder.
+     */
+    readonly projectName: string;
+
+    /**
+     * Full hash of the commit holding the changes of this message.
+     */
+    readonly commitHash: string;
+
+    /**
+     * ISO 8601 timestamp when the changes were committed.
+     */
+    readonly committedAt: string;
+
+    /**
+     * Files the message changed, ordered as git reports them.
+     */
+    readonly changedFiles: ReadonlyArray<AgentMessageProjectChangedFile>;
+
+    /**
+     * Count of lines added across all changed files.
+     */
+    readonly insertionCount: number;
+
+    /**
+     * Count of lines removed across all changed files.
+     */
+    readonly deletionCount: number;
+
+    /**
+     * Unified diff of the commit, shortened when the change is too large to carry into a chat.
+     */
+    readonly diff: string;
+
+    /**
+     * Whether `diff` holds only the beginning of the real diff.
+     */
+    readonly isDiffTruncated: boolean;
+};
+
+/**
+ * Validates one already-parsed JSON value as a project change.
+ *
+ * @param value - Raw serialized project change.
+ * @returns The typed project change, or `null` when the value does not match the expected shape,
+ * so consumers can silently skip foreign or malformed entries.
+ *
+ * @private internal utility of the agent-message runtime
+ */
+export function normalizeAgentMessageProjectChange(value: unknown): AgentMessageProjectChange | null {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+
+    const candidate = value as Partial<AgentMessageProjectChange>;
+    if (!isNonEmptyString(candidate.projectName) || !isNonEmptyString(candidate.commitHash)) {
+        return null;
+    }
+
+    if (!isNonEmptyString(candidate.committedAt) || !Number.isFinite(Date.parse(candidate.committedAt))) {
+        return null;
+    }
+
+    if (!Array.isArray(candidate.changedFiles)) {
+        return null;
+    }
+
+    const changedFiles = candidate.changedFiles.map((changedFile) =>
+        normalizeAgentMessageProjectChangedFile(changedFile),
+    );
+    if (changedFiles.some((changedFile) => changedFile === null)) {
+        return null;
+    }
+
+    if (!isChangeCount(candidate.insertionCount) || !isChangeCount(candidate.deletionCount)) {
+        return null;
+    }
+
+    if (typeof candidate.diff !== 'string' || typeof candidate.isDiffTruncated !== 'boolean') {
+        return null;
+    }
+
+    return {
+        projectName: candidate.projectName.trim(),
+        commitHash: candidate.commitHash.trim(),
+        committedAt: candidate.committedAt,
+        changedFiles: changedFiles as ReadonlyArray<AgentMessageProjectChangedFile>,
+        insertionCount: candidate.insertionCount,
+        deletionCount: candidate.deletionCount,
+        diff: candidate.diff,
+        isDiffTruncated: candidate.isDiffTruncated,
+    };
+}
+
+/**
+ * Validates one already-parsed JSON value as a changed project file.
+ *
+ * @param value - Raw serialized changed file.
+ * @returns The typed changed file, or `null` when the value does not match the expected shape.
+ *
+ * @private internal helper of `normalizeAgentMessageProjectChange`
+ */
+function normalizeAgentMessageProjectChangedFile(value: unknown): AgentMessageProjectChangedFile | null {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+
+    const candidate = value as Partial<AgentMessageProjectChangedFile>;
+    if (!isNonEmptyString(candidate.path)) {
+        return null;
+    }
+
+    if (!isChangeCount(candidate.insertionCount) || !isChangeCount(candidate.deletionCount)) {
+        return null;
+    }
+
+    return {
+        path: candidate.path.trim(),
+        insertionCount: candidate.insertionCount,
+        deletionCount: candidate.deletionCount,
+    };
+}
+
+/**
+ * Checks that one value is a usable non-empty string.
+ *
+ * @param value - Raw serialized value.
+ * @returns Whether the value is a string carrying content.
+ *
+ * @private internal helper of `normalizeAgentMessageProjectChange`
+ */
+function isNonEmptyString(value: unknown): value is string {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+
+/**
+ * Checks that one value is a line count git could have reported.
+ *
+ * @param value - Raw serialized value.
+ * @returns Whether the value is a non-negative finite number.
+ *
+ * @private internal helper of `normalizeAgentMessageProjectChange`
+ */
+function isChangeCount(value: unknown): value is number {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}

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

@@ -0,0 +1,80 @@
+/**
+ * Category of one external source an answered agent message touched.
+ *
+ * -   `integration` is a third-party service reached through an integration, for example Gmail.
+ * -   `website` is a concrete web address the agent fetched or browsed.
+ * -   `search` is a lookup the agent ran against a web search engine.
+ *
+ * @private internal type of the agent-message runtime
+ */
+export type AgentMessageTouchedExternalSourceKind = 'integration' | 'website' | 'search';
+
+/**
+ * One source outside the agent itself which answering a single message viewed or edited.
+ *
+ * Everything the agent does inside its own folder stays internal and is never described here;
+ * this records only the reach beyond it, so a chat can tell which outside services and websites
+ * one answer really involved.
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ *
+ * @private internal type of the agent-message runtime
+ */
+export type AgentMessageTouchedExternalSource = {
+    /**
+     * Category of the touched source.
+     */
+    readonly kind: AgentMessageTouchedExternalSourceKind;
+
+    /**
+     * User-facing name of the source, for example `Gmail`, `example.com` or the search query.
+     */
+    readonly name: string;
+
+    /**
+     * Address of the source, when the touch names a concrete one.
+     */
+    readonly url?: string;
+};
+
+/**
+ * Validates one already-parsed JSON value as a touched external source.
+ *
+ * @param value - Raw serialized source.
+ * @returns The typed source, or `null` when the value does not match the expected shape, so
+ * consumers can silently skip foreign or malformed entries.
+ *
+ * @private internal utility of the agent-message runtime
+ */
+export function normalizeAgentMessageTouchedExternalSource(value: unknown): AgentMessageTouchedExternalSource | null {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+
+    const candidate = value as Partial<AgentMessageTouchedExternalSource>;
+    if (!isAgentMessageTouchedExternalSourceKind(candidate.kind)) {
+        return null;
+    }
+
+    if (typeof candidate.name !== 'string' || candidate.name.trim().length === 0) {
+        return null;
+    }
+
+    return {
+        kind: candidate.kind,
+        name: candidate.name.trim(),
+        ...(typeof candidate.url === 'string' && candidate.url.trim().length > 0 ? { url: candidate.url.trim() } : {}),
+    };
+}
+
+/**
+ * Checks that one value is a known external source category.
+ *
+ * @param value - Raw serialized kind.
+ * @returns Whether the value names one of the supported categories.
+ *
+ * @private internal helper of `normalizeAgentMessageTouchedExternalSource`
+ */
+function isAgentMessageTouchedExternalSourceKind(value: unknown): value is AgentMessageTouchedExternalSourceKind {
+    return value === 'integration' || value === 'website' || value === 'search';
+}

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

@@ -45,6 +45,9 @@ export type AgentMessageRuntimeLogEvent = {
         readonly command?: string;
         readonly exit_code?: number | null;
         readonly changes?: ReadonlyArray<AgentMessageRuntimeLogFileChange>;
+        readonly server?: string;
+        readonly tool?: string;
+        readonly query?: string;
     };
 };
 

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

@@ -30,8 +30,7 @@ type CodexCommandActivity = {
  */
 const CODEX_COMMAND_ACTIVITIES: ReadonlyArray<CodexCommandActivity> = [
     {
-        pattern:
-            /(^|\s)(npm\s+(?:run\s+)?test|pnpm\s+(?:run\s+)?test|yarn\s+test|jest|vitest|pytest)\b/u,
+        pattern: /(^|\s)(npm\s+(?:run\s+)?test|pnpm\s+(?:run\s+)?test|yarn\s+test|jest|vitest|pytest)\b/u,
         running: 'Running tests.',
         completed: 'Finished running tests.',
     },
@@ -56,8 +55,7 @@ const CODEX_COMMAND_ACTIVITIES: ReadonlyArray<CodexCommandActivity> = [
         completed: 'Finished reviewing changes.',
     },
     {
-        pattern:
-            /(^|\s)(apply_patch|set-content|add-content|out-file|new-item|copy-item|move-item|set-item)\b/u,
+        pattern: /(^|\s)(apply_patch|set-content|add-content|out-file|new-item|copy-item|move-item|set-item)\b/u,
         running: 'Updating relevant files.',
         completed: 'Finished updating relevant files.',
     },

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

@@ -0,0 +1,341 @@
+import { capitalize } from '../normalization/capitalize';
+import type { AgentMessageTouchedExternalSource } from './AgentMessageTouchedExternalSource';
+import type {
+    AgentMessageRuntimeLogContentBlock,
+    AgentMessageRuntimeLogEvent,
+} from './parseAgentMessageRuntimeLogEvents';
+import { parseAgentMessageRuntimeLogEvents } from './parseAgentMessageRuntimeLogEvents';
+
+/**
+ * Maximum count of external sources reported for one answered message.
+ *
+ * A single answer can reach the same kind of source many times, so the chip row below it stays
+ * readable by keeping only the sources touched first.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const MAX_TOUCHED_EXTERNAL_SOURCES = 12;
+
+/**
+ * Maximum length of one search query shown as the name of a touched search source.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const MAX_SEARCH_QUERY_LENGTH = 48;
+
+/**
+ * Separator between the segments of one integration tool name, as in `mcp__gmail__create_draft`.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const INTEGRATION_TOOL_NAME_SEPARATOR = '__';
+
+/**
+ * First segment marking one tool name as belonging to an integration.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const INTEGRATION_TOOL_NAME_PREFIX = 'mcp';
+
+/**
+ * Names of the harness tools which look something up on the web, indexed for case-insensitive matching.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const WEB_SEARCH_TOOL_NAMES: ReadonlySet<string> = new Set(
+    ['WebSearch', 'web_search'].map((webSearchToolName) => webSearchToolName.toLowerCase()),
+);
+
+/**
+ * Matches one shell command invoking a network client, whose arguments therefore address the outside world.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const NETWORK_CLIENT_COMMAND_REGEX = /(^|[\s|;&(])(curl|wget|invoke-webrequest|iwr)\b/iu;
+
+/**
+ * Matches one web address inside a shell command.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const COMMAND_URL_REGEX = /https?:\/\/[^\s"'`<>)\]]+/giu;
+
+/**
+ * Separators used between the words of one integration name.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const INTEGRATION_NAME_WORD_SEPARATOR_REGEX = /[-_.\s]+/gu;
+
+/**
+ * Hostnames which address the machine the agent runs on and are therefore not external.
+ *
+ * @private internal constant of agent-message touched external sources
+ */
+const LOCAL_HOSTNAMES: ReadonlySet<string> = new Set(['localhost', '127.0.0.1', '0.0.0.0', '::1', '[::1]']);
+
+/**
+ * Resolves which sources outside the agent one coding harness touched while answering a single message.
+ *
+ * The runtime log streams what the harness really did, so a source counts as touched when the
+ * harness reached it in a tool invocation — calling an integration, fetching a web address,
+ * searching the web, or running a network client in the shell. Only tool payloads are inspected:
+ * tool results and assistant narration are ignored so a service merely mentioned in the
+ * conversation is never reported, and addresses of the machine the agent runs on are dropped
+ * because they are internal.
+ *
+ * @param options - Raw runtime log content of one answered message.
+ * @returns Touched external sources without duplicates, ordered by first appearance.
+ * @private internal utility of the agent-message runtime
+ */
+export function resolveAgentMessageTouchedExternalSources(options: {
+    readonly logText: string | null | undefined;
+}): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    const touchedExternalSources = new Map<string, AgentMessageTouchedExternalSource>();
+
+    for (const event of parseAgentMessageRuntimeLogEvents(options.logText)) {
+        for (const externalSource of resolveRuntimeLogEventExternalSources(event)) {
+            const externalSourceKey = createExternalSourceKey(externalSource);
+
+            if (!touchedExternalSources.has(externalSourceKey)) {
+                touchedExternalSources.set(externalSourceKey, externalSource);
+            }
+
+            if (touchedExternalSources.size === MAX_TOUCHED_EXTERNAL_SOURCES) {
+                return Array.from(touchedExternalSources.values());
+            }
+        }
+    }
+
+    return Array.from(touchedExternalSources.values());
+}
+
+/**
+ * Collects every external source described by one runtime log event.
+ *
+ * Claude Code reports tool invocations as `tool_use` content blocks, while Codex reports executed
+ * commands, web searches, and integration calls as items.
+ *
+ * @param event - One structured runtime log event.
+ * @returns External sources the event reached, possibly with duplicates.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveRuntimeLogEventExternalSources(
+    event: AgentMessageRuntimeLogEvent,
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    const externalSources: Array<AgentMessageTouchedExternalSource> = [];
+
+    for (const contentBlock of event.message?.content || []) {
+        if (contentBlock.type === 'tool_use') {
+            externalSources.push(...resolveToolUseExternalSources(contentBlock));
+        }
+    }
+
+    externalSources.push(...resolveCodexItemExternalSources(event.item));
+
+    return externalSources;
+}
+
+/**
+ * Collects the external sources reached by one Claude Code tool invocation.
+ *
+ * @param contentBlock - One `tool_use` content block.
+ * @returns External sources the invocation reached.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveToolUseExternalSources(
+    contentBlock: AgentMessageRuntimeLogContentBlock,
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    const toolName = contentBlock.name || '';
+    const toolInput = contentBlock.input || {};
+
+    return collectDefinedExternalSources([
+        createIntegrationExternalSource(resolveIntegrationName(toolName)),
+        typeof toolInput.url === 'string' ? createWebsiteExternalSource(toolInput.url) : null,
+        WEB_SEARCH_TOOL_NAMES.has(toolName.toLowerCase()) && typeof toolInput.query === 'string'
+            ? createSearchExternalSource(toolInput.query)
+            : null,
+        ...(typeof toolInput.command === 'string' ? resolveNetworkCommandExternalSources(toolInput.command) : []),
+    ]);
+}
+
+/**
+ * Collects the external sources reached by one Codex runtime item.
+ *
+ * @param item - One Codex item of a runtime log event.
+ * @returns External sources the item reached.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveCodexItemExternalSources(
+    item: AgentMessageRuntimeLogEvent['item'],
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    if (!item) {
+        return [];
+    }
+
+    return collectDefinedExternalSources([
+        item.type === 'mcp_tool_call'
+            ? createIntegrationExternalSource(item.server || resolveIntegrationName(item.tool || ''))
+            : null,
+        item.type === 'web_search' && typeof item.query === 'string' ? createSearchExternalSource(item.query) : null,
+        ...(typeof item.command === 'string' ? resolveNetworkCommandExternalSources(item.command) : []),
+    ]);
+}
+
+/**
+ * Drops the candidates which turned out not to describe an external source.
+ *
+ * @param candidates - Resolved sources mixed with the candidates that resolved to nothing.
+ * @returns Only the sources which were resolved.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function collectDefinedExternalSources(
+    candidates: ReadonlyArray<AgentMessageTouchedExternalSource | null>,
+): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    return candidates.filter((candidate): candidate is AgentMessageTouchedExternalSource => candidate !== null);
+}
+
+/**
+ * Resolves the integration a tool name belongs to, following the `mcp__<integration>__<tool>` convention.
+ *
+ * @param toolName - Raw harness tool name.
+ * @returns Raw integration name, or `null` when the tool belongs to no integration.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveIntegrationName(toolName: string): string | null {
+    const toolNameSegments = toolName.split(INTEGRATION_TOOL_NAME_SEPARATOR);
+
+    if (toolNameSegments.length < 3 || toolNameSegments[0]!.toLowerCase() !== INTEGRATION_TOOL_NAME_PREFIX) {
+        return null;
+    }
+
+    return toolNameSegments[1] || null;
+}
+
+/**
+ * Creates one touched integration source.
+ *
+ * @param integrationName - Raw integration name, or `null` when there is none.
+ * @returns Touched source, or `null` when the integration cannot be named.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createIntegrationExternalSource(integrationName: string | null): AgentMessageTouchedExternalSource | null {
+    const humanizedIntegrationName = humanizeIntegrationName(integrationName || '');
+
+    if (humanizedIntegrationName === '') {
+        return null;
+    }
+
+    return { kind: 'integration', name: humanizedIntegrationName };
+}
+
+/**
+ * Creates one touched website source.
+ *
+ * @param rawUrl - Raw web address the harness reached.
+ * @returns Touched source, or `null` when the address is unusable or addresses the local machine.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createWebsiteExternalSource(rawUrl: string): AgentMessageTouchedExternalSource | null {
+    let url: URL;
+    try {
+        url = new URL(rawUrl.trim());
+    } catch {
+        return null;
+    }
+
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return null;
+    }
+
+    const hostname = url.hostname.toLowerCase();
+    if (hostname === '' || LOCAL_HOSTNAMES.has(hostname) || hostname.endsWith('.localhost')) {
+        return null;
+    }
+
+    return { kind: 'website', name: hostname, url: url.href };
+}
+
+/**
+ * Creates one touched web search source.
+ *
+ * @param query - Raw query the harness looked up.
+ * @returns Touched source, or `null` when the query is empty.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createSearchExternalSource(query: string): AgentMessageTouchedExternalSource | null {
+    const normalizedQuery = query.replace(/\s+/gu, ' ').trim();
+
+    if (normalizedQuery === '') {
+        return null;
+    }
+
+    return {
+        kind: 'search',
+        name:
+            normalizedQuery.length <= MAX_SEARCH_QUERY_LENGTH
+                ? normalizedQuery
+                : `${normalizedQuery.slice(0, MAX_SEARCH_QUERY_LENGTH).trimEnd()}…`,
+    };
+}
+
+/**
+ * Collects the websites addressed by one shell command running a network client.
+ *
+ * Commands which do not invoke a network client are ignored, so a web address that merely appears
+ * in the text the agent writes into a file is never reported as touched.
+ *
+ * @param command - One executed shell command.
+ * @returns Touched website sources of the command.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function resolveNetworkCommandExternalSources(command: string): ReadonlyArray<AgentMessageTouchedExternalSource> {
+    if (!NETWORK_CLIENT_COMMAND_REGEX.test(command)) {
+        return [];
+    }
+
+    const commandUrlRegex = new RegExp(COMMAND_URL_REGEX.source, COMMAND_URL_REGEX.flags);
+    const externalSources: Array<AgentMessageTouchedExternalSource> = [];
+    let commandUrlMatch = commandUrlRegex.exec(command);
+
+    while (commandUrlMatch !== null) {
+        const externalSource = createWebsiteExternalSource(commandUrlMatch[0]);
+
+        if (externalSource) {
+            externalSources.push(externalSource);
+        }
+
+        commandUrlMatch = commandUrlRegex.exec(command);
+    }
+
+    return externalSources;
+}
+
+/**
+ * Converts one raw integration name into its user-facing form.
+ *
+ * For example `google-calendar` becomes `Google Calendar`.
+ *
+ * @param integrationName - Raw integration name.
+ * @returns Human-readable integration name, or an empty string when there is nothing to show.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function humanizeIntegrationName(integrationName: string): string {
+    return integrationName
+        .trim()
+        .split(INTEGRATION_NAME_WORD_SEPARATOR_REGEX)
+        .filter((integrationNameWord) => integrationNameWord !== '')
+        .map((integrationNameWord) => capitalize(integrationNameWord))
+        .join(' ');
+}
+
+/**
+ * Builds the key identifying one external source across the whole run.
+ *
+ * @param externalSource - One touched external source.
+ * @returns Key under which repeated touches of the same source collapse into one.
+ * @private internal helper of `resolveAgentMessageTouchedExternalSources`
+ */
+function createExternalSourceKey(externalSource: AgentMessageTouchedExternalSource): string {
+    return `${externalSource.kind}:${externalSource.name.toLowerCase()}`;
+}

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-13';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-18';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.114.0-12`).
+ * It follows semantic versioning (e.g., `0.114.0-17`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1189,3 +1189,8 @@
 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