@promptbook/cli 0.112.0-35 → 0.112.0-36

package/esm/index.es.js

@@ -2,10 +2,10 @@ import colors from 'colors';
 import commander, { Option } from 'commander';
 import _spaceTrim, { spaceTrim as spaceTrim$1 } from 'spacetrim';
 import * as fs from 'fs';
-import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'fs';
 import * as path from 'path';
 import { join, basename, dirname, isAbsolute, relative, extname, resolve } from 'path';
-import { mkdir, readFile, writeFile, stat, access, constants, readdir, watch, unlink, rm, rename, rmdir } from 'fs/promises';
+import { writeFile, readFile, stat, mkdir, access, constants, readdir, watch, unlink, rm, rename, rmdir } from 'fs/promises';
 import { forTime, forEver } from 'waitasecond';
 import prompts from 'prompts';
 import * as dotenv from 'dotenv';
@@ -57,7 +57,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -1697,6 +1697,220 @@ function $initializeCoderFindRefactorCandidatesCommand(program) {
 // 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 = 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 = 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: 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: 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 = join(projectPath, definition.relativeFilePath);
+        if (await isExistingFile$1(absoluteTemplatePath)) {
+            ensuredTemplateFiles.push({
+                id: definition.id,
+                relativeFilePath: definition.relativeFilePath,
+                status: 'unchanged',
+            });
+            continue;
+        }
+        await 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 = join(projectPath, normalizedTemplateOption);
+    try {
+        const content = (await readFile(absoluteTemplatePath, 'utf-8')).trim();
+        return {
+            identifier: normalizedTemplateOption,
+            relativeFilePath: normalizedTemplateOption,
+            content,
+            slugPrefix: deriveCoderPromptSlugPrefix(normalizedTemplateOption),
+        };
+    }
+    catch (error) {
+        if (isNodeJsErrorWithCode(error, 'ENOENT')) {
+            throw new NotFoundError(spaceTrim$1(`
+                    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 = 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 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
  *
@@ -1710,12 +1924,21 @@ function $initializeCoderGenerateBoilerplatesCommand(program) {
             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$1(`
+            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);
     }));
 }
@@ -1724,14 +1947,15 @@ function $initializeCoderGenerateBoilerplatesCommand(program) {
  *
  * @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);
+    mkdirSync(join(projectPath, PROMPTS_DIRECTORY_PATH), { recursive: true });
+    const promptTemplate = await resolveCoderPromptTemplate({ projectPath, templateOption });
     const promptNumbering = await getPromptNumbering({
-        promptsDir: join(process.cwd(), 'prompts'),
+        promptsDir: join(projectPath, PROMPTS_DIRECTORY_PATH),
         step: 10,
         ignoreGlobs: ['**/node_modules/**'],
     });
@@ -1740,7 +1964,7 @@ async function generatePromptBoilerplate({ filesCount, template, }) {
     console.info(colors.blue(`Highest existing number for ${promptNumbering.datePrefix} found: ${highestNumberFormatted}`));
     const { availableCount, selectedEmojis } = await getFreshPromptEmojiTags({
         count: filesCount,
-        rootDir: process.cwd(),
+        rootDir: projectPath,
     });
     console.info(colors.green(`Found ${availableCount} available fresh emojis`));
     console.info(colors.green(`Selected emojis: ${selectedEmojis.map((emoji) => formatPromptEmojiTag(emoji)).join(' ')}`));
@@ -1752,8 +1976,9 @@ async function generatePromptBoilerplate({ filesCount, template, }) {
         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 = join('prompts', filename);
+        const filename = buildPromptFilename(promptNumbering.datePrefix, number, buildPromptSlug$1(promptTemplate.slugPrefix, title));
+        const filepath = join(PROMPTS_DIRECTORY_PATH, filename);
+        const absoluteFilepath = join(projectPath, filepath);
         const emojiTag = formatPromptEmojiTag(emoji);
         const one = spaceTrim$1((block) => `
 
@@ -1761,7 +1986,7 @@ async function generatePromptBoilerplate({ filesCount, template, }) {
 
                 ${emojiTag} ${title}
 
-                ${block(promptTemplateContent)}
+                ${block(promptTemplate.content)}
             `);
         const content = spaceTrim$1((block) => `
 
@@ -1782,6 +2007,7 @@ async function generatePromptBoilerplate({ filesCount, template, }) {
             `);
         filesToCreate.push({
             filepath,
+            absoluteFilepath,
             filename,
             content,
             emoji,
@@ -1791,7 +2017,7 @@ async function generatePromptBoilerplate({ filesCount, template, }) {
     // Create the files
     console.info(colors.yellow(`Creating ${filesToCreate.length} files:`));
     for (const file of filesToCreate) {
-        writeFileSync(file.filepath, file.content, 'utf-8');
+        writeFileSync(file.absoluteFilepath, file.content, 'utf-8');
         console.info(colors.green(`✓ Created: ${file.filename} with ${formatPromptEmojiTag(file.emoji)}`));
     }
     console.info(colors.bgGreen(` Successfully created ${filesToCreate.length} prompt boilerplate files! `));
@@ -1809,52 +2035,34 @@ function parseFilesCount(countOption) {
     }
     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.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 = join(__dirname, '../../../../scripts/generate-prompt-boilerplate/templates', `${template}.template.md`);
-    return 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 = 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.
  */
@@ -1872,6 +2080,58 @@ const REQUIRED_CODER_ENV_VARIABLES = [
         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$1(`
+    # Promptbook Coder
+    /.tmp
+`);
 /**
  * Initializes `coder init` command for Promptbook CLI utilities.
  *
@@ -1885,9 +2145,14 @@ function $initializeCoderInitCommand(program) {
     command.description(spaceTrim$1(`
             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
@@ -1899,17 +2164,37 @@ function $initializeCoderInitCommand(program) {
         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,
     };
 }
@@ -1955,6 +2240,70 @@ async function ensureCoderEnvFile(projectPath) {
         initializedEnvVariableNames: missingEnvVariables.map(({ name }) => name),
     };
 }
+/**
+ * Ensures `.gitignore` contains the standalone Promptbook coder cache entry.
+ */
+async function ensureCoderGitignoreFile(projectPath) {
+    const gitignorePath = 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 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 = 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 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 mkdir(join(projectPath, VSCODE_DIRECTORY_PATH), { recursive: true });
+    const vscodeSettingsPath = 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 writeFile(vscodeSettingsPath, serializeJsonObject(nextVscodeSettings, formatting), 'utf-8');
+    return vscodeSettingsContent === undefined ? 'created' : 'updated';
+}
 /**
  * Parses variable names currently defined in `.env` style content.
  */
@@ -1997,14 +2346,21 @@ function appendBlock(currentContent, blockToAppend) {
  */
 function printInitializationSummary(summary) {
     console.info(colors.green('Promptbook coder configuration initialized.'));
-    console.info(colors.gray(`- prompts/: ${formatInitializationStatus(summary.promptsDirectoryStatus)}`));
-    console.info(colors.gray(`- prompts/done/: ${formatInitializationStatus(summary.promptsDoneDirectoryStatus)}`));
-    console.info(colors.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.cyan(`- Added env variables: ${summary.initializedEnvVariableNames.join(', ')}`));
+        printInitializationNote(`Added env variables: ${summary.initializedEnvVariableNames.join(', ')}`, colors.cyan);
     }
     else {
-        console.info(colors.gray('- Required coder env variables are already present.'));
+        printInitializationNote('Required coder env variables are already present.', colors.gray);
     }
 }
 /**
@@ -2019,6 +2375,117 @@ function formatInitializationStatus(status) {
     }
     return 'unchanged';
 }
+/**
+ * Prints one checked initialization-status line.
+ */
+function printInitializationStatusLine(relativePath, status) {
+    console.info(colors.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 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$1(`
+                Cannot parse \`${relativeFilePath}\` as JSON.
+
+                ${typescript.flattenDiagnosticMessageText(parsedFile.error.messageText, '\n')}
+            `));
+    }
+    if (!isPlainObject(parsedFile.config)) {
+        throw new ParseError(spaceTrim$1(`
+                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$1(`
+                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$1(`
+                    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.
  */
@@ -4043,33 +4510,6 @@ class NotAllowed extends Error {
     }
 }
 
-/**
- * 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
  *
@@ -44048,11 +44488,11 @@ function buildGitHubCopilotScript(options) {
             ${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}
         `);
 }