@garyr/pt-cli 1.3.1 → 1.4.0

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [1.4.0] - 2026-09-11
+
+### Added
+
+- **Post-config variable substitution**: `pt init` now substitutes template variables into `post_config` commands, scripts, and descriptions.
+- **Hyphenated variable name support**: `substituteVariables` now supports variable names containing hyphens (`[a-zA-Z0-9_-]+`).
+
+### Changed
+
+- Variable pre-filling from parent `.env` files and `--vars` CLI flags is now performed even when templates do not explicitly define a `variables` block.
+- Post-config security validation checks substituted commands, properly catching dangerous or blocked commands resolved from variables.
+- Project destination directory is guaranteed to be created even when templates contain no folder nodes.
+
+---
+
 ## [1.3.0] - 2026-09-08
 
 ### Added

package/dist/commands/initCommand.js

@@ -322,25 +322,25 @@ export async function init(targetOrArgs, destPathOrOptions, optionsOrUndefined)
     // Merge Variables
     const mergedVarsDef = mergeVariables(loadedTemplates);
     let variables = {};
-    if (mergedVarsDef.length > 0) {
-        // Scan parent directories for .env files and pre-fill variables
-        const envVars = scanEnvForVariables(resolvedDest);
-        if (Object.keys(envVars).length > 0) {
-            for (const [key, value] of Object.entries(envVars)) {
-                if (!variables[key]) {
-                    variables[key] = value;
-                }
+    // Scan parent directories for .env files and pre-fill variables
+    const envVars = scanEnvForVariables(resolvedDest);
+    if (Object.keys(envVars).length > 0) {
+        for (const [key, value] of Object.entries(envVars)) {
+            if (!variables[key]) {
+                variables[key] = value;
             }
         }
-        if (options.vars) {
-            const pairs = options.vars.split(',').map((p) => p.trim());
-            for (const pair of pairs) {
-                const [k, ...v] = pair.split('=');
-                if (k && v.length > 0) {
-                    variables[k.trim()] = v.join('=').trim();
-                }
+    }
+    if (options.vars) {
+        const pairs = options.vars.split(',').map((p) => p.trim());
+        for (const pair of pairs) {
+            const [k, ...v] = pair.split('=');
+            if (k && v.length > 0) {
+                variables[k.trim()] = v.join('=').trim();
             }
         }
+    }
+    if (mergedVarsDef.length > 0) {
         if (!options.yes) {
             for (const v of mergedVarsDef) {
                 if (!variables[v.name]) {
@@ -374,6 +374,11 @@ export async function init(targetOrArgs, destPathOrOptions, optionsOrUndefined)
             }
         }
     }
+    if (Object.keys(variables).length > 0) {
+        for (const [key, val] of Object.entries(variables)) {
+            variables[key] = substituteVariables(val, variables);
+        }
+    }
     // 1. Create structure (deep merge folders across all templates)
     let mergedFolders = [];
     for (const { template } of loadedTemplates) {
@@ -471,7 +476,7 @@ export async function init(targetOrArgs, destPathOrOptions, optionsOrUndefined)
                         }
                     }
                     let fileContent = fs.readFileSync(srcPath, 'utf-8');
-                    if (mergedVarsDef.length > 0) {
+                    if (Object.keys(variables).length > 0) {
                         fileContent = substituteVariables(fileContent, variables);
                     }
                     const destDir = path.dirname(destPath);
@@ -515,6 +520,17 @@ export async function init(targetOrArgs, destPathOrOptions, optionsOrUndefined)
     for (const lt of loadedTemplates) {
         if (lt.template.post_config) {
             for (const t of lt.template.post_config) {
+                if (Object.keys(variables).length > 0) {
+                    if (t.command) {
+                        t.command = substituteVariables(t.command, variables);
+                    }
+                    if (t.description) {
+                        t.description = substituteVariables(t.description, variables);
+                    }
+                    if (t.script) {
+                        t.script = substituteVariables(t.script, variables);
+                    }
+                }
                 if (!t.type || t.type === lt.name) {
                     const key = `${t.command || t.script || ''}|${t.description || ''}`;
                     if (taskMap.has(key)) {
@@ -682,6 +698,9 @@ export async function init(targetOrArgs, destPathOrOptions, optionsOrUndefined)
     }
 }
 function createStructure(dirPath, folders, dryRun = false, silent = false) {
+    if (!dryRun) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
     for (const folder of folders) {
         const fullDirPath = path.join(dirPath, sanitizePath(folder.name));
         if (dryRun) {

package/dist/postconfig.js

@@ -2,11 +2,12 @@ import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
+import { substituteVariables } from './substitute.js';
 import { isBlockedCommand, isDangerousCommand, executeWithTimeout, logSecurityEvent, canExecute, showDangerousCommandWarning, getSecurityPolicy, } from './safety.js';
 /**
  * Runs post-configuration tasks for a project.
  */
-export async function runPostConfig(destPath, tasks, projectType, options = {}) {
+export async function runPostConfig(destPath, tasks, projectType, options = {}, variables = {}) {
     if (options.skipPostConfig)
         return;
     // Load security policy
@@ -17,8 +18,15 @@ export async function runPostConfig(destPath, tasks, projectType, options = {})
         console.log(chalk.yellow('⚠️  Rate limit reached: max commands per run exceeded'));
         return;
     }
-    // 1. Filter tasks by type
-    const applicableTasks = tasks.filter(t => !t.type || t.type === projectType);
+    // 1. Filter tasks by type and substitute variables
+    const applicableTasks = tasks
+        .filter(t => !t.type || t.type === projectType)
+        .map(t => ({
+        ...t,
+        command: t.command && Object.keys(variables).length > 0 ? substituteVariables(t.command, variables) : t.command,
+        description: t.description && Object.keys(variables).length > 0 ? substituteVariables(t.description, variables) : t.description,
+        script: t.script && Object.keys(variables).length > 0 ? substituteVariables(t.script, variables) : t.script,
+    }));
     if (applicableTasks.length === 0) {
         return;
     }

package/dist/substitute.js

@@ -13,7 +13,7 @@ export function substituteVariables(content, variables, maxIterations = 10) {
     // Keep expanding until no more placeholders remain or we hit the limit
     while (/\{\{[^}]+\}\}/.test(result) && iteration < maxIterations) {
         // Use a more complex regex that captures the full placeholder including spaces
-        result = result.replace(/(\{\{\s*)(\w+)(\s*\}\})/g, (_, prefix, varName, suffix) => {
+        result = result.replace(/(\{\{\s*)([a-zA-Z0-9_-]+)(\s*\}\})/g, (_, prefix, varName, suffix) => {
             const val = variables[varName];
             // If variable not found, leave placeholder as-is with original spacing
             if (val === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@garyr/pt-cli",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Project Template CLI - Learn structures and initialize projects",
   "main": "dist/index.js",
   "bin": {

package/src/commands/initCommand.ts

@@ -349,27 +349,27 @@ export async function init(
   const mergedVarsDef = mergeVariables(loadedTemplates);
   let variables: Record<string, string> = {};
 
-  if (mergedVarsDef.length > 0) {
-    // Scan parent directories for .env files and pre-fill variables
-    const envVars = scanEnvForVariables(resolvedDest);
-    if (Object.keys(envVars).length > 0) {
-      for (const [key, value] of Object.entries(envVars)) {
-        if (!variables[key]) {
-          variables[key] = value;
-        }
+  // Scan parent directories for .env files and pre-fill variables
+  const envVars = scanEnvForVariables(resolvedDest);
+  if (Object.keys(envVars).length > 0) {
+    for (const [key, value] of Object.entries(envVars)) {
+      if (!variables[key]) {
+        variables[key] = value;
       }
     }
+  }
 
-    if (options.vars) {
-      const pairs = options.vars.split(',').map((p: string) => p.trim());
-      for (const pair of pairs) {
-        const [k, ...v] = pair.split('=');
-        if (k && v.length > 0) {
-          variables[k.trim()] = v.join('=').trim();
-        }
+  if (options.vars) {
+    const pairs = options.vars.split(',').map((p: string) => p.trim());
+    for (const pair of pairs) {
+      const [k, ...v] = pair.split('=');
+      if (k && v.length > 0) {
+        variables[k.trim()] = v.join('=').trim();
       }
     }
+  }
 
+  if (mergedVarsDef.length > 0) {
     if (!options.yes) {
       for (const v of mergedVarsDef) {
         if (!variables[v.name]) {
@@ -401,6 +401,12 @@ export async function init(
     }
   }
 
+  if (Object.keys(variables).length > 0) {
+    for (const [key, val] of Object.entries(variables)) {
+      variables[key] = substituteVariables(val, variables);
+    }
+  }
+
   // 1. Create structure (deep merge folders across all templates)
   let mergedFolders: FolderNode[] = [];
   for (const { template } of loadedTemplates) {
@@ -509,7 +515,7 @@ export async function init(
           }
 
           let fileContent = fs.readFileSync(srcPath, 'utf-8');
-          if (mergedVarsDef.length > 0) {
+          if (Object.keys(variables).length > 0) {
             fileContent = substituteVariables(fileContent, variables);
           }
 
@@ -554,6 +560,17 @@ export async function init(
   for (const lt of loadedTemplates) {
     if (lt.template.post_config) {
       for (const t of lt.template.post_config) {
+        if (Object.keys(variables).length > 0) {
+          if (t.command) {
+            t.command = substituteVariables(t.command, variables);
+          }
+          if (t.description) {
+            t.description = substituteVariables(t.description, variables);
+          }
+          if (t.script) {
+            t.script = substituteVariables(t.script, variables);
+          }
+        }
         if (!t.type || t.type === lt.name) {
           const key = `${t.command || t.script || ''}|${t.description || ''}`;
           if (taskMap.has(key)) {
@@ -723,6 +740,9 @@ export async function init(
 }
 
 function createStructure(dirPath: string, folders: FolderNode[], dryRun: boolean = false, silent: boolean = false) {
+  if (!dryRun) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
   for (const folder of folders) {
     const fullDirPath = path.join(dirPath, sanitizePath(folder.name));
 

package/src/postconfig.ts

@@ -5,6 +5,7 @@ import { execSync } from 'child_process';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
 import { PostConfigTask } from './config.js';
+import { substituteVariables } from './substitute.js';
 import {
   isBlockedCommand,
   isDangerousCommand,
@@ -28,7 +29,8 @@ export async function runPostConfig(
   destPath: string,
   tasks: PostConfigTask[],
   projectType: string,
-  options: PostConfigOptions = {}
+  options: PostConfigOptions = {},
+  variables: Record<string, string> = {}
 ): Promise<void> {
   if (options.skipPostConfig) return;
 
@@ -42,8 +44,15 @@ export async function runPostConfig(
     return;
   }
 
-  // 1. Filter tasks by type
-  const applicableTasks = tasks.filter(t => !t.type || t.type === projectType);
+  // 1. Filter tasks by type and substitute variables
+  const applicableTasks = tasks
+    .filter(t => !t.type || t.type === projectType)
+    .map(t => ({
+      ...t,
+      command: t.command && Object.keys(variables).length > 0 ? substituteVariables(t.command, variables) : t.command,
+      description: t.description && Object.keys(variables).length > 0 ? substituteVariables(t.description, variables) : t.description,
+      script: t.script && Object.keys(variables).length > 0 ? substituteVariables(t.script, variables) : t.script,
+    }));
 
   if (applicableTasks.length === 0) {
     return;

package/src/substitute.ts

@@ -21,7 +21,7 @@ export function substituteVariables(
   // Keep expanding until no more placeholders remain or we hit the limit
   while (/\{\{[^}]+\}\}/.test(result) && iteration < maxIterations) {
     // Use a more complex regex that captures the full placeholder including spaces
-    result = result.replace(/(\{\{\s*)(\w+)(\s*\}\})/g, (_, prefix, varName, suffix) => {
+    result = result.replace(/(\{\{\s*)([a-zA-Z0-9_-]+)(\s*\}\})/g, (_, prefix, varName, suffix) => {
       const val = variables[varName];
       // If variable not found, leave placeholder as-is with original spacing
       if (val === undefined) {

package/tests/post-config-variables.test.ts

@@ -0,0 +1,321 @@
+import { test } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs';
+import path from 'path';
+
+// Force a temporary home directory for testing before importing anything from the CLI
+const testHome = path.join(process.cwd(), '.test-home-post-config-vars');
+process.env.HOME = testHome;
+
+import { init } from '../src/commands/initCommand.js';
+import { saveConfig, PtConfig } from '../src/config.js';
+import { runPostConfig } from '../src/postconfig.js';
+
+function cleanup(...paths: string[]) {
+  for (const p of paths) {
+    if (fs.existsSync(p)) {
+      fs.rmSync(p, { recursive: true, force: true });
+    }
+  }
+}
+
+function setupTestConfig(templateName: string, template: any): PtConfig {
+  const config: PtConfig = {
+    version: '3.0',
+    templates: {
+      [templateName]: template
+    }
+  };
+  saveConfig(config);
+  return config;
+}
+
+test('post_config variable substitution: replaces variables in command, script, and description', async () => {
+  const projectDest = path.join(process.cwd(), 'test-post-config-vars-project');
+  const templateRoot = path.join(process.cwd(), 'test-post-config-vars-root');
+  cleanup(projectDest, templateRoot, testHome);
+
+  fs.mkdirSync(templateRoot, { recursive: true });
+
+  setupTestConfig('memory-field-tpl', {
+    description: 'Memory field template',
+    templateRoot: templateRoot,
+    folders: [{ name: 'memories', info: '' }],
+    variables: [
+      { name: 'MEMORY_NAME', prompt: 'Memory Name:', required: true },
+      { name: 'MEMORY_DIR', prompt: 'Memory Dir:', default: 'memories' }
+    ],
+    post_config: [
+      {
+        command: 'echo "Creating {{ MEMORY_NAME }} in {{ MEMORY_DIR }}" > result.txt',
+        description: 'Create {{ MEMORY_NAME }}'
+      }
+    ]
+  });
+
+  await init('memory-field-tpl', projectDest, {
+    yes: true,
+    vars: 'MEMORY_NAME=test-agent,MEMORY_DIR=custom-memories'
+  });
+
+  // Verify post_config.sh and post_config.bat were written with substituted variables
+  const shContent = fs.readFileSync(path.join(projectDest, 'post_config.sh'), 'utf-8');
+  assert.ok(
+    shContent.includes('echo "Creating test-agent in custom-memories" > result.txt'),
+    `post_config.sh should have substituted command, got:\n${shContent}`
+  );
+  assert.ok(
+    shContent.includes('echo "Running: Create test-agent"'),
+    `post_config.sh should have substituted description, got:\n${shContent}`
+  );
+  assert.ok(!shContent.includes('{{ MEMORY_NAME }}'), 'post_config.sh should not contain {{ MEMORY_NAME }}');
+  assert.ok(!shContent.includes('{{ MEMORY_DIR }}'), 'post_config.sh should not contain {{ MEMORY_DIR }}');
+
+  const batContent = fs.readFileSync(path.join(projectDest, 'post_config.bat'), 'utf-8');
+  assert.ok(
+    batContent.includes('echo "Creating test-agent in custom-memories" > result.txt'),
+    `post_config.bat should have substituted command, got:\n${batContent}`
+  );
+  assert.ok(
+    batContent.includes('echo Running: Create test-agent'),
+    `post_config.bat should have substituted description, got:\n${batContent}`
+  );
+
+  // Verify that the task actually executed and produced the output with substituted vars
+  const resultTxt = fs.readFileSync(path.join(projectDest, 'result.txt'), 'utf-8');
+  assert.strictEqual(resultTxt.trim(), 'Creating test-agent in custom-memories');
+
+  cleanup(projectDest, templateRoot, testHome);
+});
+
+test('post_config variable substitution: variables from .env in parent directory', async () => {
+  const parentDir = path.join(process.cwd(), 'test-post-config-env-parent');
+  const projectDest = path.join(parentDir, 'test-post-config-env-project');
+  const templateRoot = path.join(process.cwd(), 'test-post-config-env-root');
+  cleanup(projectDest, templateRoot, parentDir, testHome);
+
+  fs.mkdirSync(templateRoot, { recursive: true });
+  fs.mkdirSync(parentDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(parentDir, '.env'),
+    'PROJECT_NAME=alpha\nMEMORY_DIR=agent_memories\n'
+  );
+
+  setupTestConfig('env-post-config-tpl', {
+    description: 'Template with env vars in post_config',
+    templateRoot: templateRoot,
+    folders: [],
+    variables: [
+      { name: 'PROJECT_NAME', prompt: 'Project name:' },
+      { name: 'MEMORY_DIR', prompt: 'Memory dir:', default: 'memories' }
+    ],
+    post_config: [
+      {
+        command: 'echo "name={{ PROJECT_NAME }} dir={{ MEMORY_DIR }}" > env_result.txt',
+        description: 'Initialize {{ PROJECT_NAME }}'
+      }
+    ]
+  });
+
+  await init('env-post-config-tpl', projectDest, {
+    yes: true
+  });
+
+  const shContent = fs.readFileSync(path.join(projectDest, 'post_config.sh'), 'utf-8');
+  assert.ok(shContent.includes('name=alpha dir=agent_memories'));
+
+  const envResult = fs.readFileSync(path.join(projectDest, 'env_result.txt'), 'utf-8');
+  assert.strictEqual(envResult.trim(), 'name=alpha dir=agent_memories');
+
+  cleanup(projectDest, templateRoot, parentDir, testHome);
+});
+
+test('post_config variable substitution: nested variable expansion in post_config', async () => {
+  const parentDir = path.join(process.cwd(), 'test-post-config-nested-parent');
+  const projectDest = path.join(parentDir, 'test-post-config-nested-project');
+  const templateRoot = path.join(process.cwd(), 'test-post-config-nested-root');
+  cleanup(projectDest, templateRoot, parentDir, testHome);
+
+  fs.mkdirSync(templateRoot, { recursive: true });
+  fs.mkdirSync(parentDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(parentDir, '.env'),
+    `prefix='rst_{{ project }}'\nproject=deep_nested\n`
+  );
+
+  setupTestConfig('nested-post-config-tpl', {
+    description: 'Template with nested variable in post_config',
+    templateRoot: templateRoot,
+    folders: [],
+    variables: [
+      { name: 'prefix', prompt: 'Prefix:' },
+      { name: 'project', prompt: 'Project:' }
+    ],
+    post_config: [
+      {
+        command: 'echo "{{ prefix }}" > nested_result.txt',
+        description: 'Task for {{ prefix }}'
+      }
+    ]
+  });
+
+  await init('nested-post-config-tpl', projectDest, {
+    yes: true
+  });
+
+  const shContent = fs.readFileSync(path.join(projectDest, 'post_config.sh'), 'utf-8');
+  assert.ok(shContent.includes('echo "rst_deep_nested" > nested_result.txt'));
+  assert.ok(shContent.includes('echo "Running: Task for rst_deep_nested"'));
+
+  const nestedResult = fs.readFileSync(path.join(projectDest, 'nested_result.txt'), 'utf-8');
+  assert.strictEqual(nestedResult.trim(), 'rst_deep_nested');
+
+  cleanup(projectDest, templateRoot, parentDir, testHome);
+});
+
+test('post_config variable substitution: multi-template deduplication with variables', async () => {
+  const projectDest = path.join(process.cwd(), 'test-post-config-multi-project');
+  const templateRoot1 = path.join(process.cwd(), 'test-post-config-multi-root1');
+  const templateRoot2 = path.join(process.cwd(), 'test-post-config-multi-root2');
+  cleanup(projectDest, templateRoot1, templateRoot2, testHome);
+
+  fs.mkdirSync(templateRoot1, { recursive: true });
+  fs.mkdirSync(templateRoot2, { recursive: true });
+
+  const config: PtConfig = {
+    version: '3.0',
+    templates: {
+      tplA: {
+        description: 'Template A',
+        templateRoot: templateRoot1,
+        folders: [],
+        variables: [{ name: 'COMMON_DIR', prompt: 'Common dir:', default: 'shared' }],
+        post_config: [
+          {
+            command: 'echo "{{ COMMON_DIR }}" >> common.txt',
+            description: 'Common task'
+          }
+        ]
+      },
+      tplB: {
+        description: 'Template B',
+        templateRoot: templateRoot2,
+        folders: [],
+        variables: [{ name: 'COMMON_DIR', prompt: 'Common dir:', default: 'shared' }],
+        post_config: [
+          {
+            command: 'echo "{{ COMMON_DIR }}" >> common.txt',
+            description: 'Common task'
+          }
+        ]
+      }
+    }
+  };
+  saveConfig(config);
+
+  await init(['tplA', 'tplB', projectDest], {
+    yes: true,
+    vars: 'COMMON_DIR=my_shared_dir'
+  });
+
+  const shContent = fs.readFileSync(path.join(projectDest, 'post_config.sh'), 'utf-8');
+  // Should deduplicate identical substituted tasks
+  const occurrences = (shContent.match(/echo "my_shared_dir" >> common.txt/g) || []).length;
+  assert.strictEqual(occurrences, 1, 'Duplicate task after variable substitution should be deduplicated to 1');
+
+  cleanup(projectDest, templateRoot1, templateRoot2, testHome);
+});
+
+test('postconfig.ts: runPostConfig applies variable substitution', async () => {
+  const projectDest = path.join(process.cwd(), 'test-postconfig-fn-project');
+  cleanup(projectDest, testHome);
+  fs.mkdirSync(projectDest, { recursive: true });
+
+  const tasks = [
+    {
+      command: 'echo "{{ APP_ENV }}" > app.txt',
+      description: 'Configure {{ APP_ENV }}'
+    }
+  ];
+
+  await runPostConfig(
+    projectDest,
+    tasks,
+    'my-app',
+    { yes: true },
+    { APP_ENV: 'staging' }
+  );
+
+  const appTxt = fs.readFileSync(path.join(projectDest, 'app.txt'), 'utf-8');
+  assert.strictEqual(appTxt.trim(), 'staging');
+
+  cleanup(projectDest, testHome);
+});
+
+test('post_config variable substitution: supports hyphenated variable names', async () => {
+  const projectDest = path.join(process.cwd(), 'test-post-config-hyphen-project');
+  const templateRoot = path.join(process.cwd(), 'test-post-config-hyphen-root');
+  cleanup(projectDest, templateRoot, testHome);
+
+  fs.mkdirSync(templateRoot, { recursive: true });
+
+  setupTestConfig('hyphen-var-tpl', {
+    description: 'Hyphen var template',
+    templateRoot: templateRoot,
+    folders: [],
+    variables: [{ name: 'memory-name', prompt: 'Memory Name:' }],
+    post_config: [
+      {
+        command: 'echo "{{ memory-name }}" > hyphen_out.txt',
+        description: 'Create {{ memory-name }}'
+      }
+    ]
+  });
+
+  await init('hyphen-var-tpl', projectDest, {
+    yes: true,
+    vars: 'memory-name=my-hyphen-mem'
+  });
+
+  const shContent = fs.readFileSync(path.join(projectDest, 'post_config.sh'), 'utf-8');
+  assert.ok(shContent.includes('echo "my-hyphen-mem" > hyphen_out.txt'));
+
+  const out = fs.readFileSync(path.join(projectDest, 'hyphen_out.txt'), 'utf-8');
+  assert.strictEqual(out.trim(), 'my-hyphen-mem');
+
+  cleanup(projectDest, templateRoot, testHome);
+});
+
+test('post_config variable substitution: --vars works even when template has no variables field', async () => {
+  const projectDest = path.join(process.cwd(), 'test-post-config-novars-project');
+  const templateRoot = path.join(process.cwd(), 'test-post-config-novars-root');
+  cleanup(projectDest, templateRoot, testHome);
+
+  fs.mkdirSync(templateRoot, { recursive: true });
+
+  setupTestConfig('novars-tpl', {
+    description: 'No variables field template',
+    templateRoot: templateRoot,
+    folders: [],
+    post_config: [
+      {
+        command: 'echo "hello {{ USER_VAR }}" > novars_out.txt',
+        description: 'Run {{ USER_VAR }}'
+      }
+    ]
+  });
+
+  await init('novars-tpl', projectDest, {
+    yes: true,
+    vars: 'USER_VAR=world'
+  });
+
+  const shContent = fs.readFileSync(path.join(projectDest, 'post_config.sh'), 'utf-8');
+  assert.ok(shContent.includes('echo "hello world" > novars_out.txt'));
+
+  const out = fs.readFileSync(path.join(projectDest, 'novars_out.txt'), 'utf-8');
+  assert.strictEqual(out.trim(), 'hello world');
+
+  cleanup(projectDest, templateRoot, testHome);
+});
+