@promptbook/cli 0.112.0-99 → 0.113.0-0

package/src/book-components/Chat/utils/citationHelpers.ts

@@ -19,12 +19,20 @@ const FILE_EXTENSION_REGEX = /\.([a-z0-9]{1,10})$/i;
  * Pattern matching punctuation that should be trimmed from citation tails.
  */
 const TRAILING_PUNCTUATION_REGEX = /[.,;:!?)+\]]+$/;
+/**
+ * Pattern matching filename separators that should become spaces in source labels.
+ */
+const FILENAME_SEPARATOR_REGEX = /[-_]+/g;
+/**
+ * Pattern matching consecutive whitespace in display labels.
+ */
+const WHITESPACE_REGEX = /\s+/g;
 
 /**
  * Collapses consecutive whitespace into single spaces.
  */
 function collapseWhitespace(value: string): string {
-    return value.replace(/\s+/g, ' ');
+    return value.replace(WHITESPACE_REGEX, ' ');
 }
 
 /**
@@ -105,6 +113,11 @@ export function isPlainTextCitation(citation: ParsedCitation): boolean {
  * @private utility of `<Chat/>` citation rendering
  */
 export function getCitationLabel(citation: ParsedCitation): string {
+    const title = normalizeCitationDisplayLabel(citation.title);
+    if (title) {
+        return title;
+    }
+
     const trimmed = trimToNormalized(citation.source);
     if (!trimmed) {
         return citation.source;
@@ -119,7 +132,7 @@ export function getCitationLabel(citation: ParsedCitation): string {
         return collapsed.slice(0, TEXT_LABEL_LENGTH) + LABEL_ELLIPSIS;
     }
 
-    return simplifyKnowledgeLabel(trimmed);
+    return createReadableCitationSourceLabel(trimmed);
 }
 
 /**
@@ -143,4 +156,79 @@ export function resolveCitationPreviewUrl(
     return explicitUrl || literalUrl || knowledgeUrl || null;
 }
 
+/**
+ * Creates a readable fallback label from a citation source when no title metadata is available.
+ *
+ * @param source - Raw citation source value.
+ * @returns Human-friendly source label.
+ *
+ * @private utility of `<Chat/>` citation rendering
+ */
+export function createReadableCitationSourceLabel(source: string): string {
+    const trimmed = trimToNormalized(source);
+    if (!trimmed) {
+        return source;
+    }
+
+    const parsedUrl = parseCitationUrl(trimmed);
+    const filenameCandidate = parsedUrl
+        ? getUrlLabelCandidate(parsedUrl) || parsedUrl.hostname.replace(/^www\./i, '')
+        : simplifyKnowledgeLabel(trimmed);
+
+    return normalizeCitationDisplayLabel(filenameCandidate) || simplifyKnowledgeLabel(trimmed);
+}
+
+/**
+ * Normalizes a citation label candidate for display.
+ *
+ * @param label - Raw candidate label.
+ * @returns Cleaned label or `null` when empty.
+ *
+ * @private utility of `<Chat/>` citation rendering
+ */
+function normalizeCitationDisplayLabel(label: string | undefined): string | null {
+    const normalized = collapseWhitespace((label || '').replace(FILENAME_SEPARATOR_REGEX, ' ')).trim();
+
+    return normalized || null;
+}
+
+/**
+ * Parses one HTTP(S) citation URL, returning null for non-URL values.
+ *
+ * @param value - Candidate URL value.
+ * @returns Parsed URL or null.
+ *
+ * @private utility of `<Chat/>` citation rendering
+ */
+function parseCitationUrl(value: string): URL | null {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:' ? url : null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Extracts a readable candidate from a URL path.
+ *
+ * @param url - Parsed citation URL.
+ * @returns URL path label candidate or null.
+ *
+ * @private utility of `<Chat/>` citation rendering
+ */
+function getUrlLabelCandidate(url: URL): string | null {
+    const pathSegments = url.pathname.split('/').filter(Boolean);
+    const lastPathSegment = pathSegments[pathSegments.length - 1];
+    if (!lastPathSegment) {
+        return null;
+    }
+
+    try {
+        return simplifyKnowledgeLabel(decodeURIComponent(lastPathSegment));
+    } catch {
+        return simplifyKnowledgeLabel(lastPathSegment);
+    }
+}
+
 // TODO: [💞] Spread into multiple files

package/src/book-components/Chat/utils/createCitationFootnoteRenderModel.ts

@@ -191,6 +191,7 @@ function normalizeParsedCitation(citation: ParsedCitation): ParsedCitation {
         id: citation.id.trim(),
         source: citation.source.trim(),
         url: citation.url?.trim() || undefined,
+        title: citation.title?.trim() || undefined,
         excerpt: citation.excerpt?.trim() || undefined,
     };
 }
@@ -209,6 +210,7 @@ function mergeParsedCitations(currentCitation: ParsedCitation, incomingCitation:
         id: currentCitation.id || incomingCitation.id,
         source: resolvePreferredCitationSource(currentCitation, incomingCitation),
         url: currentCitation.url || incomingCitation.url,
+        title: currentCitation.title || incomingCitation.title,
         excerpt: currentCitation.excerpt || incomingCitation.excerpt,
     } satisfies ParsedCitation;
 
@@ -216,6 +218,7 @@ function mergeParsedCitations(currentCitation: ParsedCitation, incomingCitation:
         mergedCitation.id === currentCitation.id &&
         mergedCitation.source === currentCitation.source &&
         mergedCitation.url === currentCitation.url &&
+        mergedCitation.title === currentCitation.title &&
         mergedCitation.excerpt === currentCitation.excerpt
     ) {
         return currentCitation;

package/src/book-components/Chat/utils/decodeJsonUnicodeEscapesInMarkdownText.ts

@@ -0,0 +1,178 @@
+import type { string_markdown } from '../../../types/string_markdown';
+
+/**
+ * Pattern for detecting JSON-style Unicode escape sequences in model text.
+ *
+ * @private utility of chat message postprocessing
+ */
+const JSON_UNICODE_ESCAPE_DETECTION_PATTERN = /\\u[0-9a-fA-F]{4}/;
+
+/**
+ * Pattern for decoding JSON-style Unicode escape sequences in model text.
+ *
+ * @private utility of chat message postprocessing
+ */
+const JSON_UNICODE_ESCAPE_PATTERN = /\\u([0-9a-fA-F]{4})/g;
+
+/**
+ * Pattern for detecting fenced markdown code-block boundaries.
+ *
+ * @private utility of chat message postprocessing
+ */
+const MARKDOWN_CODE_FENCE_PATTERN = /^[ \t]{0,3}(`{3,}|~{3,})/;
+
+/**
+ * Minimum code point decoded by the chat Unicode escape normalizer.
+ *
+ * ASCII escapes can be intentional in JSON and security-sensitive examples, so this
+ * helper only decodes non-ASCII characters that were visibly broken in chat text.
+ *
+ * @private utility of chat message postprocessing
+ */
+const FIRST_NON_ASCII_CODE_POINT = 0x80;
+
+/**
+ * Markdown fence state while scanning chat text line-by-line.
+ *
+ * @private utility of chat message postprocessing
+ */
+type MarkdownFenceState = {
+    readonly marker: '`' | '~';
+    readonly length: number;
+};
+
+/**
+ * Decodes JSON-style Unicode escape sequences in markdown prose while preserving code.
+ *
+ * Model/tool output can occasionally arrive as already JSON-escaped text, which makes
+ * natural-language replies render `\u00fd` instead of the decoded character. This
+ * keeps code examples intact by skipping fenced code blocks and inline code spans.
+ *
+ * @param markdown - Markdown chat content to normalize for display.
+ * @returns Markdown chat content with non-ASCII JSON Unicode escapes decoded.
+ *
+ * @private internal utility of `<Chat/>`
+ */
+export function decodeJsonUnicodeEscapesInMarkdownText(markdown: string_markdown): string_markdown {
+    if (!JSON_UNICODE_ESCAPE_DETECTION_PATTERN.test(markdown)) {
+        return markdown;
+    }
+
+    const parts = markdown.split(/(\r\n|\r|\n)/);
+    let fenceState: MarkdownFenceState | null = null;
+    let normalizedMarkdown = '';
+
+    for (let index = 0; index < parts.length; index += 2) {
+        const line = parts[index] ?? '';
+        const newline = parts[index + 1] ?? '';
+        const fenceBoundary = resolveMarkdownFenceBoundary(line);
+
+        if (fenceState) {
+            normalizedMarkdown += line + newline;
+            if (
+                fenceBoundary &&
+                fenceBoundary.marker === fenceState.marker &&
+                fenceBoundary.length >= fenceState.length
+            ) {
+                fenceState = null;
+            }
+            continue;
+        }
+
+        if (fenceBoundary) {
+            fenceState = fenceBoundary;
+            normalizedMarkdown += line + newline;
+            continue;
+        }
+
+        normalizedMarkdown += decodeJsonUnicodeEscapesOutsideInlineCode(line) + newline;
+    }
+
+    return normalizedMarkdown as string_markdown;
+}
+
+/**
+ * Resolves one markdown code-fence boundary from a line.
+ *
+ * @private utility of `decodeJsonUnicodeEscapesInMarkdownText`
+ */
+function resolveMarkdownFenceBoundary(line: string): MarkdownFenceState | null {
+    const match = line.match(MARKDOWN_CODE_FENCE_PATTERN);
+    const fenceMarker = match?.[1];
+
+    if (!fenceMarker) {
+        return null;
+    }
+
+    return {
+        marker: fenceMarker[0] as MarkdownFenceState['marker'],
+        length: fenceMarker.length,
+    };
+}
+
+/**
+ * Decodes Unicode escapes in one markdown line while skipping inline code spans.
+ *
+ * @private utility of `decodeJsonUnicodeEscapesInMarkdownText`
+ */
+function decodeJsonUnicodeEscapesOutsideInlineCode(line: string): string {
+    let normalizedLine = '';
+    let cursor = 0;
+
+    while (cursor < line.length) {
+        const openingDelimiterStart = line.indexOf('`', cursor);
+        if (openingDelimiterStart === -1) {
+            normalizedLine += decodeJsonUnicodeEscapesInText(line.slice(cursor));
+            break;
+        }
+
+        const openingDelimiterEnd = findBacktickRunEnd(line, openingDelimiterStart);
+        const openingDelimiter = line.slice(openingDelimiterStart, openingDelimiterEnd);
+        const closingDelimiterStart = line.indexOf(openingDelimiter, openingDelimiterEnd);
+
+        normalizedLine += decodeJsonUnicodeEscapesInText(line.slice(cursor, openingDelimiterStart));
+
+        if (closingDelimiterStart === -1) {
+            normalizedLine += line.slice(openingDelimiterStart);
+            break;
+        }
+
+        const closingDelimiterEnd = closingDelimiterStart + openingDelimiter.length;
+        normalizedLine += line.slice(openingDelimiterStart, closingDelimiterEnd);
+        cursor = closingDelimiterEnd;
+    }
+
+    return normalizedLine;
+}
+
+/**
+ * Finds the first character after one contiguous run of backticks.
+ *
+ * @private utility of `decodeJsonUnicodeEscapesInMarkdownText`
+ */
+function findBacktickRunEnd(line: string, startIndex: number): number {
+    let cursor = startIndex;
+
+    while (cursor < line.length && line[cursor] === '`') {
+        cursor++;
+    }
+
+    return cursor;
+}
+
+/**
+ * Decodes non-ASCII JSON Unicode escapes in plain text.
+ *
+ * @private utility of `decodeJsonUnicodeEscapesInMarkdownText`
+ */
+function decodeJsonUnicodeEscapesInText(text: string): string {
+    return text.replace(JSON_UNICODE_ESCAPE_PATTERN, (match, hexadecimalCodePoint: string) => {
+        const codePoint = Number.parseInt(hexadecimalCodePoint, 16);
+
+        if (codePoint < FIRST_NON_ASCII_CODE_POINT) {
+            return match;
+        }
+
+        return String.fromCharCode(codePoint);
+    });
+}

package/src/book-components/Chat/utils/isVisibleChatToolCall.ts

@@ -0,0 +1,23 @@
+import { ASSISTANT_PREPARATION_TOOL_CALL_NAME, type ToolCall } from '../../../types/ToolCall';
+
+/**
+ * Tool calls that stay available in message data but should not be surfaced as user-facing chat progress.
+ *
+ * @private internal utility of `<Chat/>`
+ */
+const HIDDEN_CHAT_TOOL_CALL_NAMES: ReadonlySet<string> = new Set([
+    ASSISTANT_PREPARATION_TOOL_CALL_NAME,
+    'agent_progress',
+]);
+
+/**
+ * Returns true when one tool call represents a user-facing action.
+ *
+ * @param toolCall - Tool call candidate.
+ * @returns Whether the tool call should be visible in chat progress and chips.
+ *
+ * @private internal utility of `<Chat/>`
+ */
+export function isVisibleChatToolCall(toolCall: Pick<ToolCall, 'name'>): boolean {
+    return !HIDDEN_CHAT_TOOL_CALL_NAMES.has(toolCall.name);
+}

package/src/book-components/Chat/utils/parseCitationsFromContent.ts

@@ -20,6 +20,11 @@ export type ParsedCitation = {
      */
     url?: string;
 
+    /**
+     * Optional human-readable source title.
+     */
+    title?: string;
+
     /**
      * Optional preview/excerpt from the source
      */
@@ -100,6 +105,7 @@ export function dedupeCitationsBySource(citations: ReadonlyArray<ParsedCitation>
             id: existing.id,
             source: existing.source,
             url: existing.url || citation.url,
+            title: existing.title || citation.title,
             excerpt: existing.excerpt || citation.excerpt,
         };
     }

package/src/book-components/Chat/utils/renderMarkdown.ts

@@ -5,7 +5,8 @@ import createDOMPurify, {
     type WindowLike as DomPurifyWindowLike,
 } from 'dompurify';
 import katex from 'katex';
-import { Converter as ShowdownConverter } from 'showdown';
+import type { Converter as ShowdownConverter } from 'showdown';
+import showdown from 'showdown';
 import type { string_html, string_markdown } from '../../../types/string_markdown';
 import { TODO_USE } from '../../../utils/organization/TODO_USE';
 import { createCitationMarkerRegex, parseCitationMarker } from './parseCitationMarker';
@@ -507,7 +508,7 @@ function normalizeMarkdownSublists(markdown: string_markdown): string_markdown {
 function createChatMarkdownConverter(options?: RenderMarkdownOptions): ShowdownConverter {
     const citationReferenceClassName = options?.citationReferenceClassName ?? DEFAULT_CITATION_REFERENCE_CLASS_NAME;
 
-    return new ShowdownConverter({
+    return new showdown.Converter({
         flavor: 'github',
         tables: true,
         strikethrough: true,

package/src/book-components/_common/Dropdown/Dropdown.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import React, { ReactNode, useState } from 'react';
+import React, { type ReactNode, useState } from 'react';
 import { HamburgerMenu } from '../HamburgerMenu/HamburgerMenu';
 import { classNames } from '../react-utils/classNames';
 import styles from './Dropdown.module.css';

package/src/book-components/_common/MenuHoisting/MenuHoistingContext.tsx

@@ -1,4 +1,4 @@
-import { createContext, ReactNode, useContext, useState } from 'react';
+import { createContext, type ReactNode, useContext, useState } from 'react';
 
 /**
  * Item that can be hoisted to the top menu

package/src/book-components/_common/Modal/Modal.tsx

@@ -1,4 +1,4 @@
-import { ReactNode, useEffect } from 'react';
+import { type ReactNode, useEffect } from 'react';
 import { createPortal } from 'react-dom';
 import { classNames } from '../react-utils/classNames';
 import styles from './Modal.module.css';

package/src/book-components/icons/AboutIcon.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { SVGProps } from 'react';
+import type { SVGProps } from 'react';
 
 /**
  * Renders an information/about icon.

package/src/book-components/icons/DownloadIcon.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { SVGProps } from 'react';
+import type { SVGProps } from 'react';
 
 /**
  * Renders a download icon.

package/src/book-components/icons/ExitFullscreenIcon.tsx

@@ -1,4 +1,4 @@
-import { JSX } from 'react';
+import type { JSX } from 'react';
 import iconAsset from './ExitFullscreenIcon.svg';
 // <- TODO: [😺] Is this type of SVG import working correctly?
 // <- TODO: [😺] Try also the png import if SVG works

package/src/book-components/icons/FullscreenIcon.tsx

@@ -1,4 +1,4 @@
-import { JSX } from 'react';
+import type { JSX } from 'react';
 
 /**
  * Renders an icon that represents the fullscreen action

package/src/cli/cli-commands/agent/agentCliOptions.ts

@@ -0,0 +1,92 @@
+import type {
+    Command as Program /* <- Note: [🔸] Using Program because Command is misleading name */,
+} from 'commander';
+import { NotAllowed } from '../../../errors/NotAllowed';
+import type {
+    NormalizedPromptRunnerSelectionCliOptions,
+    PromptRunnerSelectionCliOptions,
+} from '../common/promptRunnerCliOptions';
+import { normalizePromptRunnerSelectionCliOptions } from '../common/promptRunnerCliOptions';
+
+/**
+ * Commander option bag shared by `ptbk agent` subcommands.
+ *
+ * @private internal utility of `ptbk agent`
+ */
+export type AgentCommandCliOptions = PromptRunnerSelectionCliOptions & {
+    readonly agent?: string;
+    readonly context?: string;
+    readonly message?: string;
+};
+
+/**
+ * Normalized shared options used by local `ptbk agent` subcommands.
+ *
+ * @private internal utility of `ptbk agent`
+ */
+export type NormalizedAgentCommandRunnerOptions = NormalizedPromptRunnerSelectionCliOptions & {
+    readonly isVerbose: boolean;
+};
+
+/**
+ * Normalizes shared runner flags for local agent subcommands.
+ *
+ * @private internal utility of `ptbk agent`
+ */
+export function normalizeAgentCommandRunnerOptions(
+    cliOptions: AgentCommandCliOptions,
+    command: Program,
+): NormalizedAgentCommandRunnerOptions {
+    return {
+        ...normalizePromptRunnerSelectionCliOptions(cliOptions, {
+            isAgentRequired: true,
+        }),
+        isVerbose: resolveCommandVerboseOption(command),
+    };
+}
+
+// Note: [🟡] Code for CLI command options [agent](src/cli/cli-commands/agent/agentCliOptions.ts) should never be published outside of `@promptbook/cli`
+// Note: [💞] Ignore a discrepancy between file name and exported helper names
+
+/**
+ * Returns the required agent book path from Commander options.
+ *
+ * @private internal utility of `ptbk agent`
+ */
+export function resolveRequiredAgentPath(cliOptions: AgentCommandCliOptions): string {
+    const agentPath = cliOptions.agent?.trim();
+
+    if (!agentPath) {
+        throw new NotAllowed('Pass an agent book path in `--agent`.');
+    }
+
+    return agentPath;
+}
+
+/**
+ * Returns the required single-turn user message from Commander options.
+ *
+ * @private internal utility of `ptbk agent`
+ */
+export function resolveRequiredAgentMessage(cliOptions: AgentCommandCliOptions): string {
+    const message = cliOptions.message?.trim();
+
+    if (!message) {
+        throw new NotAllowed('Pass a non-empty user message in `--message`.');
+    }
+
+    return message;
+}
+
+/**
+ * Resolves the inherited `--verbose` flag from the current Commander command chain.
+ *
+ * @private internal utility of `ptbk agent`
+ */
+function resolveCommandVerboseOption(command: Program): boolean {
+    const globalOptions = command.optsWithGlobals() as {
+        readonly verbose?: boolean;
+    };
+
+    return globalOptions.verbose ?? false;
+}

package/src/cli/cli-commands/agent/chat.ts

@@ -0,0 +1,54 @@
+import type {
+    Command as Program /* <- Note: [🔸] Using Program because Command is misleading name */,
+} from 'commander';
+import { spaceTrim } from 'spacetrim';
+import type { $side_effect } from '../../../utils/organization/$side_effect';
+import { handleActionErrors } from '../common/handleActionErrors';
+import {
+    addPromptRunnerRuntimeOptions,
+    addPromptRunnerSelectionOptions,
+    PROMPT_RUNNER_DESCRIPTION,
+} from '../common/promptRunnerCliOptions';
+import type { AgentCommandCliOptions } from './agentCliOptions';
+import { normalizeAgentCommandRunnerOptions, resolveRequiredAgentPath } from './agentCliOptions';
+
+/**
+ * Initializes `agent chat` command for Promptbook CLI utilities.
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI.
+ *
+ * @private internal function of `promptbookCli`
+ */
+export function $initializeAgentChatCommand(program: Program): $side_effect {
+    const command = program.command('chat');
+    command.description(
+        spaceTrim(`
+            Run an interactive CLI chat with one Promptbook agent book
+
+            ${PROMPT_RUNNER_DESCRIPTION}
+        `),
+    );
+
+    command.requiredOption('--agent <agent-book-path>', 'Path to the agent .book file');
+    addPromptRunnerSelectionOptions(command);
+    addPromptRunnerRuntimeOptions(command);
+    command.option('--context <context-or-file>', 'Append extra context either inline or from a file path');
+
+    command.action(
+        handleActionErrors(async (cliOptions, commandProgram) => {
+            const options = cliOptions as AgentCommandCliOptions;
+            const runnerOptions = normalizeAgentCommandRunnerOptions(options, commandProgram as Program);
+            const { runAgentChat } = await import('../../../../scripts/run-agent-chat/runAgentChat');
+
+            await runAgentChat({
+                agentPath: resolveRequiredAgentPath(options),
+                context: options.context,
+                currentWorkingDirectory: process.cwd(),
+                ...runnerOptions,
+            });
+        }),
+    );
+}
+
+// Note: [🟡] Code for CLI command [agent chat](src/cli/cli-commands/agent/chat.ts) should never be published outside of `@promptbook/cli`
+// Note: [💞] Ignore a discrepancy between file name and entity name

package/src/cli/cli-commands/agent/exec.ts

@@ -0,0 +1,60 @@
+import type {
+    Command as Program /* <- Note: [🔸] Using Program because Command is misleading name */,
+} from 'commander';
+import { spaceTrim } from 'spacetrim';
+import type { $side_effect } from '../../../utils/organization/$side_effect';
+import { handleActionErrors } from '../common/handleActionErrors';
+import {
+    addPromptRunnerRuntimeOptions,
+    addPromptRunnerSelectionOptions,
+    PROMPT_RUNNER_DESCRIPTION,
+} from '../common/promptRunnerCliOptions';
+import type { AgentCommandCliOptions } from './agentCliOptions';
+import {
+    normalizeAgentCommandRunnerOptions,
+    resolveRequiredAgentMessage,
+    resolveRequiredAgentPath,
+} from './agentCliOptions';
+
+/**
+ * Initializes `agent exec` command for Promptbook CLI utilities.
+ *
+ * Note: `$` is used to indicate that this function is not a pure function - it registers a command in the CLI.
+ *
+ * @private internal function of `promptbookCli`
+ */
+export function $initializeAgentExecCommand(program: Program): $side_effect {
+    const command = program.command('exec');
+    command.description(
+        spaceTrim(`
+            Run one non-interactive message with a Promptbook agent book and print the answer
+
+            ${PROMPT_RUNNER_DESCRIPTION}
+        `),
+    );
+
+    command.requiredOption('--agent <agent-book-path>', 'Path to the agent .book file');
+    command.requiredOption('--message <message>', 'User message to send to the agent');
+    addPromptRunnerSelectionOptions(command);
+    addPromptRunnerRuntimeOptions(command);
+    command.option('--context <context-or-file>', 'Append extra context either inline or from a file path');
+
+    command.action(
+        handleActionErrors(async (cliOptions, commandProgram) => {
+            const options = cliOptions as AgentCommandCliOptions;
+            const runnerOptions = normalizeAgentCommandRunnerOptions(options, commandProgram as Program);
+            const { runAgentExec } = await import('../../../../scripts/run-agent-chat/runAgentExec');
+
+            await runAgentExec({
+                agentPath: resolveRequiredAgentPath(options),
+                context: options.context,
+                message: resolveRequiredAgentMessage(options),
+                currentWorkingDirectory: process.cwd(),
+                ...runnerOptions,
+            });
+        }),
+    );
+}
+
+// Note: [🟡] Code for CLI command [agent exec](src/cli/cli-commands/agent/exec.ts) should never be published outside of `@promptbook/cli`
+// Note: [💞] Ignore a discrepancy between file name and entity name