@promptbook/browser 0.114.0-35 → 0.114.0-38

package/esm/src/book-2.0/agent-source/createAgentModelRequirements.deduplication.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/book-2.0/agent-source/deduplicateSystemMessage.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Removes duplicated instructions from a generated system message
+ *
+ * Commitments are applied one by one, so a commitment used multiple times in one book repeats its whole
+ * section, including the shared guidance preamble. For example two `WRITING RULES` commitments emit the
+ * `## Writing rules` heading and its guidance paragraph twice. This function merges all sections sharing
+ * one heading into the position of their first occurrence and keeps every identical block only once.
+ *
+ * @param systemMessage The assembled system message which may contain repeated sections and blocks
+ * @returns The system message where each section heading and each identical block appears exactly once
+ *
+ * @private internal utility of `createAgentModelRequirementsWithCommitments`
+ */
+export declare function deduplicateSystemMessage(systemMessage: string): string;

package/esm/src/book-2.0/agent-source/deduplicateSystemMessage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/src/cli/$initializePromptbookCliProgram.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+/**
+ * Registers the CLI commands on a fresh Commander program without parsing arguments or running an action.
+ * Tests can configure output and exit handling before registration, so subcommands inherit those settings.
+ *
+ * @private internal utility of `promptbookCli`
+ */
+export declare function $initializePromptbookCliProgram(program: Command): void;

package/esm/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.114.0-34`).
+ * It follows semantic versioning (e.g., `0.114.0-37`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/browser",
-    "version": "0.114.0-35",
+    "version": "0.114.0-38",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,
@@ -95,7 +95,7 @@
     "types": "./esm/src/_packages/browser.index.d.ts",
     "typings": "./esm/src/_packages/browser.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.114.0-35"
+        "@promptbook/core": "0.114.0-38"
     },
     "dependencies": {
         "@openai/agents": "0.4.15",

package/umd/index.umd.js

@@ -27,7 +27,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-35';
+    const PROMPTBOOK_ENGINE_VERSION = '0.114.0-38';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -27062,6 +27062,245 @@
         return Object.keys(rest).length > 0 ? rest : undefined;
     }
 
+    /**
+     * Pattern matching a markdown section heading (`## Title`) that separates system-message sections
+     *
+     * @private internal constant of `deduplicateSystemMessage`
+     */
+    const SYSTEM_MESSAGE_SECTION_HEADING_PATTERN = /^##(?!#)\s*(.+?)\s*$/;
+    /**
+     * Pattern matching a fenced code block delimiter which suspends section and block splitting
+     *
+     * @private internal constant of `deduplicateSystemMessage`
+     */
+    const CODE_FENCE_PATTERN = /^\s*(?:```|~~~)/;
+    /**
+     * Pattern matching a markdown list item which keeps merged bullet lists visually compact
+     *
+     * @private internal constant of `deduplicateSystemMessage`
+     */
+    const LIST_ITEM_PATTERN = /^\s*(?:[-*+]|\d+[.)])\s/;
+    /**
+     * Removes duplicated instructions from a generated system message
+     *
+     * Commitments are applied one by one, so a commitment used multiple times in one book repeats its whole
+     * section, including the shared guidance preamble. For example two `WRITING RULES` commitments emit the
+     * `## Writing rules` heading and its guidance paragraph twice. This function merges all sections sharing
+     * one heading into the position of their first occurrence and keeps every identical block only once.
+     *
+     * @param systemMessage The assembled system message which may contain repeated sections and blocks
+     * @returns The system message where each section heading and each identical block appears exactly once
+     *
+     * @private internal utility of `createAgentModelRequirementsWithCommitments`
+     */
+    function deduplicateSystemMessage(systemMessage) {
+        if (!systemMessage.trim()) {
+            return systemMessage;
+        }
+        return splitSystemMessageIntoRegions(systemMessage)
+            .reduce(mergeRegionSharingHeading, [])
+            .map(removeDuplicateBlocksFromRegion)
+            .map(renderRegion)
+            .filter((renderedRegion) => renderedRegion !== '')
+            .join('\n\n');
+    }
+    /**
+     * Splits the system message into the intro region and one region per `## Title` section
+     *
+     * @param systemMessage The system message to split
+     * @returns Regions in their original order, without empty ones
+     *
+     * @private internal utility of `deduplicateSystemMessage`
+     */
+    function splitSystemMessageIntoRegions(systemMessage) {
+        const regions = [];
+        let headingLine = null;
+        let bodyLines = [];
+        let isInsideCodeFence = false;
+        for (const line of systemMessage.split(/\r?\n/)) {
+            if (CODE_FENCE_PATTERN.test(line)) {
+                isInsideCodeFence = !isInsideCodeFence;
+            }
+            if (isInsideCodeFence || !SYSTEM_MESSAGE_SECTION_HEADING_PATTERN.test(line)) {
+                bodyLines.push(line);
+                continue;
+            }
+            regions.push(createRegion(headingLine, bodyLines));
+            headingLine = line;
+            bodyLines = [];
+        }
+        regions.push(createRegion(headingLine, bodyLines));
+        return regions.filter((region) => region.headingLine !== null || region.blocks.length > 0);
+    }
+    /**
+     * Creates one region from its heading line and its raw body lines
+     *
+     * @param headingLine The original `## Title` line, or `null` for the intro before the first heading
+     * @param bodyLines The raw lines following the heading line
+     * @returns The region with its body already split into blocks
+     *
+     * @private internal utility of `splitSystemMessageIntoRegions`
+     */
+    function createRegion(headingLine, bodyLines) {
+        return {
+            titleKey: headingLine === null ? null : normalizeSectionTitle(headingLine),
+            headingLine,
+            isBodySeparatedByBlankLine: bodyLines[0] !== undefined && bodyLines[0].trim() === '',
+            blocks: splitBodyIntoBlocks(bodyLines),
+        };
+    }
+    /**
+     * Normalizes a heading line into a key usable for matching sections which belong together
+     *
+     * @param headingLine The original `## Title` line
+     * @returns Lowercased title without the markdown heading prefix
+     *
+     * @private internal utility of `createRegion`
+     */
+    function normalizeSectionTitle(headingLine) {
+        var _a, _b;
+        return ((_b = (_a = SYSTEM_MESSAGE_SECTION_HEADING_PATTERN.exec(headingLine)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : headingLine).toLowerCase();
+    }
+    /**
+     * Splits raw body lines into blocks separated by blank lines while keeping fenced code blocks intact
+     *
+     * @param bodyLines The raw lines of one region body
+     * @returns Non-empty blocks in their original order
+     *
+     * @private internal utility of `createRegion`
+     */
+    function splitBodyIntoBlocks(bodyLines) {
+        const blockTexts = [];
+        let blockLines = [];
+        let isInsideCodeFence = false;
+        for (const line of bodyLines) {
+            if (CODE_FENCE_PATTERN.test(line)) {
+                isInsideCodeFence = !isInsideCodeFence;
+            }
+            if (!isInsideCodeFence && line.trim() === '') {
+                blockTexts.push(blockLines.join('\n'));
+                blockLines = [];
+                continue;
+            }
+            blockLines.push(line);
+        }
+        blockTexts.push(blockLines.join('\n'));
+        return blockTexts
+            .filter((blockText) => blockText.trim() !== '')
+            .map((blockText) => ({ text: blockText, isOpeningMergedSection: false }));
+    }
+    /**
+     * Appends one region to the already merged regions, merging it into an earlier region with the same heading
+     *
+     * @param mergedRegions Regions merged so far, used as the reducer accumulator
+     * @param region The next region in original order
+     * @returns The accumulator with the region either appended or merged into its earlier twin
+     *
+     * @private internal utility of `deduplicateSystemMessage`
+     */
+    function mergeRegionSharingHeading(mergedRegions, region) {
+        const existingRegionIndex = mergedRegions.findIndex((mergedRegion) => region.titleKey !== null && mergedRegion.titleKey === region.titleKey);
+        if (existingRegionIndex === -1) {
+            return [...mergedRegions, region];
+        }
+        return mergedRegions.map((mergedRegion, index) => index !== existingRegionIndex
+            ? mergedRegion
+            : {
+                ...mergedRegion,
+                blocks: [...mergedRegion.blocks, ...markFirstBlockAsOpeningMergedSection(region.blocks)],
+            });
+    }
+    /**
+     * Marks the first block of a merged section occurrence so the merge seam can be rendered as one list
+     *
+     * @param blocks The blocks of the section occurrence being merged into an earlier section
+     * @returns The same blocks with the first one marked as opening a merged section
+     *
+     * @private internal utility of `mergeRegionSharingHeading`
+     */
+    function markFirstBlockAsOpeningMergedSection(blocks) {
+        return blocks.map((block, index) => (index === 0 ? { ...block, isOpeningMergedSection: true } : block));
+    }
+    /**
+     * Keeps only the first occurrence of every identical block inside one region
+     *
+     * @param region The region whose blocks may repeat
+     * @returns The region without repeated blocks
+     *
+     * @private internal utility of `deduplicateSystemMessage`
+     */
+    function removeDuplicateBlocksFromRegion(region) {
+        const alreadyRenderedTexts = new Set();
+        const uniqueBlocks = [];
+        let isMergeSeamPending = false;
+        for (const block of region.blocks) {
+            if (alreadyRenderedTexts.has(block.text)) {
+                // Note: A removed block must still hand its merge seam over to the next block which survives
+                isMergeSeamPending = isMergeSeamPending || block.isOpeningMergedSection;
+                continue;
+            }
+            alreadyRenderedTexts.add(block.text);
+            uniqueBlocks.push({
+                text: block.text,
+                isOpeningMergedSection: block.isOpeningMergedSection || isMergeSeamPending,
+            });
+            isMergeSeamPending = false;
+        }
+        return { ...region, blocks: uniqueBlocks };
+    }
+    /**
+     * Renders one region back into its markdown representation
+     *
+     * @param region The region to render
+     * @returns The heading line together with its joined blocks
+     *
+     * @private internal utility of `deduplicateSystemMessage`
+     */
+    function renderRegion(region) {
+        const body = joinBlocks(region.blocks);
+        if (region.headingLine === null) {
+            return body;
+        }
+        if (body === '') {
+            return region.headingLine;
+        }
+        return `${region.headingLine}${region.isBodySeparatedByBlankLine ? '\n\n' : '\n'}${body}`;
+    }
+    /**
+     * Joins blocks of one region back together
+     *
+     * @param blocks The blocks to join in their original order
+     * @returns The joined body of one region
+     *
+     * @private internal utility of `renderRegion`
+     */
+    function joinBlocks(blocks) {
+        return blocks
+            .map((block, index) => index === 0 ? block.text : `${createBlockSeparator(blocks[index - 1], block)}${block.text}`)
+            .join('');
+    }
+    /**
+     * Chooses the separator between two neighboring blocks
+     *
+     * Blocks are normally separated by a blank line, exactly as they were written. Only where two sections were
+     * merged together their lists are joined into one compact list instead of two separate ones.
+     *
+     * @param previousBlock The block rendered before the separator
+     * @param nextBlock The block rendered after the separator
+     * @returns Either a single or a double newline
+     *
+     * @private internal utility of `joinBlocks`
+     */
+    function createBlockSeparator(previousBlock, nextBlock) {
+        if (!nextBlock.isOpeningMergedSection) {
+            return '\n\n';
+        }
+        const previousBlockLines = previousBlock.text.split('\n');
+        const isListContinuing = LIST_ITEM_PATTERN.test(previousBlockLines[previousBlockLines.length - 1]) &&
+            LIST_ITEM_PATTERN.test(nextBlock.text.split('\n')[0]);
+        return isListContinuing ? '\n' : '\n\n';
+    }
+
     /**
      * Removes single-hash comment lines (`# Comment`) from a system message
      * This is used to clean up the final system message before sending it to the AI model
@@ -27135,14 +27374,14 @@
      * Performs the final system-message cleanup pass after all other augmentation steps are complete.
      *
      * @param requirements - Fully built requirements before final cleanup.
-     * @returns Requirements with comment lines removed from the final system message.
+     * @returns Requirements with comment lines removed and repeated instructions deduplicated in the final system message.
      *
      * @private internal utility of `createAgentModelRequirementsWithCommitments`
      */
     function finalizeRequirements(requirements) {
         return {
             ...requirements,
-            systemMessage: removeCommentsFromSystemMessage(requirements.systemMessage),
+            systemMessage: deduplicateSystemMessage(removeCommentsFromSystemMessage(requirements.systemMessage)),
         };
     }