@promptbook/cli 0.112.0-35 → 0.112.0-36

package/umd/index.umd.js

@@ -60,7 +60,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-35';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-36';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -1700,6 +1700,220 @@
     // Note: [🟡] Code for CLI command [find-refactor-candidates](src/cli/cli-commands/coder/find-refactor-candidates.ts) should never be published outside of `@promptbook/cli`
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
+    /**
+     * This error indicates that promptbook not found in the collection
+     *
+     * @public exported from `@promptbook/core`
+     */
+    class NotFoundError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'NotFoundError';
+            Object.setPrototypeOf(this, NotFoundError.prototype);
+        }
+    }
+
+    /**
+     * Relative path to the root prompts directory used by Promptbook coder utilities.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    const PROMPTS_DIRECTORY_PATH = 'prompts';
+    /**
+     * Relative path to the archive directory used by `coder verify`.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    const PROMPTS_DONE_DIRECTORY_PATH = path.join(PROMPTS_DIRECTORY_PATH, 'done');
+    /**
+     * Relative path to the project-owned boilerplate templates directory.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    const PROMPTS_TEMPLATES_DIRECTORY_PATH = path.join(PROMPTS_DIRECTORY_PATH, 'templates');
+    /**
+     * Built-in boilerplate templates shared by `coder init` and `coder generate-boilerplates`.
+     */
+    const DEFAULT_CODER_PROMPT_TEMPLATE_DEFINITIONS = [
+        {
+            id: 'common',
+            relativeFilePath: path.join(PROMPTS_TEMPLATES_DIRECTORY_PATH, 'common.md'),
+            slugPrefix: null,
+            content: buildCoderPromptTemplateContent([
+                '-   @@@',
+                '-   Keep in mind the DRY _(don\'t repeat yourself)_ principle.',
+                '-   Do a proper analysis of the current functionality before you start implementing.',
+                '-   Add the changes into the [changelog](./changelog/_current-preversion.md)',
+            ]),
+        },
+        {
+            id: 'agents-server',
+            relativeFilePath: path.join(PROMPTS_TEMPLATES_DIRECTORY_PATH, 'agents-server.md'),
+            slugPrefix: 'agents-server',
+            content: buildCoderPromptTemplateContent([
+                '-   @@@',
+                '-   Keep in mind the DRY _(don\'t repeat yourself)_ principle.',
+                '-   Do a proper analysis of the current functionality before you start implementing.',
+                '-   You are working with the [Agents Server](apps/agents-server)',
+                '-   If you need to do the database migration, do it',
+                '-   Add the changes into the [changelog](changelog/_current-preversion.md)',
+            ]),
+        },
+    ];
+    /**
+     * Lists the built-in coder boilerplate templates.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    function getDefaultCoderPromptTemplateDefinitions() {
+        return DEFAULT_CODER_PROMPT_TEMPLATE_DEFINITIONS;
+    }
+    /**
+     * Resolves one built-in coder boilerplate template definition by its stable identifier.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    function getDefaultCoderPromptTemplateDefinition(template) {
+        const definition = getDefaultCoderPromptTemplateDefinitionOrUndefined(template);
+        if (!definition) {
+            throw new NotFoundError(`Built-in coder prompt template \`${template}\` was not found.`);
+        }
+        return definition;
+    }
+    /**
+     * Ensures the default project-owned coder template files exist without overwriting user customizations.
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    async function ensureDefaultCoderPromptTemplateFiles(projectPath) {
+        const ensuredTemplateFiles = [];
+        for (const definition of DEFAULT_CODER_PROMPT_TEMPLATE_DEFINITIONS) {
+            const absoluteTemplatePath = path.join(projectPath, definition.relativeFilePath);
+            if (await isExistingFile$1(absoluteTemplatePath)) {
+                ensuredTemplateFiles.push({
+                    id: definition.id,
+                    relativeFilePath: definition.relativeFilePath,
+                    status: 'unchanged',
+                });
+                continue;
+            }
+            await promises.writeFile(absoluteTemplatePath, `${definition.content}\n`, 'utf-8');
+            ensuredTemplateFiles.push({
+                id: definition.id,
+                relativeFilePath: definition.relativeFilePath,
+                status: 'created',
+            });
+        }
+        return ensuredTemplateFiles;
+    }
+    /**
+     * Resolves the template requested by `coder generate-boilerplates`.
+     *
+     * Supports three modes:
+     * - omitted option => built-in `common`
+     * - built-in alias => one of the shared default templates
+     * - relative path => markdown template file resolved from the project root
+     *
+     * @private internal utility of `ptbk coder`
+     */
+    async function resolveCoderPromptTemplate({ projectPath, templateOption, }) {
+        const normalizedTemplateOption = normalizeCoderPromptTemplateOption(templateOption);
+        if (!normalizedTemplateOption) {
+            return createResolvedBuiltInCoderPromptTemplate('common');
+        }
+        const builtInTemplateDefinition = getDefaultCoderPromptTemplateDefinitionOrUndefined(normalizedTemplateOption);
+        if (builtInTemplateDefinition) {
+            return createResolvedBuiltInCoderPromptTemplate(builtInTemplateDefinition.id);
+        }
+        const absoluteTemplatePath = path.join(projectPath, normalizedTemplateOption);
+        try {
+            const content = (await promises.readFile(absoluteTemplatePath, 'utf-8')).trim();
+            return {
+                identifier: normalizedTemplateOption,
+                relativeFilePath: normalizedTemplateOption,
+                content,
+                slugPrefix: deriveCoderPromptSlugPrefix(normalizedTemplateOption),
+            };
+        }
+        catch (error) {
+            if (isNodeJsErrorWithCode(error, 'ENOENT')) {
+                throw new NotFoundError(_spaceTrim.spaceTrim(`
+                    Prompt boilerplate template was not found at \`${normalizedTemplateOption}\`.
+
+                    -   The \`--template\` option resolves paths relative to the current project root: \`${projectPath}\`
+                    -   Run \`ptbk coder init\` to create the default project templates in \`${PROMPTS_TEMPLATES_DIRECTORY_PATH}\`
+                    -   Or omit \`--template\` / use the built-in aliases \`common\` or \`agents-server\`
+                `));
+            }
+            throw error;
+        }
+    }
+    /**
+     * Normalizes one raw `--template` option to either a trimmed string or `undefined`.
+     */
+    function normalizeCoderPromptTemplateOption(templateOption) {
+        const normalizedTemplateOption = templateOption === null || templateOption === void 0 ? void 0 : templateOption.trim();
+        if (!normalizedTemplateOption) {
+            return undefined;
+        }
+        return normalizedTemplateOption;
+    }
+    /**
+     * Resolves one built-in template definition without throwing.
+     */
+    function getDefaultCoderPromptTemplateDefinitionOrUndefined(template) {
+        return DEFAULT_CODER_PROMPT_TEMPLATE_DEFINITIONS.find((definition) => definition.id === template);
+    }
+    /**
+     * Builds stable markdown content for one coder prompt template without indentation drift.
+     */
+    function buildCoderPromptTemplateContent(lines) {
+        return lines.join('\n');
+    }
+    /**
+     * Creates a fully resolved template payload from one built-in definition.
+     */
+    function createResolvedBuiltInCoderPromptTemplate(template) {
+        const definition = getDefaultCoderPromptTemplateDefinition(template);
+        return {
+            identifier: definition.id,
+            relativeFilePath: definition.relativeFilePath,
+            content: definition.content,
+            slugPrefix: definition.slugPrefix,
+        };
+    }
+    /**
+     * Derives the filename slug prefix from a project-relative template path.
+     */
+    function deriveCoderPromptSlugPrefix(relativeTemplatePath) {
+        const templateBasename = path.basename(relativeTemplatePath)
+            .replace(/\.[^.]+$/u, '')
+            .replace(/\.template$/u, '');
+        if (templateBasename === 'common') {
+            return null;
+        }
+        return templateBasename;
+    }
+    /**
+     * Checks whether the provided error object exposes a specific Node.js `code`.
+     */
+    function isNodeJsErrorWithCode(error, code) {
+        return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
+    }
+    /**
+     * Checks whether a path exists and is a file.
+     */
+    async function isExistingFile$1(path) {
+        try {
+            return (await promises.stat(path)).isFile();
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    // Note: [🟡] Code for coder boilerplate templates [boilerplateTemplates](src/cli/cli-commands/coder/boilerplateTemplates.ts) should never be published outside of `@promptbook/cli`
+    // Note: [💞] Ignore a discrepancy between file name and exported helper names
+
     /**
      * Initializes `coder generate-boilerplates` command for Promptbook CLI utilities
      *
@@ -1713,12 +1927,21 @@
             Generate prompt boilerplate files with unique emoji tags
         `));
         command.option('--count <count>', `Number of prompt boilerplate files to generate`, '5');
-        command.option('--template <template>', `Prompt template to use: common | agents-server`, 'common');
+        command.option('--template <template>', _spaceTrim.spaceTrim(`
+            Prompt template to use.
+
+            Accepts either a built-in alias (${getDefaultCoderPromptTemplateDefinitions()
+        .map(({ id }) => id)
+        .join(', ')}) or a markdown file path relative to the current project root.
+        `));
         command.action(handleActionErrors(async (cliOptions) => {
             const { count: countOption, template: templateOption } = cliOptions;
             const filesCount = parseFilesCount(countOption);
-            const template = parsePromptTemplate(templateOption);
-            await generatePromptBoilerplate({ filesCount, template });
+            await generatePromptBoilerplate({
+                projectPath: process.cwd(),
+                filesCount,
+                templateOption,
+            });
             return process.exit(0);
         }));
     }
@@ -1727,14 +1950,15 @@
      *
      * @private internal function of `generatePromptBoilerplate` command
      */
-    async function generatePromptBoilerplate({ filesCount, template, }) {
+    async function generatePromptBoilerplate({ projectPath, filesCount, templateOption, }) {
         // Note: Import these dynamically to avoid circular dependencies and keep CLI fast
         const { buildPromptFilename, getPromptNumbering } = await Promise.resolve().then(function () { return getPromptNumbering$1; });
         const { formatPromptEmojiTag, getFreshPromptEmojiTags } = await Promise.resolve().then(function () { return promptEmojiTags; });
         console.info(`🚀  Generate prompt boilerplate files`);
-        const promptTemplateContent = loadPromptTemplate(template);
+        fs.mkdirSync(path.join(projectPath, PROMPTS_DIRECTORY_PATH), { recursive: true });
+        const promptTemplate = await resolveCoderPromptTemplate({ projectPath, templateOption });
         const promptNumbering = await getPromptNumbering({
-            promptsDir: path.join(process.cwd(), 'prompts'),
+            promptsDir: path.join(projectPath, PROMPTS_DIRECTORY_PATH),
             step: 10,
             ignoreGlobs: ['**/node_modules/**'],
         });
@@ -1743,7 +1967,7 @@
         console.info(colors__default["default"].blue(`Highest existing number for ${promptNumbering.datePrefix} found: ${highestNumberFormatted}`));
         const { availableCount, selectedEmojis } = await getFreshPromptEmojiTags({
             count: filesCount,
-            rootDir: process.cwd(),
+            rootDir: projectPath,
         });
         console.info(colors__default["default"].green(`Found ${availableCount} available fresh emojis`));
         console.info(colors__default["default"].green(`Selected emojis: ${selectedEmojis.map((emoji) => formatPromptEmojiTag(emoji)).join(' ')}`));
@@ -1755,8 +1979,9 @@
             const number = promptNumbering.startNumber + i * promptNumbering.step;
             const title = titles[i % titles.length];
             const emoji = selectedEmojis[i];
-            const filename = buildPromptFilename(promptNumbering.datePrefix, number, buildPromptSlug$1(template, title));
-            const filepath = path.join('prompts', filename);
+            const filename = buildPromptFilename(promptNumbering.datePrefix, number, buildPromptSlug$1(promptTemplate.slugPrefix, title));
+            const filepath = path.join(PROMPTS_DIRECTORY_PATH, filename);
+            const absoluteFilepath = path.join(projectPath, filepath);
             const emojiTag = formatPromptEmojiTag(emoji);
             const one = _spaceTrim.spaceTrim((block) => `
 
@@ -1764,7 +1989,7 @@
 
                 ${emojiTag} ${title}
 
-                ${block(promptTemplateContent)}
+                ${block(promptTemplate.content)}
             `);
             const content = _spaceTrim.spaceTrim((block) => `
 
@@ -1785,6 +2010,7 @@
             `);
             filesToCreate.push({
                 filepath,
+                absoluteFilepath,
                 filename,
                 content,
                 emoji,
@@ -1794,7 +2020,7 @@
         // Create the files
         console.info(colors__default["default"].yellow(`Creating ${filesToCreate.length} files:`));
         for (const file of filesToCreate) {
-            fs.writeFileSync(file.filepath, file.content, 'utf-8');
+            fs.writeFileSync(file.absoluteFilepath, file.content, 'utf-8');
             console.info(colors__default["default"].green(`✓ Created: ${file.filename} with ${formatPromptEmojiTag(file.emoji)}`));
         }
         console.info(colors__default["default"].bgGreen(` Successfully created ${filesToCreate.length} prompt boilerplate files! `));
@@ -1812,52 +2038,34 @@
         }
         return Math.floor(filesCount);
     }
-    /**
-     * Parses and validates the prompt template name.
-     *
-     * @private internal utility of `generatePromptBoilerplate` command
-     */
-    function parsePromptTemplate(templateOption) {
-        if (templateOption === 'common' ||
-            templateOption === 'agents-server'
-        // <- TODO: Unhardcode and allow this dynamically by the template files.
-        ) {
-            return templateOption;
-        }
-        console.info(colors__default["default"].yellow(`Invalid --template '${templateOption}'. Falling back to default 'common'.`));
-        return 'common';
-    }
-    /**
-     * Loads prompt template markdown content from the local templates folder.
-     *
-     * @private internal utility of `generatePromptBoilerplate` command
-     */
-    function loadPromptTemplate(template) {
-        const templateFilePath = path.join(__dirname, '../../../../scripts/generate-prompt-boilerplate/templates', `${template}.template.md`);
-        return fs.readFileSync(templateFilePath, 'utf-8').trim();
-    }
     /**
      * Builds filename slug from template and placeholder title.
      *
      * @private internal utility of `generatePromptBoilerplate` command
      */
-    function buildPromptSlug$1(template, title) {
-        if (template === 'common') {
+    function buildPromptSlug$1(templateSlugPrefix, title) {
+        if (!templateSlugPrefix) {
             return title;
         }
-        return `${template}-${title}`;
+        return `${templateSlugPrefix}-${title}`;
     }
     // Note: [🟡] Code for CLI command [generate-boilerplates](src/cli/cli-commands/coder/generate-boilerplates.ts) should never be published outside of `@promptbook/cli`
     // Note: [💞] Ignore a discrepancy between file name and entity name
 
     /**
-     * Relative path to the root prompts directory used by Promptbook coder utilities.
-     */
-    const PROMPTS_DIRECTORY_PATH = 'prompts';
-    /**
-     * Relative path to the archive directory used by `coder verify`.
+     * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
+     *
+     * @public exported from `@promptbook/core`
      */
-    const PROMPTS_DONE_DIRECTORY_PATH = path.join(PROMPTS_DIRECTORY_PATH, 'done');
+    class ParseError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = 'ParseError';
+            Object.setPrototypeOf(this, ParseError.prototype);
+        }
+    }
+    // TODO: Maybe split `ParseError` and `ApplyError`
+
     /**
      * Required environment variables for coding-agent git identity.
      */
@@ -1875,6 +2083,58 @@
             value: '13406525ED912F938FEA85AB4046C687298B2382',
         },
     ];
+    /**
+     * Default npm scripts initialized by `ptbk coder init`.
+     */
+    const DEFAULT_CODER_PACKAGE_JSON_SCRIPTS = {
+        'coder:generate-boilerplates': 'npx ptbk coder generate-boilerplates',
+        'coder:run': 'npx ptbk coder run --agent github-copilot --model gpt-5.4 --thinking-level xhigh --context AGENTS.md --no-wait',
+        'coder:find-refactor-candidates': 'npx ptbk coder find-refactor-candidates',
+        'coder:verify': 'npx ptbk coder verify',
+    };
+    /**
+     * Relative path to `.gitignore` in the initialized project.
+     */
+    const GITIGNORE_FILE_PATH = '.gitignore';
+    /**
+     * Relative path to `package.json` in the initialized project.
+     */
+    const PACKAGE_JSON_FILE_PATH = 'package.json';
+    /**
+     * Relative path to the VS Code settings file initialized by `ptbk coder init`.
+     */
+    const VSCODE_SETTINGS_FILE_PATH = '.vscode/settings.json';
+    /**
+     * Relative path to the VS Code directory initialized by `ptbk coder init`.
+     */
+    const VSCODE_DIRECTORY_PATH = '.vscode';
+    /**
+     * VS Code setting key used to route pasted markdown images into prompt-specific screenshots.
+     */
+    const MARKDOWN_COPY_FILES_DESTINATION_SETTING_KEY = 'markdown.copyFiles.destination';
+    /**
+     * Markdown glob used for coder prompt files inside VS Code settings.
+     */
+    const PROMPTS_MARKDOWN_FILE_GLOB = 'prompts/*md';
+    /**
+     * Screenshot destination used for pasted prompt images inside VS Code settings.
+     */
+    const PROMPTS_SCREENSHOT_DESTINATION = './prompts/screenshots/${documentBaseName}.png';
+    /**
+     * Default indentation used when creating new JSON configuration files.
+     */
+    const DEFAULT_JSON_FILE_INDENTATION = '    ';
+    /**
+     * Default newline used when creating new JSON configuration files.
+     */
+    const DEFAULT_JSON_FILE_NEWLINE = '\n';
+    /**
+     * `.gitignore` block required by standalone Promptbook coder projects.
+     */
+    const CODER_GITIGNORE_BLOCK = _spaceTrim.spaceTrim(`
+    # Promptbook Coder
+    /.tmp
+`);
     /**
      * Initializes `coder init` command for Promptbook CLI utilities.
      *
@@ -1888,9 +2148,14 @@
         command.description(_spaceTrim.spaceTrim(`
             Initialize Promptbook coder configuration for current project
 
-            Creates:
+            Creates or updates:
             - prompts/
             - prompts/done/
+            - prompts/templates/common.md
+            - prompts/templates/agents-server.md
+            - .gitignore
+            - package.json
+            - .vscode/settings.json
 
             Ensures required coding-agent environment variables in .env:
             - CODING_AGENT_GIT_NAME
@@ -1902,17 +2167,37 @@
             printInitializationSummary(summary);
         }));
     }
+    /**
+     * Lists the default npm scripts initialized by `ptbk coder init`.
+     *
+     * @private internal utility of `coder init` command
+     */
+    function getDefaultCoderPackageJsonScripts() {
+        return DEFAULT_CODER_PACKAGE_JSON_SCRIPTS;
+    }
     /**
      * Creates or updates all coder configuration artifacts required in the current project.
+     *
+     * @private internal utility of `coder init` command
      */
     async function initializeCoderProjectConfiguration(projectPath) {
         const promptsDirectoryStatus = await ensureDirectory(projectPath, PROMPTS_DIRECTORY_PATH);
         const promptsDoneDirectoryStatus = await ensureDirectory(projectPath, PROMPTS_DONE_DIRECTORY_PATH);
+        const promptsTemplatesDirectoryStatus = await ensureDirectory(projectPath, PROMPTS_TEMPLATES_DIRECTORY_PATH);
+        const promptTemplateFileStatuses = await ensureDefaultCoderPromptTemplateFiles(projectPath);
         const { envFileStatus, initializedEnvVariableNames } = await ensureCoderEnvFile(projectPath);
+        const gitignoreFileStatus = await ensureCoderGitignoreFile(projectPath);
+        const packageJsonFileStatus = await ensureCoderPackageJsonFile(projectPath);
+        const vscodeSettingsFileStatus = await ensureCoderVscodeSettingsFile(projectPath);
         return {
             promptsDirectoryStatus,
             promptsDoneDirectoryStatus,
+            promptsTemplatesDirectoryStatus,
+            promptTemplateFileStatuses,
             envFileStatus,
+            gitignoreFileStatus,
+            packageJsonFileStatus,
+            vscodeSettingsFileStatus,
             initializedEnvVariableNames,
         };
     }
@@ -1958,6 +2243,70 @@
             initializedEnvVariableNames: missingEnvVariables.map(({ name }) => name),
         };
     }
+    /**
+     * Ensures `.gitignore` contains the standalone Promptbook coder cache entry.
+     */
+    async function ensureCoderGitignoreFile(projectPath) {
+        const gitignorePath = path.join(projectPath, GITIGNORE_FILE_PATH);
+        const currentGitignoreContent = await readTextFileIfExists(gitignorePath);
+        if (currentGitignoreContent !== undefined && hasTmpGitignoreRule(currentGitignoreContent)) {
+            return 'unchanged';
+        }
+        const nextGitignoreContent = appendBlock(currentGitignoreContent || '', CODER_GITIGNORE_BLOCK);
+        await promises.writeFile(gitignorePath, nextGitignoreContent, 'utf-8');
+        return currentGitignoreContent === undefined ? 'created' : 'updated';
+    }
+    /**
+     * Ensures `package.json` contains the standalone Promptbook coder helper scripts.
+     */
+    async function ensureCoderPackageJsonFile(projectPath) {
+        const packageJsonPath = path.join(projectPath, PACKAGE_JSON_FILE_PATH);
+        const packageJsonContent = await readTextFileIfExists(packageJsonPath);
+        const formatting = detectJsonFileFormatting(packageJsonContent);
+        const packageJson = packageJsonContent === undefined ? {} : await parseJsonObjectFile(PACKAGE_JSON_FILE_PATH, packageJsonContent);
+        const scripts = getStringRecordOrDefault(packageJson['scripts'], PACKAGE_JSON_FILE_PATH, 'scripts');
+        let hasChanges = packageJsonContent === undefined;
+        const nextScripts = { ...scripts };
+        for (const [scriptName, scriptCommand] of Object.entries(getDefaultCoderPackageJsonScripts())) {
+            if (nextScripts[scriptName] !== scriptCommand) {
+                nextScripts[scriptName] = scriptCommand;
+                hasChanges = true;
+            }
+        }
+        if (!hasChanges) {
+            return 'unchanged';
+        }
+        const nextPackageJson = { ...packageJson };
+        nextPackageJson['scripts'] = nextScripts;
+        await promises.writeFile(packageJsonPath, serializeJsonObject(nextPackageJson, formatting), 'utf-8');
+        return packageJsonContent === undefined ? 'created' : 'updated';
+    }
+    /**
+     * Ensures VS Code routes pasted prompt images into `prompts/screenshots`.
+     */
+    async function ensureCoderVscodeSettingsFile(projectPath) {
+        await promises.mkdir(path.join(projectPath, VSCODE_DIRECTORY_PATH), { recursive: true });
+        const vscodeSettingsPath = path.join(projectPath, VSCODE_SETTINGS_FILE_PATH);
+        const vscodeSettingsContent = await readTextFileIfExists(vscodeSettingsPath);
+        const formatting = detectJsonFileFormatting(vscodeSettingsContent);
+        const vscodeSettings = vscodeSettingsContent === undefined
+            ? {}
+            : await parseJsonObjectFile(VSCODE_SETTINGS_FILE_PATH, vscodeSettingsContent);
+        const markdownCopyFilesDestinations = getStringRecordOrDefault(vscodeSettings[MARKDOWN_COPY_FILES_DESTINATION_SETTING_KEY], VSCODE_SETTINGS_FILE_PATH, MARKDOWN_COPY_FILES_DESTINATION_SETTING_KEY);
+        let hasChanges = vscodeSettingsContent === undefined;
+        const nextMarkdownCopyFilesDestinations = { ...markdownCopyFilesDestinations };
+        if (nextMarkdownCopyFilesDestinations[PROMPTS_MARKDOWN_FILE_GLOB] !== PROMPTS_SCREENSHOT_DESTINATION) {
+            nextMarkdownCopyFilesDestinations[PROMPTS_MARKDOWN_FILE_GLOB] = PROMPTS_SCREENSHOT_DESTINATION;
+            hasChanges = true;
+        }
+        if (!hasChanges) {
+            return 'unchanged';
+        }
+        const nextVscodeSettings = { ...vscodeSettings };
+        nextVscodeSettings[MARKDOWN_COPY_FILES_DESTINATION_SETTING_KEY] = nextMarkdownCopyFilesDestinations;
+        await promises.writeFile(vscodeSettingsPath, serializeJsonObject(nextVscodeSettings, formatting), 'utf-8');
+        return vscodeSettingsContent === undefined ? 'created' : 'updated';
+    }
     /**
      * Parses variable names currently defined in `.env` style content.
      */
@@ -2000,14 +2349,21 @@
      */
     function printInitializationSummary(summary) {
         console.info(colors__default["default"].green('Promptbook coder configuration initialized.'));
-        console.info(colors__default["default"].gray(`- prompts/: ${formatInitializationStatus(summary.promptsDirectoryStatus)}`));
-        console.info(colors__default["default"].gray(`- prompts/done/: ${formatInitializationStatus(summary.promptsDoneDirectoryStatus)}`));
-        console.info(colors__default["default"].gray(`- .env: ${formatInitializationStatus(summary.envFileStatus)}`));
+        printInitializationStatusLine('prompts/', summary.promptsDirectoryStatus);
+        printInitializationStatusLine('prompts/done/', summary.promptsDoneDirectoryStatus);
+        printInitializationStatusLine('prompts/templates/', summary.promptsTemplatesDirectoryStatus);
+        for (const templateFileStatus of summary.promptTemplateFileStatuses) {
+            printInitializationStatusLine(formatDisplayPath(templateFileStatus.relativeFilePath), templateFileStatus.status);
+        }
+        printInitializationStatusLine('.env', summary.envFileStatus);
+        printInitializationStatusLine('.gitignore', summary.gitignoreFileStatus);
+        printInitializationStatusLine('package.json', summary.packageJsonFileStatus);
+        printInitializationStatusLine('.vscode/settings.json', summary.vscodeSettingsFileStatus);
         if (summary.initializedEnvVariableNames.length > 0) {
-            console.info(colors__default["default"].cyan(`- Added env variables: ${summary.initializedEnvVariableNames.join(', ')}`));
+            printInitializationNote(`Added env variables: ${summary.initializedEnvVariableNames.join(', ')}`, colors__default["default"].cyan);
         }
         else {
-            console.info(colors__default["default"].gray('- Required coder env variables are already present.'));
+            printInitializationNote('Required coder env variables are already present.', colors__default["default"].gray);
         }
     }
     /**
@@ -2022,6 +2378,117 @@
         }
         return 'unchanged';
     }
+    /**
+     * Prints one checked initialization-status line.
+     */
+    function printInitializationStatusLine(relativePath, status) {
+        console.info(colors__default["default"].gray(`✔ ${relativePath}: ${formatInitializationStatus(status)}`));
+    }
+    /**
+     * Prints one checked initialization note.
+     */
+    function printInitializationNote(message, colorize) {
+        console.info(colorize(`✔ ${message}`));
+    }
+    /**
+     * Normalizes one project-relative path for human-readable CLI output.
+     */
+    function formatDisplayPath(relativePath) {
+        return relativePath.replace(/\\/gu, '/');
+    }
+    /**
+     * Detects whether `.gitignore` already covers the standalone coder temp directory.
+     */
+    function hasTmpGitignoreRule(gitignoreContent) {
+        return /(^|[\r\n])\/?\.tmp(?:[\r\n]|$)/u.test(gitignoreContent);
+    }
+    /**
+     * Reads one text file when it exists, otherwise returns `undefined`.
+     */
+    async function readTextFileIfExists(path) {
+        if (!(await isExistingFile(path))) {
+            return undefined;
+        }
+        return promises.readFile(path, 'utf-8');
+    }
+    /**
+     * Parses one JSON object file while accepting VS Code style comments and trailing commas.
+     */
+    async function parseJsonObjectFile(relativeFilePath, fileContent) {
+        if (fileContent.trim() === '') {
+            return {};
+        }
+        const typescript = await import('typescript');
+        const parsedFile = typescript.parseConfigFileTextToJson(relativeFilePath, fileContent);
+        if (parsedFile.error) {
+            throw new ParseError(_spaceTrim.spaceTrim(`
+                Cannot parse \`${relativeFilePath}\` as JSON.
+
+                ${typescript.flattenDiagnosticMessageText(parsedFile.error.messageText, '\n')}
+            `));
+        }
+        if (!isPlainObject(parsedFile.config)) {
+            throw new ParseError(_spaceTrim.spaceTrim(`
+                File \`${relativeFilePath}\` must contain one top-level JSON object.
+            `));
+        }
+        return parsedFile.config;
+    }
+    /**
+     * Reads one JSON object field as a string-to-string record.
+     */
+    function getStringRecordOrDefault(value, relativeFilePath, fieldPath) {
+        if (value === undefined) {
+            return {};
+        }
+        if (!isPlainObject(value)) {
+            throw new ParseError(_spaceTrim.spaceTrim(`
+                File \`${relativeFilePath}\` contains invalid \`${fieldPath}\`.
+
+                Expected \`${fieldPath}\` to be an object with string values.
+            `));
+        }
+        const stringRecord = {};
+        for (const [key, itemValue] of Object.entries(value)) {
+            if (typeof itemValue !== 'string') {
+                throw new ParseError(_spaceTrim.spaceTrim(`
+                    File \`${relativeFilePath}\` contains invalid \`${fieldPath}.${key}\`.
+
+                    Expected \`${fieldPath}\` to be an object with string values.
+                `));
+            }
+            stringRecord[key] = itemValue;
+        }
+        return stringRecord;
+    }
+    /**
+     * Serializes one JSON object using detected or default formatting.
+     */
+    function serializeJsonObject(value, formatting) {
+        return `${JSON.stringify(value, null, formatting.indentation)}${formatting.newline}`;
+    }
+    /**
+     * Detects indentation and newline formatting from an existing JSON file.
+     */
+    function detectJsonFileFormatting(fileContent) {
+        if (!fileContent) {
+            return {
+                indentation: DEFAULT_JSON_FILE_INDENTATION,
+                newline: DEFAULT_JSON_FILE_NEWLINE,
+            };
+        }
+        const indentationMatch = fileContent.match(/^[ \t]+(?=")/mu);
+        return {
+            indentation: (indentationMatch === null || indentationMatch === void 0 ? void 0 : indentationMatch[0]) || DEFAULT_JSON_FILE_INDENTATION,
+            newline: fileContent.includes('\r\n') ? '\r\n' : '\n',
+        };
+    }
+    /**
+     * Checks whether one parsed JSON value is a plain object.
+     */
+    function isPlainObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
     /**
      * Checks whether a path exists and is a file.
      */
@@ -4046,33 +4513,6 @@
         }
     }
 
-    /**
-     * This error indicates that promptbook not found in the collection
-     *
-     * @public exported from `@promptbook/core`
-     */
-    class NotFoundError extends Error {
-        constructor(message) {
-            super(message);
-            this.name = 'NotFoundError';
-            Object.setPrototypeOf(this, NotFoundError.prototype);
-        }
-    }
-
-    /**
-     * This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
-     *
-     * @public exported from `@promptbook/core`
-     */
-    class ParseError extends Error {
-        constructor(message) {
-            super(message);
-            this.name = 'ParseError';
-            Object.setPrototypeOf(this, ParseError.prototype);
-        }
-    }
-    // TODO: Maybe split `ParseError` and `ApplyError`
-
     /**
      * Generates random token
      *
@@ -44051,11 +44491,11 @@
             ${block(options.prompt)}
 
             ${delimiter}
-            )" \
-                --yolo \
-                --no-ask-user \
-                --no-color \
-                --output-format json \
+            )" \\
+                --yolo \\
+                --no-ask-user \\
+                --no-color \\
+                --output-format json \\
                 --stream off${modelArgument}${thinkingLevelArgument}
         `);
     }