@promptbook/cli 0.113.0-9 → 0.114.0-0

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

@@ -0,0 +1,18 @@
+/**
+ * Converts a heading label into a stable markdown anchor id.
+ *
+ * Anchors are generated from language-neutral identifiers, so deep links into
+ * the manual keep working in every translation.
+ *
+ * @param value - Raw heading/identifier text.
+ * @returns Stable lowercase anchor id.
+ *
+ * @private internal utility of `createStandaloneBookLanguageMarkdown`
+ */
+export function toStableAnchorId(value: string): string {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}

package/src/book-3.0/AgentMessageRunReport.ts

@@ -0,0 +1,164 @@
+// Note: [💞] Ignore a discrepancy between file name and entity name
+
+import type { Usage } from '../execution/Usage';
+import type { CodexLoginMethod } from './codexLoginMethod';
+
+/**
+ * File suffix appended to one answered message book to store its run report sidecar.
+ *
+ * For example `messages/finished/2026-07-16-thread.book` is reported in
+ * `messages/finished/2026-07-16-thread.book.report.json`.
+ *
+ * @private internal constant of the agent folder convention
+ */
+export const AGENT_MESSAGE_RUN_REPORT_FILE_SUFFIX = '.report.json';
+
+/**
+ * Report describing how one queued agent message was answered by a CLI harness runner.
+ *
+ * The agent runner writes it next to the answered message book so consumers
+ * (for example the Agents Server task details) can show which runner, authentication
+ * method and usage one answer cost without re-parsing the runner output.
+ *
+ * Note: [🚉] This is fully serializable as JSON
+ *
+ * @private internal type of the agent folder convention
+ */
+export type AgentMessageRunReport = {
+    /**
+     * Report schema version for forward compatibility.
+     */
+    readonly version: 1;
+
+    /**
+     * Name of the harness runner which answered the message, for example `codex` or `claude-code`.
+     */
+    readonly runnerName: string;
+
+    /**
+     * Model identifier used by the runner, when known.
+     */
+    readonly modelName?: string;
+
+    /**
+     * Authentication method the runner used, when it can be determined.
+     *
+     * Currently only the OpenAI Codex runner reports this (its ChatGPT account vs. `OPENAI_API_KEY`);
+     * other runners leave it `undefined`.
+     */
+    readonly loginMethod?: CodexLoginMethod;
+
+    /**
+     * Usage statistics of the run (price, token counts, duration).
+     */
+    readonly usage: Usage;
+};
+
+/**
+ * Builds the run-report sidecar path for one message book path.
+ *
+ * Works for absolute and relative paths because the suffix is simply appended.
+ *
+ * @private internal utility of the agent folder convention
+ */
+export function buildAgentMessageRunReportPath(messageFilePath: string): string {
+    return `${messageFilePath}${AGENT_MESSAGE_RUN_REPORT_FILE_SUFFIX}`;
+}
+
+/**
+ * Serializes one run report into the stable JSON format persisted next to the answered message book.
+ *
+ * @private internal utility of the agent folder convention
+ */
+export function serializeAgentMessageRunReport(report: AgentMessageRunReport): string {
+    return `${JSON.stringify(report, null, 4)}\n`;
+}
+
+/**
+ * Validates one already-parsed JSON value as a run report.
+ *
+ * @returns The typed report, or `null` when the value does not match the expected shape,
+ * so consumers can silently skip malformed or foreign sidecar files.
+ *
+ * @private internal utility of the agent folder convention
+ */
+export function normalizeAgentMessageRunReport(value: unknown): AgentMessageRunReport | null {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+
+    const report = value as Record<string, unknown>;
+
+    if (report.version !== 1 || typeof report.runnerName !== 'string' || report.runnerName.length === 0) {
+        return null;
+    }
+
+    if (report.modelName !== undefined && typeof report.modelName !== 'string') {
+        return null;
+    }
+
+    if (
+        report.loginMethod !== undefined &&
+        report.loginMethod !== 'chatgpt' &&
+        report.loginMethod !== 'api' &&
+        report.loginMethod !== 'unknown'
+    ) {
+        return null;
+    }
+
+    if (!isSerializedUsage(report.usage)) {
+        return null;
+    }
+
+    return report as AgentMessageRunReport;
+}
+
+/**
+ * Parses one run-report sidecar file content.
+ *
+ * @returns The typed report, or `null` when the content is not valid JSON or does not match the expected shape.
+ *
+ * @private internal utility of the agent folder convention
+ */
+export function parseAgentMessageRunReport(reportFileContent: string): AgentMessageRunReport | null {
+    try {
+        return normalizeAgentMessageRunReport(JSON.parse(reportFileContent));
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Checks that one value structurally matches the serialized `Usage` shape.
+ *
+ * @private internal helper of `normalizeAgentMessageRunReport`
+ */
+function isSerializedUsage(value: unknown): value is Usage {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+
+    const usage = value as Record<string, unknown>;
+    return (
+        isSerializedUncertainNumber(usage.price) &&
+        isSerializedUncertainNumber(usage.duration) &&
+        typeof usage.input === 'object' &&
+        usage.input !== null &&
+        typeof usage.output === 'object' &&
+        usage.output !== null
+    );
+}
+
+/**
+ * Checks that one value structurally matches the serialized `UncertainNumber` shape.
+ *
+ * @private internal helper of `normalizeAgentMessageRunReport`
+ */
+function isSerializedUncertainNumber(value: unknown): boolean {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        typeof (value as { value?: unknown }).value === 'number' &&
+        Number.isFinite((value as { value: number }).value)
+    );
+}

package/src/book-3.0/CliAgent.ts

@@ -6,7 +6,13 @@ import { resolvePromptbookTemporaryPath } from '../utils/filesystem/promptbookTe
 import { spaceTrim } from '../utils/organization/spaceTrim';
 import type { BookNodeAgentSourceOptions, ResolvedBookNodeAgentSource } from './BookNodeAgentSource';
 import { resolveBookNodeAgentSource } from './BookNodeAgentSource';
-import { CLI_AGENT_HARNESS_NAMES, CLI_AGENT_THINKING_LEVEL_VALUES, PTBK_HARNESS_ENV, PTBK_MODEL_ENV, PTBK_THINKING_LEVEL_ENV } from './cliAgentEnv';
+import {
+    CLI_AGENT_HARNESS_NAMES,
+    CLI_AGENT_THINKING_LEVEL_VALUES,
+    PTBK_HARNESS_ENV,
+    PTBK_MODEL_ENV,
+    PTBK_THINKING_LEVEL_ENV,
+} from './cliAgentEnv';
 
 /**
  * CLI harness names supported by `ptbk agent exec`.

package/src/book-3.0/agentFolderPaths.ts

@@ -36,3 +36,13 @@ export const AGENT_FINISHED_MESSAGES_DIRECTORY_PATH = join(AGENT_MESSAGES_DIRECT
  * @public exported from `@promptbook/node`
  */
 export const AGENT_FAILED_MESSAGES_DIRECTORY_PATH = join(AGENT_MESSAGES_DIRECTORY_PATH, 'failed');
+
+/**
+ * Relative path to the agent-owned projects root used by the agent folder convention.
+ *
+ * Each direct child directory is one project — an isolated folder the agent fully controls
+ * (files, scripts, optionally its own git repository).
+ *
+ * @private internal constant of the agent folder convention, used by agent runners and the Agents Server
+ */
+export const AGENT_PROJECTS_DIRECTORY_PATH = 'projects';

package/src/book-3.0/codexLoginMethod.ts

@@ -0,0 +1,52 @@
+// Note: [💞] Ignore a discrepancy between file name and entity name
+
+/**
+ * Authentication method that the OpenAI Codex CLI used for one run.
+ *
+ * - `chatgpt` — the server's ChatGPT account (subscription) login was used.
+ * - `api` — `OPENAI_API_KEY` API-key authentication was used.
+ * - `unknown` — the runner could not determine which method Codex used.
+ *
+ * @private internal type of the OpenAI Codex runner and the Agents Server task details
+ */
+export type CodexLoginMethod = 'chatgpt' | 'api' | 'unknown';
+
+/**
+ * Stable stdout marker printed by the generated Codex runner script to report which login method it used.
+ *
+ * The marker is followed by the resolved method keyword, for example `ptbk-codex-login-method: chatgpt`,
+ * so `parseCodexLoginMethodFromOutput` can recover it from the captured runner output.
+ *
+ * @private internal constant of the OpenAI Codex runner
+ */
+export const CODEX_LOGIN_METHOD_MARKER = 'ptbk-codex-login-method:';
+
+/**
+ * Substring that the `codex login status` command prints when the Codex CLI is signed in with a
+ * ChatGPT subscription account instead of an `OPENAI_API_KEY`.
+ *
+ * This is the single source of truth for detecting an active ChatGPT login, reused by the Codex runner
+ * script and by the Agents Server harness authentication status resolver.
+ *
+ * @private internal constant of the OpenAI Codex runner and the Agents Server Harness Auth
+ */
+export const CODEX_CHATGPT_LOGIN_STATUS_NEEDLE = 'Logged in using ChatGPT';
+
+/**
+ * Formats one Codex login method as a short human-readable label for prompt status lines and task details.
+ *
+ * @returns The label to append to a status line, or `undefined` when there is no meaningful method to show
+ * (for example the runner is not Codex or the method could not be determined), so callers can omit the suffix.
+ *
+ * @private internal utility of the OpenAI Codex runner and the Agents Server task details
+ */
+export function formatCodexLoginMethod(loginMethod: CodexLoginMethod | undefined): string | undefined {
+    switch (loginMethod) {
+        case 'chatgpt':
+            return 'ChatGPT account';
+        case 'api':
+            return 'API key';
+        default:
+            return undefined;
+    }
+}

package/src/book-components/AvatarProfile/AvatarProfile/AvatarProfile.tsx

@@ -4,7 +4,10 @@ import { CSSProperties } from 'react';
 import type { AgentBasicInformation } from '../../../book-2.0/agent-source/AgentBasicInformation';
 import type { string_book } from '../../../book-2.0/agent-source/string_book';
 import type { string_css_class } from '../../../types/string_markdown';
-import { resolveAgentAvatarFallbackUrl, resolveAgentAvatarImageUrl } from '../../../utils/agents/resolveAgentAvatarImageUrl';
+import {
+    resolveAgentAvatarFallbackUrl,
+    resolveAgentAvatarImageUrl,
+} from '../../../utils/agents/resolveAgentAvatarImageUrl';
 import { classNames } from '../../_common/react-utils/classNames';
 import styles from './AvatarProfile.module.css';
 

package/src/book-components/BookEditor/BookEditorSyntaxTokenStyles.ts

@@ -0,0 +1,88 @@
+import { PROMPTBOOK_SYNTAX_COLORS } from '../../config';
+
+/**
+ * One token emitted while highlighting Book source.
+ *
+ * @private internal type of `BookEditor`
+ */
+export type BookEditorSyntaxTokenName =
+    | 'title'
+    | 'commitment'
+    | 'note-commitment'
+    | 'todo-commitment'
+    | 'parameter'
+    | 'agent-reference'
+    | 'code-block';
+
+/**
+ * Visual style of one Book syntax token.
+ *
+ * @private internal type of `BookEditor`
+ */
+export type BookEditorSyntaxTokenStyle = {
+    /**
+     * Token this style belongs to.
+     */
+    readonly token: BookEditorSyntaxTokenName;
+
+    /**
+     * Text color of the token.
+     */
+    readonly foreground: string;
+
+    /**
+     * Optional background color of the token.
+     */
+    readonly background?: string;
+
+    /**
+     * Optional space-separated font style, for example `bold underline`.
+     */
+    readonly fontStyle?: string;
+};
+
+/**
+ * Single source of truth for how Book source is colored.
+ *
+ * The Monaco theme of `<BookEditor/>` and every static rendering of Book source
+ * (for example the Book language manual PDF) are derived from these styles, so
+ * a book always looks the same no matter where it is displayed.
+ *
+ * @private internal constant of `BookEditor`
+ */
+export const BOOK_EDITOR_SYNTAX_TOKEN_STYLES: ReadonlyArray<BookEditorSyntaxTokenStyle> = [
+    {
+        token: 'title',
+        foreground: PROMPTBOOK_SYNTAX_COLORS.TITLE.toHex(),
+        fontStyle: 'bold underline',
+    },
+    {
+        token: 'commitment',
+        foreground: PROMPTBOOK_SYNTAX_COLORS.COMMITMENT.toHex(),
+        fontStyle: 'bold',
+    },
+    {
+        token: 'note-commitment',
+        foreground: PROMPTBOOK_SYNTAX_COLORS.NOTE_COMMITMENT.toHex(),
+    },
+    {
+        token: 'todo-commitment',
+        foreground: PROMPTBOOK_SYNTAX_COLORS.TODO_COMMITMENT_TEXT.toHex(),
+        background: PROMPTBOOK_SYNTAX_COLORS.TODO_COMMITMENT_BACKGROUND.toHex(),
+        fontStyle: 'bold',
+    },
+    {
+        token: 'parameter',
+        foreground: PROMPTBOOK_SYNTAX_COLORS.PARAMETER.toHex(),
+        fontStyle: 'italic',
+    },
+    {
+        token: 'agent-reference',
+        foreground: PROMPTBOOK_SYNTAX_COLORS.COMMITMENT.toHex(),
+        fontStyle: 'underline',
+    },
+    {
+        token: 'code-block',
+        foreground: PROMPTBOOK_SYNTAX_COLORS.CODE_BLOCK.toHex(),
+    },
+];

package/src/book-components/BookEditor/createBookSourceHighlightStyles.ts

@@ -0,0 +1,49 @@
+import { BOOK_EDITOR_SYNTAX_TOKEN_STYLES, type BookEditorSyntaxTokenStyle } from './BookEditorSyntaxTokenStyles';
+import { BOOK_SYNTAX_TOKEN_CLASS_NAME_PREFIX } from './highlightBookSourceToHtml';
+
+/**
+ * Font styles that `BookEditorSyntaxTokenStyle` can request.
+ *
+ * @private internal constant of `createBookSourceHighlightStyles`
+ */
+const BOOK_SYNTAX_FONT_STYLE_DECLARATIONS: Readonly<Record<string, string>> = {
+    bold: 'font-weight: bold;',
+    italic: 'font-style: italic;',
+    underline: 'text-decoration: underline;',
+};
+
+/**
+ * Creates the CSS matching the markup of `highlightBookSourceToHtml`.
+ *
+ * Both the stylesheet and the markup are derived from the shared
+ * `BOOK_EDITOR_SYNTAX_TOKEN_STYLES`, therefore a statically rendered book keeps
+ * the exact colors of `<BookEditor/>`.
+ *
+ * @returns CSS rules for every Book syntax token.
+ *
+ * @private internal utility of `BookEditor`
+ */
+export function createBookSourceHighlightStyles(): string {
+    return BOOK_EDITOR_SYNTAX_TOKEN_STYLES.map(createBookSourceHighlightRule).join('\n');
+}
+
+/**
+ * Creates one CSS rule for a single Book syntax token.
+ *
+ * @param tokenStyle - Shared visual style of the token.
+ * @returns CSS rule for the token class name.
+ *
+ * @private internal utility of `createBookSourceHighlightStyles`
+ */
+function createBookSourceHighlightRule(tokenStyle: BookEditorSyntaxTokenStyle): string {
+    const declarations = [
+        `color: ${tokenStyle.foreground};`,
+        ...(tokenStyle.background ? [`background: ${tokenStyle.background};`] : []),
+        ...(tokenStyle.fontStyle || '')
+            .split(/\s+/)
+            .filter((fontStyle) => fontStyle.length > 0)
+            .map((fontStyle) => BOOK_SYNTAX_FONT_STYLE_DECLARATIONS[fontStyle] || ''),
+    ].filter((declaration) => declaration.length > 0);
+
+    return `.${BOOK_SYNTAX_TOKEN_CLASS_NAME_PREFIX}${tokenStyle.token} { ${declarations.join(' ')} }`;
+}

package/src/book-components/BookEditor/highlightBookSourceToHtml.ts

@@ -0,0 +1,208 @@
+import { escapeHtml } from '../../utils/html/escapeHtml';
+import { BookEditorMonacoTokenization } from './BookEditorMonacoTokenization';
+import type { BookEditorSyntaxTokenName } from './BookEditorSyntaxTokenStyles';
+
+/**
+ * Prefix of the CSS class names emitted for highlighted Book source.
+ *
+ * @private internal constant of `BookEditor`
+ */
+export const BOOK_SYNTAX_TOKEN_CLASS_NAME_PREFIX = 'book-syntax-';
+
+/**
+ * Commitment keywords rendered as low-visibility notes.
+ *
+ * @private internal constant of `highlightBookSourceToHtml`
+ */
+const NOTE_COMMITMENT_TYPES = ['NOTE', 'NOTES', 'COMMENT', 'NONCE'];
+
+/**
+ * Commitment keywords rendered as high-visibility annotations.
+ *
+ * @private internal constant of `highlightBookSourceToHtml`
+ */
+const TODO_COMMITMENT_TYPES = ['TODO'];
+
+/**
+ * Commitment keywords whose content may contain compact agent references.
+ *
+ * @private internal constant of `highlightBookSourceToHtml`
+ */
+const AGENT_REFERENCE_COMMITMENT_TYPES = ['FROM', 'IMPORT', 'IMPORTS', 'TEAM'];
+
+/**
+ * Matches fenced code-block delimiters, including optional leading indentation.
+ *
+ * @private internal constant of `highlightBookSourceToHtml`
+ */
+const CODE_BLOCK_FENCE_REGEX = /^\s*```/;
+
+/**
+ * Matches horizontal separators between embedded agents.
+ *
+ * @private internal constant of `highlightBookSourceToHtml`
+ */
+const HORIZONTAL_SEPARATOR_REGEX = /^\s*-{3,}\s*$/;
+
+/**
+ * Matches `@parameter` and `{parameter}` notations inside commitment content.
+ *
+ * @private internal constant of `highlightBookSourceToHtml`
+ */
+const PARAMETER_TOKEN_REGEX = /@([a-zA-Z0-9_á-žÁ-Žč-řČ-Řš-žŠ-Žа-яА-ЯёЁ]+)|\{[^{}\r\n]+\}/g;
+
+/**
+ * How the currently rendered line should be colored.
+ *
+ * @private internal type of `highlightBookSourceToHtml`
+ */
+type BookSourceHighlightState = 'title' | 'body' | 'code-block' | 'note-commitment' | 'todo-commitment';
+
+/**
+ * Highlights Book source into static HTML using the `<BookEditor/>` token colors.
+ *
+ * `<BookEditor/>` itself is a Monaco-based browser component and cannot run
+ * where a book has to be rendered as plain markup (server-side exports such as
+ * the Book language manual PDF). This function reuses the very same
+ * tokenization patterns and token names, so both surfaces stay in sync.
+ *
+ * @param bookSource - Raw Book source to highlight.
+ * @returns HTML with one `<span>` per highlighted token, safe to place into `<pre>`.
+ *
+ * @private internal utility of `BookEditor`
+ */
+export function highlightBookSourceToHtml(bookSource: string): string {
+    const sourceLines = bookSource.split(/\r?\n/);
+    let state: BookSourceHighlightState = 'title';
+    let stateBeforeCodeBlock: BookSourceHighlightState = 'body';
+    let isAgentReferenceCommitment = false;
+
+    return sourceLines
+        .map((sourceLine) => {
+            if (state === 'code-block') {
+                const highlightedLine = renderToken('code-block', sourceLine);
+
+                if (CODE_BLOCK_FENCE_REGEX.test(sourceLine)) {
+                    state = stateBeforeCodeBlock;
+                }
+
+                return highlightedLine;
+            }
+
+            if (CODE_BLOCK_FENCE_REGEX.test(sourceLine)) {
+                stateBeforeCodeBlock = state === 'title' ? 'body' : state;
+                state = 'code-block';
+                return renderToken('code-block', sourceLine);
+            }
+
+            if (sourceLine.trim() === '' || HORIZONTAL_SEPARATOR_REGEX.test(sourceLine)) {
+                return escapeHtml(sourceLine);
+            }
+
+            if (state === 'title') {
+                state = 'body';
+                return renderToken('title', sourceLine);
+            }
+
+            const commitmentKeyword = BookEditorMonacoTokenization.DYNAMIC_COMMITMENT_REGEX.exec(sourceLine)?.[0];
+
+            if (commitmentKeyword !== undefined) {
+                state = resolveCommitmentState(commitmentKeyword);
+                isAgentReferenceCommitment = isCommitmentOfType(commitmentKeyword, AGENT_REFERENCE_COMMITMENT_TYPES);
+
+                if (state !== 'body') {
+                    return renderToken(state, sourceLine);
+                }
+
+                return (
+                    renderToken('commitment', commitmentKeyword) +
+                    renderCommitmentContent(sourceLine.slice(commitmentKeyword.length), isAgentReferenceCommitment)
+                );
+            }
+
+            if (state === 'note-commitment' || state === 'todo-commitment') {
+                return renderToken(state, sourceLine);
+            }
+
+            return renderCommitmentContent(sourceLine, isAgentReferenceCommitment);
+        })
+        .join('\n');
+}
+
+/**
+ * Resolves which highlighting state one commitment keyword switches to.
+ *
+ * @param commitmentKeyword - Keyword matched at the beginning of a line.
+ * @returns Highlighting state for the commitment block.
+ *
+ * @private internal utility of `highlightBookSourceToHtml`
+ */
+function resolveCommitmentState(commitmentKeyword: string): BookSourceHighlightState {
+    if (isCommitmentOfType(commitmentKeyword, TODO_COMMITMENT_TYPES)) {
+        return 'todo-commitment';
+    }
+
+    if (isCommitmentOfType(commitmentKeyword, NOTE_COMMITMENT_TYPES)) {
+        return 'note-commitment';
+    }
+
+    return 'body';
+}
+
+/**
+ * Returns whether one matched keyword starts with any of the given commitment types.
+ *
+ * @param commitmentKeyword - Keyword matched at the beginning of a line.
+ * @param commitmentTypes - Commitment types to test against.
+ * @returns Whether the keyword belongs to one of the commitment types.
+ *
+ * @private internal utility of `highlightBookSourceToHtml`
+ */
+function isCommitmentOfType(commitmentKeyword: string, commitmentTypes: ReadonlyArray<string>): boolean {
+    const normalizedKeyword = commitmentKeyword.trim().toUpperCase();
+
+    return commitmentTypes.some(
+        (commitmentType) => normalizedKeyword === commitmentType || normalizedKeyword.startsWith(`${commitmentType} `),
+    );
+}
+
+/**
+ * Highlights parameters and compact agent references inside commitment content.
+ *
+ * @param content - Text after the commitment keyword.
+ * @param isAgentReferenceCommitment - Whether the surrounding commitment supports agent references.
+ * @returns HTML for the commitment content.
+ *
+ * @private internal utility of `highlightBookSourceToHtml`
+ */
+function renderCommitmentContent(content: string, isAgentReferenceCommitment: boolean): string {
+    const tokenRegex = isAgentReferenceCommitment
+        ? new RegExp(BookEditorMonacoTokenization.AGENT_REFERENCE_TOKEN_REGEX.source, 'g')
+        : new RegExp(PARAMETER_TOKEN_REGEX.source, 'g');
+    const tokenName: BookEditorSyntaxTokenName = isAgentReferenceCommitment ? 'agent-reference' : 'parameter';
+
+    let renderedContent = '';
+    let plainTextStartIndex = 0;
+    let match: RegExpExecArray | null;
+
+    while ((match = tokenRegex.exec(content)) !== null) {
+        renderedContent += escapeHtml(content.slice(plainTextStartIndex, match.index));
+        renderedContent += renderToken(tokenName, match[0]);
+        plainTextStartIndex = match.index + match[0].length;
+    }
+
+    return renderedContent + escapeHtml(content.slice(plainTextStartIndex));
+}
+
+/**
+ * Wraps one piece of Book source into its highlighted `<span>`.
+ *
+ * @param tokenName - Book syntax token of the text.
+ * @param text - Raw source text of the token.
+ * @returns HTML span carrying the token class name.
+ *
+ * @private internal utility of `highlightBookSourceToHtml`
+ */
+function renderToken(tokenName: BookEditorSyntaxTokenName, text: string): string {
+    return `<span class="${BOOK_SYNTAX_TOKEN_CLASS_NAME_PREFIX}${tokenName}">${escapeHtml(text)}</span>`;
+}

package/src/book-components/BookEditor/useBookEditorMonacoLanguage.ts

@@ -1,7 +1,7 @@
 import type { editor, Position } from 'monaco-editor';
 import { useEffect } from 'react';
-import { PROMPTBOOK_SYNTAX_COLORS } from '../../config';
 import { BookEditorMonacoConstants } from './BookEditorMonacoConstants';
+import { BOOK_EDITOR_SYNTAX_TOKEN_STYLES } from './BookEditorSyntaxTokenStyles';
 import { BookEditorMonacoTokenization } from './BookEditorMonacoTokenization';
 import type { BookEditorTheme } from './BookEditorTheme';
 import { BOOK_EDITOR_RENDER_THEME, resolveBookEditorRenderTheme } from './BookEditorTheme';
@@ -109,42 +109,7 @@ type MonacoEditorWithBookEditorLanguageState = MonacoEditor & {
  *
  * @private function of BookEditorMonaco
  */
-const BOOK_EDITOR_THEME_RULES = [
-    {
-        token: 'title',
-        foreground: PROMPTBOOK_SYNTAX_COLORS.TITLE.toHex(),
-        fontStyle: 'bold underline',
-    },
-    {
-        token: 'commitment',
-        foreground: PROMPTBOOK_SYNTAX_COLORS.COMMITMENT.toHex(),
-        fontStyle: 'bold',
-    },
-    {
-        token: 'note-commitment',
-        foreground: PROMPTBOOK_SYNTAX_COLORS.NOTE_COMMITMENT.toHex(),
-    },
-    {
-        token: 'todo-commitment',
-        foreground: PROMPTBOOK_SYNTAX_COLORS.TODO_COMMITMENT_TEXT.toHex(),
-        background: PROMPTBOOK_SYNTAX_COLORS.TODO_COMMITMENT_BACKGROUND.toHex(),
-        fontStyle: 'bold',
-    },
-    {
-        token: 'parameter',
-        foreground: PROMPTBOOK_SYNTAX_COLORS.PARAMETER.toHex(),
-        fontStyle: 'italic',
-    },
-    {
-        token: 'agent-reference',
-        foreground: PROMPTBOOK_SYNTAX_COLORS.COMMITMENT.toHex(),
-        fontStyle: 'underline',
-    },
-    {
-        token: 'code-block',
-        foreground: PROMPTBOOK_SYNTAX_COLORS.CODE_BLOCK.toHex(),
-    },
-] as const;
+const BOOK_EDITOR_THEME_RULES = BOOK_EDITOR_SYNTAX_TOKEN_STYLES;
 
 /**
  * Re-defines the shared Book Monaco theme according to the requested light/dark mode.

package/src/book-components/BookEditor/useBookEditorMonacoUploads/bookEditorMonacoUploadTypes.ts

@@ -139,9 +139,4 @@ export type UploadDecorationIdsRef = MutableRefObject<Map<string, string>>;
  *
  * @private function of BookEditorMonaco
  */
-export type QueueProgressUpdate = (
-    uploadId: string,
-    progress: number,
-    loadedBytes: number,
-    totalBytes: number,
-) => void;
+export type QueueProgressUpdate = (uploadId: string, progress: number, loadedBytes: number, totalBytes: number) => void;