@promptbook/cli 0.112.0-126 → 0.112.0-128

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/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/cli/cli-commands/agents-server/ensureAgentsServerEnvFile.ts

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import { ensureProjectEnvFile, type EnsureProjectEnvFileResult } from '../common/projectInitialization';
 
 /**
@@ -70,10 +71,20 @@ function createAgentsServerEnvVariable(name: string, value: string): RequiredAge
  */
 function buildMissingEnvVariablesBlock(variables: ReadonlyArray<RequiredAgentsServerEnvVariable>): string {
     const variableBlocks = variables.map(({ documentationUrl, name, value }) =>
-        [AGENTS_SERVER_ENV_CREATED_COMMENT, `# Documentation: ${documentationUrl}`, `${name}=${value}`].join('\n'),
+        spaceTrim(`
+            ${AGENTS_SERVER_ENV_CREATED_COMMENT}
+            # Documentation: ${documentationUrl}
+            ${name}=${value}
+        `),
     );
 
-    return ['# Promptbook Agents Server', ...variableBlocks].join('\n\n');
+    return spaceTrim(
+        (block) => `
+            # Promptbook Agents Server
+
+            ${block(variableBlocks.join('\n\n'))}
+        `,
+    );
 }
 
 // Note: [🟡] Code for Agents Server environment bootstrapping [ensureAgentsServerEnvFile](src/cli/cli-commands/agents-server/ensureAgentsServerEnvFile.ts) should never be published outside of `@promptbook/cli`

package/src/cli/cli-commands/coder/getDefaultCoderPackageJsonScripts.ts

@@ -4,7 +4,7 @@
 const DEFAULT_CODER_PACKAGE_JSON_SCRIPTS = {
     'coder:generate-boilerplates': 'ptbk coder generate-boilerplates --template ./prompts/templates/common.md',
     'coder:run':
-        'ptbk coder run --harness openai-codex --model gpt-5.4 --thinking-level xhigh --agent agents/developer.book --context AGENTS.md --no-wait',
+        'ptbk coder run --harness openai-codex --model gpt-5.4 --thinking-level xhigh --agent agents/developer.book --context AGENTS.md',
     // 'coder:find-refactor-candidates': 'ptbk coder find-refactor-candidates',
     'coder:verify': 'ptbk coder verify',
 } as const satisfies Readonly<Record<string, string>>;

package/src/cli/cli-commands/coder/run.ts

@@ -63,16 +63,17 @@ export function $initializeCoderRunCommand(program: Program): $side_effect {
     addPromptRunnerExecutionOptions(command);
     command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption, 0);
     command.option(
-        '--wait [duration]',
+        '--wait <duration>',
         spaceTrim(`
-            Wait between prompt rounds.
-            Without a value (default): waits for user confirmation before each prompt (interactive mode).
-            With a duration like 1h, 30m, 5s: waits that long between prompts to avoid hitting rate limits of the harness.
+            Wait this long between prompt rounds to avoid hitting rate limits of the harness.
+            Accepts durations like 1h, 30m, 5s.
         `),
-        true,
     );
-    // Note: --no-wait disables the default interactive wait-for-user behaviour
-    command.option('--no-wait', 'Skip all waiting between prompts and run non-interactively');
+    // Note: --no-auto disables the default auto behaviour and waits for user confirmation before each prompt
+    command.option(
+        '--no-auto',
+        'Wait for user confirmation before each prompt instead of running automatically through the queue',
+    );
     command.option(
         '--auto-migrate',
         'Run testing-server database migrations automatically after each successfully processed prompt',
@@ -92,6 +93,7 @@ export function $initializeCoderRunCommand(program: Program): $side_effect {
                 preserveLogs,
                 priority,
                 wait,
+                auto,
                 autoMigrate,
                 allowDestructiveAutoMigrate,
             } = cliOptions as {
@@ -101,7 +103,8 @@ export function $initializeCoderRunCommand(program: Program): $side_effect {
                 readonly test?: string | string[];
                 readonly preserveLogs: boolean;
                 readonly priority: number;
-                readonly wait: boolean | string;
+                readonly wait?: string;
+                readonly auto: boolean;
                 readonly autoMigrate: boolean;
                 readonly allowDestructiveAutoMigrate: boolean;
             } & PromptRunnerCliOptions;
@@ -111,18 +114,12 @@ export function $initializeCoderRunCommand(program: Program): $side_effect {
                 isAgentRequired: !dryRun,
             });
 
-            // [1] Parse the --wait option:
-            //   true (default or --wait without value): wait for user confirmation
-            //   false (--no-wait): no waiting at all
-            //   string (--wait 1h): wait that long between prompt rounds
-            let waitForUser = false;
-            let waitBetweenPrompts = 0;
-
-            if (wait === true) {
-                waitForUser = true;
-            } else if (typeof wait === 'string' && wait !== '') {
-                waitBetweenPrompts = parseDuration(wait);
-            }
+            // [1] Parse the --wait and --no-auto options:
+            //   default: run automatically through the queue (no waiting)
+            //   --no-auto: wait for user confirmation before each prompt (interactive mode)
+            //   --wait <duration>: wait that long between prompt rounds to avoid rate limits
+            const waitForUser = !auto;
+            const waitBetweenPrompts = typeof wait === 'string' && wait !== '' ? parseDuration(wait) : 0;
 
             // Convert commander options to RunOptions format
             const runOptions = {

package/src/cli/cli-commands/coder/server.ts

@@ -79,15 +79,16 @@ export function $initializeCoderServerCommand(program: Program): $side_effect {
     addPromptRunnerExecutionOptions(command);
     command.option('--priority <minimum-priority>', 'Filter prompts by minimum priority level', parseIntOption, 0);
     command.option(
-        '--wait [duration]',
+        '--wait <duration>',
         spaceTrim(`
-            Wait between prompt rounds.
-            Without a value (default): waits for user confirmation before each prompt (interactive mode).
-            With a duration like 1h, 30m, 5s: waits that long between prompts to avoid hitting rate limits of the harness.
+            Wait this long between prompt rounds to avoid hitting rate limits of the harness.
+            Accepts durations like 1h, 30m, 5s.
         `),
-        true,
     );
-    command.option('--no-wait', 'Skip all waiting between prompts and run non-interactively');
+    command.option(
+        '--no-auto',
+        'Wait for user confirmation before each prompt instead of running automatically through the queue',
+    );
     command.option(
         '--auto-migrate',
         'Run testing-server database migrations automatically after each successfully processed prompt',
@@ -108,6 +109,7 @@ export function $initializeCoderServerCommand(program: Program): $side_effect {
                 preserveLogs,
                 priority,
                 wait,
+                auto,
                 autoMigrate,
                 allowDestructiveAutoMigrate,
             } = cliOptions as {
@@ -118,7 +120,8 @@ export function $initializeCoderServerCommand(program: Program): $side_effect {
                 readonly test?: string | string[];
                 readonly preserveLogs: boolean;
                 readonly priority: number;
-                readonly wait: boolean | string;
+                readonly wait?: string;
+                readonly auto: boolean;
                 readonly autoMigrate: boolean;
                 readonly allowDestructiveAutoMigrate: boolean;
             } & PromptRunnerCliOptions;
@@ -129,15 +132,9 @@ export function $initializeCoderServerCommand(program: Program): $side_effect {
                 isAgentRequired: !dryRun,
             });
 
-            // [1] Parse the --wait option (same logic as `coder run`)
-            let waitForUser = false;
-            let waitBetweenPrompts = 0;
-
-            if (wait === true) {
-                waitForUser = true;
-            } else if (typeof wait === 'string' && wait !== '') {
-                waitBetweenPrompts = parseDuration(wait);
-            }
+            // [1] Parse the --wait and --no-auto options (same logic as `coder run`)
+            const waitForUser = !auto;
+            const waitBetweenPrompts = typeof wait === 'string' && wait !== '' ? parseDuration(wait) : 0;
 
             const runOptions = {
                 port,

package/src/cli/common/$deprecateCliCommand.ts

@@ -1,5 +1,6 @@
 import colors from 'colors';
 import { Command } from 'commander';
+import { spaceTrim } from 'spacetrim';
 import type { $side_effect } from '../../utils/organization/$side_effect';
 
 /**
@@ -8,7 +9,15 @@ import type { $side_effect } from '../../utils/organization/$side_effect';
  * @private utility of CLI
  */
 export function $deprecateCliCommand(command: Command, deprecationMessage: string): $side_effect {
-    command.description(`${command.description()}\n\nDeprecated: ${deprecationMessage}`);
+    command.description(
+        spaceTrim(
+            (block) => `
+                ${block(command.description())}
+
+                Deprecated: ${block(deprecationMessage)}
+            `,
+        ),
+    );
     command.hook('preAction', () => {
         console.warn(colors.yellow(createDeprecatedCliCommandWarning(command, deprecationMessage)));
     });

package/src/commitments/GOAL/GOAL.ts

@@ -101,8 +101,13 @@ export class GoalCommitmentDefinition extends BaseCommitmentDefinition<'GOAL' |
             return requirements;
         }
 
-        // Add goal as a proper h2 section to the system message
-        const goalSection = `## Goal\n\n${trimmedContent}`;
+        const goalSection = spaceTrim(
+            (block) => `
+                ## Goal
+
+                ${block(trimmedContent)}
+            `,
+        );
         const requirementsWithGoal = this.appendToSystemMessage(requirements, goalSection, '\n\n');
 
         return this.appendToPromptSuffix(requirementsWithGoal, trimmedContent);

package/src/commitments/LANGUAGE/LANGUAGE.ts

@@ -70,8 +70,13 @@ export class LanguageCommitmentDefinition extends BaseCommitmentDefinition<'LANG
             return requirements;
         }
 
-        // Add language as a bullet under a ## Language section
-        const languageSection = `## Language\n\n-   Your language is ${trimmedContent}`;
+        const languageSection = spaceTrim(
+            (block) => `
+                ## Language
+
+                -   Your language is ${block(trimmedContent)}
+            `,
+        );
 
         return this.appendToSystemMessage(requirements, languageSection, '\n\n');
     }

package/src/commitments/TEAM/TEAM.ts

@@ -448,7 +448,18 @@ function buildTeammateMetadata(entry: TeamToolEntry): TeamToolResult['teammate']
  * Builds the teammate request text, optionally including context.
  */
 function buildTeammateRequest(message: string, context?: string): string {
-    return context ? `${message}\n\nContext:\n${context}` : message;
+    if (!context) {
+        return message;
+    }
+
+    return spaceTrim(
+        (block) => `
+            ${block(message)}
+
+            Context:
+            ${block(context)}
+        `,
+    );
 }
 
 /**

package/src/commitments/USE_PROJECT/createUseProjectToolFunctions.ts

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import type { ToolFunction } from '../../scripting/javascript/JavascriptExecutionToolsOptions';
 import type { string_javascript_name } from '../../types/string_person_fullname';
 import { decodeAttachmentAsText, DEFAULT_ATTACHMENT_TEXT_DECODE_BYTES } from '../../utils/files/decodeAttachmentAsText';
@@ -197,7 +198,13 @@ export function createUseProjectToolFunctions(): Record<string_javascript_name,
                 const lineRangedContent = applyOptionalLineRange(decodedContent, args.startLine, args.endLine);
                 const wasCharacterTruncated = lineRangedContent.length > MAX_PROJECT_FILE_CONTENT_CHARACTERS;
                 const contentToReturn = wasCharacterTruncated
-                    ? `${lineRangedContent.slice(0, MAX_PROJECT_FILE_CONTENT_CHARACTERS)}\n\n[...truncated...]`
+                    ? spaceTrim(
+                          (block) => `
+                              ${block(lineRangedContent.slice(0, MAX_PROJECT_FILE_CONTENT_CHARACTERS))}
+
+                              [...truncated...]
+                          `,
+                      )
                     : lineRangedContent;
 
                 const wasTruncated = decoded.isTruncated || wasCharacterTruncated;

package/src/import-plugins/JsonFileImportPlugin.ts

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import type { FileImportPlugin } from './FileImportPlugin';
 
 /**
@@ -14,10 +15,22 @@ export const JsonFileImportPlugin: FileImportPlugin = {
         try {
             const json = JSON.parse(content);
             const formattedJson = JSON.stringify(json, null, 4);
-            return `\`\`\`json\n${formattedJson}\n\`\`\``;
+            return spaceTrim(
+                (block) => `
+                    \`\`\`json
+                    ${block(formattedJson)}
+                    \`\`\`
+                `,
+            );
         } catch (error) {
             // If JSON is invalid, still import it but maybe not as pretty JSON
-            return `\`\`\`json\n${content}\n\`\`\``;
+            return spaceTrim(
+                (block) => `
+                    \`\`\`json
+                    ${block(content)}
+                    \`\`\`
+                `,
+            );
         }
     },
 };

package/src/import-plugins/TextFileImportPlugin.ts

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import { mimeTypeToExtension } from '../utils/files/mimeTypeToExtension';
 import type { FileImportPlugin } from './FileImportPlugin';
 
@@ -23,6 +24,12 @@ export const TextFileImportPlugin: FileImportPlugin = {
         const extension = mimeTypeToExtension(mimeType);
         const codeBlockType = extension || 'txt';
 
-        return `\`\`\`${codeBlockType}\n${content}\n\`\`\``;
+        return spaceTrim(
+            (block) => `
+                \`\`\`${codeBlockType}
+                ${block(content)}
+                \`\`\`
+            `,
+        );
     },
 };

package/src/llm-providers/_common/register/$registeredLlmToolsMessage.ts

@@ -589,7 +589,12 @@ function colorizeAvailableProviderMessage(
  * @private internal function of `$registeredLlmToolsMessage`
  */
 function createUsedEnvMessage(): string {
-    return $usedEnvFilename === null ? `Unknown \`.env\` file` : `Used \`.env\` file:\n${$usedEnvFilename}`;
+    return $usedEnvFilename === null
+        ? `Unknown \`.env\` file`
+        : spaceTrim(`
+              Used \`.env\` file:
+              ${$usedEnvFilename}
+          `);
 }
 
 // TODO: [®] DRY Register logic