@promptbook/cli 0.114.0-3 → 0.114.0-31

package/src/book-2.0/agent-source/createAgentModelRequirementsWithCommitments/filterCommitmentsForAgentModelRequirements.ts

@@ -19,13 +19,6 @@ const OVERWRITTEN_COMMITMENT_GROUP_BY_TYPE = new Map<BookCommitment, 'GOAL'>([
     ['GOALS', 'GOAL'],
 ]);
 
-/**
- * Legacy commitments that should be parsed for compatibility but ignored by the model-requirements pipeline.
- *
- * @private internal constant of `filterCommitmentsForAgentModelRequirements`
- */
-const IGNORED_COMMITMENT_TYPES = new Set<BookCommitment>(['WALLET', 'WALLETS']);
-
 /**
  * Applies the commitment filtering rules used before commitment definitions are executed.
  *
@@ -84,10 +77,6 @@ function filterDeletedCommitments(commitments: ReadonlyArray<ParsedCommitment>):
     const filteredCommitments: ParsedCommitment[] = [];
 
     for (const commitment of commitments) {
-        if (isIgnoredCommitmentType(commitment.type)) {
-            continue;
-        }
-
         if (!isDeleteCommitmentType(commitment.type)) {
             filteredCommitments.push(commitment);
             continue;
@@ -126,18 +115,6 @@ function isDeleteCommitmentType(commitmentType: ParsedCommitment['type']): boole
     return DELETE_COMMITMENT_TYPES.has(commitmentType);
 }
 
-/**
- * Checks whether a parsed commitment is intentionally ignored by the current model compiler.
- *
- * @param commitmentType - Commitment type to check.
- * @returns `true` when the commitment should not affect model requirements.
- *
- * @private internal utility of `filterDeletedCommitments`
- */
-function isIgnoredCommitmentType(commitmentType: ParsedCommitment['type']): boolean {
-    return IGNORED_COMMITMENT_TYPES.has(commitmentType);
-}
-
 /**
  * Extracts normalized parameter names used for DELETE-like invalidation matching.
  *

package/src/book-2.0/agent-source/createAgentModelRequirementsWithCommitments.ts

@@ -1,4 +1,3 @@
-import { aggregateUseCommitmentSystemMessages } from '../../commitments/USE/aggregateUseCommitmentSystemMessages';
 import { createBasicAgentModelRequirements } from '../../commitments/_base/createEmptyAgentModelRequirements';
 import type { string_model_name } from '../../types/string_model_name';
 import type { AgentModelRequirements } from './AgentModelRequirements';
@@ -32,7 +31,6 @@ export async function createAgentModelRequirementsWithCommitments(
 
     let requirements = createInitialAgentModelRequirements(parseResult.agentName, modelName);
     requirements = await applyCommitmentsToAgentModelRequirements(requirements, filteredCommitments, options);
-    requirements = aggregateUseCommitmentSystemMessages(requirements, filteredCommitments);
     requirements = await augmentAgentModelRequirementsFromSource(requirements, parseResult, agentSource);
     requirements = await materializeInlineKnowledgeSources(requirements, options?.inlineKnowledgeSourceUploader);
 

package/src/book-2.0/agent-source/getBookCommitmentLineType.ts

@@ -0,0 +1,36 @@
+/**
+ * Pattern shared by Book parsing and editor highlighting for a commitment-like line.
+ *
+ * A Book commitment keyword consists of one or more all-uppercase words with at least
+ * two characters each. This deliberately mirrors the Book editor syntax rule so an
+ * unknown keyword starts a new source block everywhere it is interpreted.
+ *
+ * @private internal constant of `getBookCommitmentLineType`
+ */
+const BOOK_COMMITMENT_LINE_TYPE_REGEX = /^\s*(?<type>[A-Z][A-Z0-9]+(?:\s+[A-Z][A-Z0-9]+)*)(?=\s|$)/;
+
+/**
+ * Creates the regex used to recognize the uppercase commitment type at the beginning of a Book line.
+ *
+ * A fresh regular expression keeps Monaco tokenizer state isolated from parser calls.
+ *
+ * @returns Regular expression matching one Book commitment-like line.
+ *
+ * @private internal utility of Book parsing and `<BookEditor/>`
+ */
+export function createBookCommitmentLineTypeRegex(): RegExp {
+    return new RegExp(BOOK_COMMITMENT_LINE_TYPE_REGEX.source);
+}
+
+/**
+ * Extracts the uppercase commitment type from a Book line, including types not registered by Promptbook.
+ *
+ * @param line - One raw Book source line.
+ * @returns Matched commitment type or `null` when the line does not begin with commitment syntax.
+ *
+ * @private internal utility of Book parsing and `<BookEditor/>`
+ */
+export function getBookCommitmentLineType(line: string): string | null {
+    const match = BOOK_COMMITMENT_LINE_TYPE_REGEX.exec(line);
+    return match?.groups?.type || null;
+}

package/src/book-2.0/agent-source/parseAgentSource/applyMetaCommitment.ts

@@ -1,6 +1,5 @@
 import { spaceTrim } from 'spacetrim';
 import { resolveAvatarVisualId } from '../../../avatars/visuals/avatarVisualRegistry';
-import { normalizeTo_camelCase } from '../../../utils/normalization/normalizeTo_camelCase';
 import { normalizeDomainForMatching } from '../../../utils/validators/url/normalizeDomainForMatching';
 import type { ParsedCommitment } from '../../../commitments/_base/ParsedCommitment';
 import { normalizeAgentVisibility } from '../agentSourceVisibility';
@@ -22,6 +21,8 @@ const META_COMMITMENT_APPLIERS: Readonly<Record<string, MetaCommitmentApplier |
     'META IMAGE': applyMetaImageContent,
     'META DESCRIPTION': applyMetaDescriptionContent,
     'META DISCLAIMER': applyMetaDisclaimerContent,
+    'META FULLNAME': applyMetaFullnameContent,
+    'META ID': applyMetaIdContent,
     'META INPUT PLACEHOLDER': applyMetaInputPlaceholderContent,
     'META THINKING MESSAGE': applyMetaThinkingMessageContent,
     'MESSAGE SUFFIX': applyMessageSuffixContent,
@@ -40,37 +41,7 @@ export function applyMetaCommitment(state: ParseAgentSourceState, commitment: Pa
     const applyMetaContent = META_COMMITMENT_APPLIERS[commitment.type];
     if (applyMetaContent) {
         applyMetaContent(state, commitment.content);
-        return;
-    }
-
-    if (commitment.type === 'META') {
-        applyGenericMetaCommitment(state, commitment.content);
-    }
-}
-
-/**
- * Applies the generic META commitment form (`META TYPE value`).
- */
-function applyGenericMetaCommitment(state: ParseAgentSourceState, content: string): void {
-    const metaTypeRaw = content.split(' ')[0] || 'NONE';
-    const metaValue = spaceTrim(content.substring(metaTypeRaw.length));
-
-    if (metaTypeRaw === 'LINK') {
-        state.links.push(metaValue);
-    }
-
-    if (metaTypeRaw.toUpperCase() === 'AVATAR') {
-        applyMetaAvatarContent(state, metaValue);
-        return;
     }
-
-    if (metaTypeRaw.toUpperCase() === 'VISIBILITY') {
-        applyMetaVisibilityContent(state, metaValue);
-        return;
-    }
-
-    const metaType = normalizeTo_camelCase(metaTypeRaw);
-    state.meta[metaType] = metaValue;
 }
 
 /**
@@ -123,6 +94,20 @@ function applyMetaDisclaimerContent(state: ParseAgentSourceState, content: strin
     state.meta.disclaimer = content;
 }
 
+/**
+ * Applies META FULLNAME content into the canonical `meta.fullname` field.
+ */
+function applyMetaFullnameContent(state: ParseAgentSourceState, content: string): void {
+    state.meta.fullname = spaceTrim(content);
+}
+
+/**
+ * Applies META ID content into the canonical `meta.id` field.
+ */
+function applyMetaIdContent(state: ParseAgentSourceState, content: string): void {
+    state.meta.id = spaceTrim(content);
+}
+
 /**
  * Applies META INPUT PLACEHOLDER content into the canonical `meta.inputPlaceholder` field.
  */

package/src/book-2.0/agent-source/parseAgentSource/createCapabilitiesFromCommitment.ts

@@ -12,46 +12,11 @@ import type { ParseAgentSourceState } from './ParseAgentSourceState';
  * Static capability descriptors for commitments that map one-to-one to a visible capability.
  */
 const SIMPLE_CAPABILITY_BY_COMMITMENT_TYPE: Readonly<Record<string, AgentCapability | undefined>> = {
-    'USE BROWSER': {
-        type: 'browser',
-        label: 'Browser',
-        iconName: 'Globe',
-    },
-    'USE SEARCH ENGINE': {
-        type: 'search-engine',
-        label: 'Internet',
-        iconName: 'Search',
-    },
-    'USE SEARCH': {
-        type: 'search-engine',
-        label: 'Internet',
-        iconName: 'Search',
-    },
-    'USE DEEPSEARCH': {
-        type: 'search-engine',
-        label: 'DeepSearch',
-        iconName: 'Search',
-    },
-    'USE TIME': {
-        type: 'time',
-        label: 'Time',
-        iconName: 'Clock',
-    },
-    'USE TIMEOUT': {
-        type: 'timeout',
-        label: 'Timers',
-        iconName: 'Clock',
-    },
     'USE USER LOCATION': {
         type: 'user-location',
         label: 'User location',
         iconName: 'MapPin',
     },
-    'USE EMAIL': {
-        type: 'email',
-        label: 'Email',
-        iconName: 'Mail',
-    },
     'USE POPUP': {
         type: 'popup',
         label: 'Popup',

package/src/book-2.0/agent-source/parseAgentSourceWithCommitments.ts

@@ -3,7 +3,9 @@ import type { BookCommitment } from '../../commitments/_base/BookCommitment';
 import type { ParsedCommitment } from '../../commitments/_base/ParsedCommitment';
 import { COMMITMENT_REGISTRY } from '../../commitments/index';
 import type { AgentSourceParseResult } from './AgentSourceParseResult';
+import { getBookCommitmentLineType } from './getBookCommitmentLineType';
 import { parseAgentSourcePrelude } from './parseAgentSourcePrelude';
+import type { ParsedUnknownCommitment } from './ParsedUnknownCommitment';
 import type { string_book } from './string_book';
 
 /**
@@ -12,6 +14,39 @@ import type { string_book } from './string_book';
  */
 const HORIZONTAL_LINE_PATTERN = /^[\s]*[-_*][\s]*[-_*][\s]*[-_*][\s]*[-_*]*[\s]*$/;
 
+/**
+ * Registered commitment block currently being collected from Book source.
+ *
+ * @private internal type of `parseAgentSourceWithCommitments`
+ */
+type CurrentKnownCommitment = {
+    readonly kind: 'known';
+    readonly type: string;
+    readonly startLineNumber: number;
+    readonly originalStartLine: string;
+    readonly contentLines: string[];
+};
+
+/**
+ * Unknown commitment block currently being collected from Book source.
+ *
+ * @private internal type of `parseAgentSourceWithCommitments`
+ */
+type CurrentUnknownCommitment = {
+    readonly kind: 'unknown';
+    readonly type: string;
+    readonly startLineNumber: number;
+    readonly originalStartLine: string;
+    readonly sourceLines: string[];
+};
+
+/**
+ * Commitment-like source block currently being collected.
+ *
+ * @private internal type of `parseAgentSourceWithCommitments`
+ */
+type CurrentCommitment = CurrentKnownCommitment | CurrentUnknownCommitment;
+
 /**
  * Parses agent source using the new commitment system with multiline support
  * This function replaces the hardcoded commitment parsing in the original parseAgentSource
@@ -26,6 +61,7 @@ export function parseAgentSourceWithCommitments(agentSource: string_book): Omit<
         return {
             agentName: null,
             commitments: [],
+            unknownCommitments: [],
             nonCommitmentLines: [],
         };
     }
@@ -33,15 +69,11 @@ export function parseAgentSourceWithCommitments(agentSource: string_book): Omit<
     const { lines, agentName, agentNameLineIndex, agentNameLineNumber } = parseAgentSourcePrelude(agentSource);
 
     const commitments: ParsedCommitment[] = [];
+    const unknownCommitments: ParsedUnknownCommitment[] = [];
     const nonCommitmentLines: string[] = agentNameLineIndex >= 0 ? [lines[agentNameLineIndex]!] : [];
 
-    // Parse commitments with multiline support
-    let currentCommitment: {
-        type: string;
-        startLineNumber: number;
-        originalStartLine: string;
-        contentLines: string[];
-    } | null = null;
+    // Parse commitments with multiline support.
+    let currentCommitment: CurrentCommitment | null = null;
 
     // Process lines starting from after the agent name line
     const startIndex = agentNameLineIndex >= 0 ? agentNameLineIndex + 1 : 0;
@@ -58,24 +90,12 @@ export function parseAgentSourceWithCommitments(agentSource: string_book): Omit<
         if (trimmedLine.startsWith('```')) {
             isInsideCodeBlock = !isInsideCodeBlock;
 
-            if (currentCommitment) {
-                // If we are inside a commitment, the code block is part of it
-                currentCommitment.contentLines.push(line);
-            } else {
-                // If we are not inside a commitment, the code block is non-commitment
-                nonCommitmentLines.push(line);
-            }
+            appendLineToCurrentCommitmentOrNonCommitmentLines(currentCommitment, line, nonCommitmentLines);
             continue;
         }
 
         if (isInsideCodeBlock) {
-            if (currentCommitment) {
-                // If we are inside a commitment and a code block, the line is part of the commitment
-                currentCommitment.contentLines.push(line);
-            } else {
-                // If we are inside a code block but not a commitment, the line is non-commitment
-                nonCommitmentLines.push(line);
-            }
+            appendLineToCurrentCommitmentOrNonCommitmentLines(currentCommitment, line, nonCommitmentLines);
             continue;
         }
 
@@ -86,16 +106,7 @@ export function parseAgentSourceWithCommitments(agentSource: string_book): Omit<
             const match = typeRegex.exec(line.trim());
 
             if (match && match.groups?.type) {
-                // Save the previous commitment if it exists
-                if (currentCommitment) {
-                    const fullContent = currentCommitment.contentLines.join('\n');
-                    commitments.push({
-                        type: currentCommitment.type as BookCommitment,
-                        content: spaceTrim(fullContent),
-                        originalLine: currentCommitment.originalStartLine,
-                        lineNumber: currentCommitment.startLineNumber,
-                    });
-                }
+                appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
 
                 // Extract the initial content from the commitment line
                 const fullRegex = definition.createRegex();
@@ -104,6 +115,7 @@ export function parseAgentSourceWithCommitments(agentSource: string_book): Omit<
 
                 // Start a new commitment
                 currentCommitment = {
+                    kind: 'known',
                     type: definition.type,
                     startLineNumber: i + 1,
                     originalStartLine: line,
@@ -114,51 +126,106 @@ export function parseAgentSourceWithCommitments(agentSource: string_book): Omit<
             }
         }
 
+        if (foundNewCommitment) {
+            continue;
+        }
+
+        const unknownCommitmentType = getBookCommitmentLineType(line);
+        if (unknownCommitmentType) {
+            appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
+            currentCommitment = {
+                kind: 'unknown',
+                type: unknownCommitmentType,
+                startLineNumber: i + 1,
+                originalStartLine: line,
+                sourceLines: [line],
+            };
+            continue;
+        }
+
         // Check if this is a horizontal line (ends any current commitment)
         const isHorizontalLine = HORIZONTAL_LINE_PATTERN.test(line);
         if (isHorizontalLine) {
-            // Save the current commitment if it exists
-            if (currentCommitment) {
-                const fullContent = currentCommitment.contentLines.join('\n');
-                commitments.push({
-                    type: currentCommitment.type as BookCommitment,
-                    content: spaceTrim(fullContent),
-                    originalLine: currentCommitment.originalStartLine,
-                    lineNumber: currentCommitment.startLineNumber,
-                });
-                currentCommitment = null;
-            }
+            appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
+            currentCommitment = null;
             // Add horizontal line to non-commitment lines
             nonCommitmentLines.push(line);
             continue;
         }
 
-        if (!foundNewCommitment) {
-            if (currentCommitment) {
-                // This line belongs to the current commitment
-                currentCommitment.contentLines.push(line);
-            } else {
-                // This line is not part of any commitment
-                nonCommitmentLines.push(line);
-            }
-        }
+        appendLineToCurrentCommitmentOrNonCommitmentLines(currentCommitment, line, nonCommitmentLines);
     }
 
-    // Don't forget to save the last commitment if it exists
-    if (currentCommitment) {
-        const fullContent = currentCommitment.contentLines.join('\n');
-        commitments.push({
-            type: currentCommitment.type as BookCommitment,
-            content: spaceTrim(fullContent) as BookCommitment,
-            originalLine: currentCommitment.originalStartLine,
-            lineNumber: currentCommitment.startLineNumber,
-        });
-    }
+    appendCurrentCommitment(currentCommitment, commitments, unknownCommitments);
 
     return {
         agentName,
         agentNameLineNumber,
         commitments,
+        unknownCommitments,
         nonCommitmentLines,
     };
 }
+
+/**
+ * Stores the current known or unknown commitment in its appropriate parsed collection.
+ *
+ * @param currentCommitment - Commitment-like block collected so far.
+ * @param commitments - Parsed registered commitments to append to.
+ * @param unknownCommitments - Parsed unregistered commitments to append to.
+ *
+ * @private internal utility of `parseAgentSourceWithCommitments`
+ */
+function appendCurrentCommitment(
+    currentCommitment: CurrentCommitment | null,
+    commitments: ParsedCommitment[],
+    unknownCommitments: ParsedUnknownCommitment[],
+): void {
+    if (!currentCommitment) {
+        return;
+    }
+
+    if (currentCommitment.kind === 'unknown') {
+        unknownCommitments.push({
+            type: currentCommitment.type,
+            originalLine: currentCommitment.originalStartLine,
+            lineNumber: currentCommitment.startLineNumber,
+            source: spaceTrim(currentCommitment.sourceLines.join('\n')),
+        });
+        return;
+    }
+
+    commitments.push({
+        type: currentCommitment.type as BookCommitment,
+        content: spaceTrim(currentCommitment.contentLines.join('\n')),
+        originalLine: currentCommitment.originalStartLine,
+        lineNumber: currentCommitment.startLineNumber,
+    });
+}
+
+/**
+ * Adds one source line to the active commitment-like block, or to plain source content when none is active.
+ *
+ * @param currentCommitment - Commitment-like block currently being collected.
+ * @param line - Source line to append.
+ * @param nonCommitmentLines - Plain source lines to append to when no block is active.
+ *
+ * @private internal utility of `parseAgentSourceWithCommitments`
+ */
+function appendLineToCurrentCommitmentOrNonCommitmentLines(
+    currentCommitment: CurrentCommitment | null,
+    line: string,
+    nonCommitmentLines: string[],
+): void {
+    if (!currentCommitment) {
+        nonCommitmentLines.push(line);
+        return;
+    }
+
+    if (currentCommitment.kind === 'unknown') {
+        currentCommitment.sourceLines.push(line);
+        return;
+    }
+
+    currentCommitment.contentLines.push(line);
+}

package/src/book-2.0/agent-source/string_book.ts

@@ -44,7 +44,7 @@ export const DEFAULT_BOOK = padBook(
         spaceTrim(`
             AI Avatar
 
-            PERSONA A friendly AI assistant that helps you with your tasks
+            GOAL Help users with their tasks as a friendly AI assistant.
         `),
     ),
 );

package/src/book-2.0/book-language-documentation/bookLanguageDocumentationExamples.ts

@@ -21,19 +21,6 @@ export const bookLanguageDocumentationExamples: ReadonlyArray<BookLanguageDocume
             CLOSED
         `),
     },
-    {
-        id: 'tool-using-browser-search-agent',
-        source: spaceTrim(`
-            Web Research Assistant
-
-            GOAL Research topics using fresh and verifiable information.
-            USE SEARCH ENGINE Prefer official sources and recent publications.
-            USE BROWSER
-            RULE Verify important claims across multiple sources when possible.
-            RULE Include source links in your final answer.
-            INITIAL MESSAGE Ask me what topic you want to research and how deep the report should be.
-        `),
-    },
     {
         id: 'rule-and-knowledge-agent',
         source: spaceTrim(`
@@ -47,18 +34,6 @@ export const bookLanguageDocumentationExamples: ReadonlyArray<BookLanguageDocume
             INITIAL MESSAGE I can explain refund and support rules from provided knowledge.
         `),
     },
-    {
-        id: 'memory-agent-with-long-term-memory',
-        source: spaceTrim(`
-            Customer Success Memory Agent
-
-            GOAL Support SaaS customers while remembering relevant setup and preference context.
-            MEMORY Remember product setup, user goals, and communication preferences.
-            RULE Store only user-approved preferences and project context.
-            RULE Never store secrets or sensitive data unless explicitly requested and allowed.
-            INITIAL MESSAGE I can remember your setup and preferences for future sessions.
-        `),
-    },
     {
         id: 'use-project-integration-agent',
         source: spaceTrim(`

package/src/book-2.0/book-language-documentation/createStandaloneBookLanguageMarkdown.ts

@@ -30,22 +30,13 @@ const COMPOSITION_COMMITMENT_TYPES = new Set(['FROM', 'IMPORT', 'IMPORTS', 'TEAM
  * @private internal utility of `createStandaloneBookLanguageMarkdown`
  */
 const TOOLING_COMMITMENT_TYPES = new Set([
-    'USE BROWSER',
-    'USE DEEPSEARCH',
-    'USE SEARCH ENGINE',
-    'USE SEARCH',
-    'USE SPAWN',
-    'USE EMAIL',
     'USE POPUP',
-    'USE TIME',
     'USE USER LOCATION',
     'USE PROJECT',
     'USE CALENDAR',
     'USE IMAGE GENERATOR',
     'USE MCP',
     'USE PRIVACY',
-    'MEMORY',
-    'MEMORIES',
 ]);
 
 /**
@@ -56,7 +47,6 @@ const TOOLING_COMMITMENT_TYPES = new Set([
 const PROFILE_COMMITMENT_TYPES = new Set([
     'GOAL',
     'GOALS',
-    'META',
     'META AVATAR',
     'META VISUAL',
     'META IMAGE',
@@ -64,6 +54,8 @@ const PROFILE_COMMITMENT_TYPES = new Set([
     'META DOMAIN',
     'META DESCRIPTION',
     'META DISCLAIMER',
+    'META FULLNAME',
+    'META ID',
     'META INPUT PLACEHOLDER',
     'META THINKING MESSAGE',
     'META VISIBILITY',
@@ -88,6 +80,7 @@ const BEHAVIOR_COMMITMENT_TYPES = new Set([
     'LANGUAGES',
     'WRITING SAMPLE',
     'WRITING RULES',
+    'WRITING RULE',
     'SCENARIO',
     'SCENARIOS',
     'MESSAGE',
@@ -288,9 +281,7 @@ export function createStandaloneBookLanguageMarkdown(
             ${block(dictionary.tutorialSections.checklistBody)}
 
             ${block(
-                isLowLevelCommitmentsIncluded
-                    ? renderLowLevelCommitmentsChapter(lowLevelCommitments, dictionary)
-                    : '',
+                isLowLevelCommitmentsIncluded ? renderLowLevelCommitmentsChapter(lowLevelCommitments, dictionary) : '',
             )}
 
             ---
@@ -604,7 +595,9 @@ function renderExampleSection(
             **${dictionary.exampleLabels.goal}:** ${exampleText.goal}
 
             **${dictionary.exampleLabels.commitmentsUsed}:** ${renderCommitmentSectionLinks(
-            parseAgentSourceWithCommitments(example.source as string_book).commitments.map((commitment) => commitment.type),
+            parseAgentSourceWithCommitments(example.source as string_book).commitments.map(
+                (commitment) => commitment.type,
+            ),
             commitmentSectionAnchorByType,
         )}