@garyr/pt-cli 0.28.0 → 0.30.1

package/dist/commands/initCommand.js

@@ -232,7 +232,8 @@ export async function init(targetName, destPath, options = {}) {
                 loop: false,
                 theme: {
                     icon: {
-                        cursor: chalk.green('[x] ')
+                        checked: chalk.green('[x] '),
+                        unchecked: '[ ] ',
                     }
                 },
                 choices

package/dist/commands/learnCommand.js

@@ -155,12 +155,32 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
         console.log(chalk.cyan(`Auto-detected ${detectedVars.length} variable(s): ${detectedVars.join(', ')}`));
     }
     let variables = [];
-    // Merge with existing variables if update
-    if (isUpdate && config.templates[updateTemplate].variables) {
-        variables = [...config.templates[updateTemplate].variables];
+    // During updates, merge existing template variables with JSON file variables
+    if (isUpdate) {
+        // Start with existing template variables
+        if (config.templates[updateTemplate].variables) {
+            variables = [...config.templates[updateTemplate].variables];
+        }
+        // Then add JSON variables (overwrite/update existing ones with same name)
+        if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
+            for (const v of fileTemplateConfig.variables) {
+                const existingIndex = variables.findIndex(existing => existing.name === v.name);
+                if (existingIndex !== -1) {
+                    // Update existing variable with JSON values (but preserve other fields)
+                    variables[existingIndex] = { ...variables[existingIndex], ...v };
+                }
+                else {
+                    // Add new variable
+                    variables.push({ ...v });
+                }
+            }
+        }
     }
-    else if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
-        variables = [...fileTemplateConfig.variables];
+    else {
+        // For new templates, use JSON variables if available
+        if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
+            variables = [...fileTemplateConfig.variables];
+        }
     }
     // Add detected variables if not already present
     for (const varName of detectedVars) {
@@ -369,7 +389,8 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
                 loop: false,
                 theme: {
                     icon: {
-                        cursor: chalk.green('[x] ')
+                        checked: chalk.green('[x] '),
+                        unchecked: '[ ] ',
                     }
                 },
                 choices

package/dist/remote.js

@@ -8,12 +8,14 @@ import { extract } from 'tar'; // You'll need: npm install tar
 export async function downloadAndExtract(url) {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pt-template-'));
     let downloadUrl = url;
+    // Strip trailing slash and .git suffix before converting to archive URL
+    let cleanUrl = url.replace(/\/$/, '').replace(/\.git$/, '');
     // Convert GitHub/Gitea URLs to Zip/Tarball endpoints
     if (url.includes('github.com')) {
-        downloadUrl = url.replace(/\/$/, '') + '/archive/refs/heads/main.tar.gz';
+        downloadUrl = cleanUrl + '/archive/refs/heads/main.tar.gz';
     }
     else if (url.includes('gitea')) {
-        downloadUrl = url.replace(/\/$/, '') + '/archive/main.tar.gz';
+        downloadUrl = cleanUrl + '/archive/main.tar.gz';
     }
     const response = await fetch(downloadUrl);
     if (!response.ok)

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@garyr/pt-cli",
-  "version": "0.28.0",
+  "version": "0.30.1",
   "description": "Project Template CLI - Learn structures and initialize projects",
   "main": "dist/index.js",
   "bin": {
-    "pt": "./dist/index.js"
+    "pt": "dist/index.js"
   },
   "type": "module",
   "scripts": {

package/src/commands/initCommand.ts

@@ -251,7 +251,8 @@ export async function init(targetName: string | undefined, destPath: string | un
         loop: false,
         theme: {
           icon: {
-            cursor: chalk.green('[x] ')
+            checked: chalk.green('[x] '),
+            unchecked: '[ ] ',
           }
         },
         choices

package/src/commands/learnCommand.ts

@@ -158,11 +158,30 @@ export async function learn(sourcePath: string, updateTemplate: string | null =
 
   let variables: TemplateVariable[] = [];
   
-  // Merge with existing variables if update
-  if (isUpdate && config.templates[updateTemplate].variables) {
-    variables = [...config.templates[updateTemplate].variables];
-  } else if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
-    variables = [...fileTemplateConfig.variables];
+  // During updates, merge existing template variables with JSON file variables
+  if (isUpdate) {
+    // Start with existing template variables
+    if (config.templates[updateTemplate].variables) {
+      variables = [...config.templates[updateTemplate].variables];
+    }
+    // Then add JSON variables (overwrite/update existing ones with same name)
+    if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
+      for (const v of fileTemplateConfig.variables) {
+        const existingIndex = variables.findIndex(existing => existing.name === v.name);
+        if (existingIndex !== -1) {
+          // Update existing variable with JSON values (but preserve other fields)
+          variables[existingIndex] = { ...variables[existingIndex], ...v };
+        } else {
+          // Add new variable
+          variables.push({ ...v });
+        }
+      }
+    }
+  } else {
+    // For new templates, use JSON variables if available
+    if (fileTemplateConfig.variables && Array.isArray(fileTemplateConfig.variables)) {
+      variables = [...fileTemplateConfig.variables];
+    }
   }
 
   // Add detected variables if not already present
@@ -380,7 +399,8 @@ export async function learn(sourcePath: string, updateTemplate: string | null =
         loop: false,
         theme: {
           icon: {
-            cursor: chalk.green('[x] ')
+            checked: chalk.green('[x] '),
+            unchecked: '[ ] ',
           }
         },
         choices

package/src/remote.ts

@@ -10,11 +10,14 @@ export async function downloadAndExtract(url: string): Promise<string> {
     const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pt-template-'));
     let downloadUrl = url;
 
+    // Strip trailing slash and .git suffix before converting to archive URL
+    let cleanUrl = url.replace(/\/$/, '').replace(/\.git$/, '');
+    
     // Convert GitHub/Gitea URLs to Zip/Tarball endpoints
     if (url.includes('github.com')) {
-        downloadUrl = url.replace(/\/$/, '') + '/archive/refs/heads/main.tar.gz';
+        downloadUrl = cleanUrl + '/archive/refs/heads/main.tar.gz';
     } else if (url.includes('gitea')) {
-        downloadUrl = url.replace(/\/$/, '') + '/archive/main.tar.gz';
+        downloadUrl = cleanUrl + '/archive/main.tar.gz';
     }
 
     const response = await fetch(downloadUrl);

package/test-direct-template.json

@@ -0,0 +1,24 @@
+{
+  "name": "direct-json-test",
+  "description": "A mock template for direct JSON scaffolding test",
+  "folders": [
+    {
+      "name": "src",
+      "info": "contains sources",
+      "children": [
+        {
+          "name": "components",
+          "info": "reusable components"
+        },
+        {
+          "name": "utils",
+          "info": "utility functions"
+        }
+      ]
+    },
+    {
+      "name": "docs",
+      "info": "documentation folder"
+    }
+  ]
+}

package/tests/config.test.ts

@@ -26,6 +26,12 @@ test('normalizeVariable key ordering', () => {
 });
 
 test('saveConfig and loadConfig roundtrip', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
   // Clean up any existing test files
   if (fs.existsSync(CONFIG_PATH)) {
     fs.unlinkSync(CONFIG_PATH);
@@ -92,7 +98,651 @@ test('saveConfig and loadConfig roundtrip', () => {
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('normalizeVariable with minimal input', () => {
+  const variableInput = {
+    name: 'minimalVar'
+  };
+
+  const normalized = normalizeVariable(variableInput);
+  
+  // Verify that only name is present
+  const keys = Object.keys(normalized);
+  assert.deepStrictEqual(keys, ['name']);
+  assert.strictEqual(normalized.name, 'minimalVar');
+});
+
+test('normalizeVariable with all fields', () => {
+  const variableInput = {
+    required: false,
+    default: 'default-value',
+    prompt: 'Custom prompt:',
+    name: 'allFields'
+  };
+
+  const normalized = normalizeVariable(variableInput);
+  
+  // Verify all fields are present and in correct order
+  const keys = Object.keys(normalized);
+  assert.deepStrictEqual(keys, ['name', 'prompt', 'default', 'required']);
+  assert.strictEqual(normalized.name, 'allFields');
+  assert.strictEqual(normalized.prompt, 'Custom prompt:');
+  assert.strictEqual(normalized.default, 'default-value');
+  assert.strictEqual(normalized.required, false);
+});
+
+test('saveConfig creates backup on overwrite', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  const config1: PtConfig = {
+    version: '1.0.0',
+    templates: {}
+  };
+  const config2: PtConfig = {
+    version: '2.0.0',
+    templates: {}
+  };
+
+  // Save first config
+  saveConfig(config1);
+  assert.ok(fs.existsSync(CONFIG_PATH), 'Config file should be created');
+
+  // Save second config (should create backup)
+  saveConfig(config2);
+  assert.ok(fs.existsSync(backupPath), 'Backup file should exist');
+  
+  // Verify backup contains first config
+  const backupContent = fs.readFileSync(backupPath, 'utf-8');
+  assert.ok(backupContent.includes("version: 1.0.0") || backupContent.includes("version: '1.0.0'"), 'Backup should contain previous version');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('saveConfig atomic write behavior', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  const config: PtConfig = {
+    version: '1.0.0',
+    templates: {}
+  };
+
+  // Save config - should use atomic write
+  saveConfig(config);
+  
+  // Verify config exists
+  assert.ok(fs.existsSync(CONFIG_PATH), 'Config file should be created');
+  
+  // Verify no temp file remains
+  const tempPath = CONFIG_PATH + '.tmp';
+  assert.ok(!fs.existsSync(tempPath), 'Temp file should not remain');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('loadConfig returns default config when file missing', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  const config = loadConfig();
+  
+  // Verify default config structure
+  assert.strictEqual(config.version, '3.0');
+  assert.deepStrictEqual(config.templates, {});
+  assert.deepStrictEqual(config.default_post_config, []);
+  assert.deepStrictEqual(config.variables, []);
+
+  // Clean up
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+});
+
+test('saveConfig with variables normalizes key order', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  const config: PtConfig = {
+    version: '1.0.0',
+    templates: {
+      'test-template': {
+        description: 'Test',
+        folders: [],
+        variables: [
+          {
+            required: true,
+            default: 'value1',
+            prompt: 'Prompt1:',
+            name: 'var1'
+          },
+          {
+            required: false,
+            default: 'value2',
+            prompt: 'Prompt2:',
+            name: 'var2'
+          }
+        ]
+      }
+    }
+  };
+
+  // Save config
+  saveConfig(config);
+  
+  // Load and verify
+  const loaded = loadConfig();
+  const vars = loaded.templates['test-template'].variables;
+  
+  assert.strictEqual(vars.length, 2, 'Should have 2 variables');
+  assert.strictEqual(vars[0].name, 'var1', 'First variable name should be var1');
+  assert.strictEqual(vars[1].name, 'var2', 'Second variable name should be var2');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('saveConfig with empty config file', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  // Create empty config file
+  fs.writeFileSync(CONFIG_PATH, '');
+  
+  // Try to load - should throw error
+  assert.throws(() => {
+    loadConfig();
+  }, /Config file is empty/, 'Should throw error for empty config file');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('normalizeVariable preserves field order', () => {
+  const variableInput = {
+    required: true,
+    default: 'my-default',
+    prompt: 'Enter variable:',
+    name: 'varName'
+  };
+
+  const normalized = normalizeVariable(variableInput);
+  
+  // Verify field order is preserved
+  const keys = Object.keys(normalized);
+  assert.deepStrictEqual(keys, ['name', 'prompt', 'default', 'required']);
+});
+
+test('saveConfig handles multiple templates', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  const config: PtConfig = {
+    version: '1.0.0',
+    templates: {
+      'template1': {
+        description: 'Template 1',
+        folders: []
+      },
+      'template2': {
+        description: 'Template 2',
+        folders: []
+      }
+    }
+  };
+
+  // Save config
+  saveConfig(config);
+  
+  // Load and verify
+  const loaded = loadConfig();
+  assert.strictEqual(Object.keys(loaded.templates).length, 2, 'Should have 2 templates');
+  assert.strictEqual(loaded.templates['template1'].description, 'Template 1');
+  assert.strictEqual(loaded.templates['template2'].description, 'Template 2');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('saveConfig handles templates with variables', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  const config: PtConfig = {
+    version: '1.0.0',
+    templates: {
+      'template-with-vars': {
+        description: 'Template with variables',
+        folders: [],
+        variables: [
+          {
+            required: true,
+            default: 'default-value',
+            prompt: 'Enter value:',
+            name: 'myVar'
+          }
+        ]
+      }
+    }
+  };
+
+  // Save config
+  saveConfig(config);
+  
+  // Load and verify
+  const loaded = loadConfig();
+  const template = loaded.templates['template-with-vars'];
+  
+  assert.ok(template, 'Template should exist');
+  assert.strictEqual(template.variables?.length, 1, 'Should have 1 variable');
+  assert.strictEqual(template.variables?.[0].name, 'myVar', 'Variable name should be myVar');
+  assert.strictEqual(template.variables?.[0].prompt, 'Enter value:', 'Variable prompt should match');
+  assert.strictEqual(template.variables?.[0].default, 'default-value', 'Variable default should match');
+  assert.strictEqual(template.variables?.[0].required, true, 'Variable should be required');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('loadConfig handles migration from v2.0', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  // Create a v2.0 config
+  const v2Config = {
+    version: '2.0',
+    templates: {
+      'test-template': {
+        name: 'Test Template',
+        description: 'Test Description',
+        type: 'web',
+        folders: []
+      }
+    }
+  };
+
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(v2Config));
+  
+  // Load config - should migrate to v3.0
+  const config = loadConfig();
+  
+  // Verify migration happened
+  assert.strictEqual(config.version, '3.0', 'Should be migrated to v3.0');
+  assert.strictEqual(config.templates['test-template'].description, 'Test Template', 'Name should be migrated to description');
+  assert.ok(!config.templates['test-template'].type, 'Type should be removed');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('loadConfig handles migration from v2.0 with global_post_config', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  // Create a v2.0 config with global_post_config
+  const v2Config = {
+    version: '2.0',
+    templates: {},
+    global_post_config: [
+      {
+        command: 'npm install',
+        description: 'Install dependencies'
+      }
+    ]
+  };
+
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(v2Config));
+  
+  // Load config - should migrate to v3.0
+  const config = loadConfig();
+  
+  // Verify migration happened
+  assert.strictEqual(config.version, '3.0', 'Should be migrated to v3.0');
+  assert.deepStrictEqual(config.default_post_config, [
+    {
+      command: 'npm install',
+      description: 'Install dependencies'
+    }
+  ], 'global_post_config should be migrated to default_post_config');
+  assert.ok(!config.global_post_config, 'global_post_config should be removed');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome);
+  }
+});
+
+test('loadConfig handles migration from v2.0 with variables', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Clean up any existing test files
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  const backupPath = CONFIG_PATH + '.bak';
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+
+  // Create a v2.0 config with variables as Record<string, string>
+  const v2Config = {
+    version: '2.0',
+    templates: {},
+    variables: {
+      'client_name': 'My Client',
+      'project_type': 'web'
+    }
+  };
+
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(v2Config));
+  
+  // Load config - should migrate to v3.0
+  const config = loadConfig();
+  
+  // Verify migration happened
+  assert.strictEqual(config.version, '3.0', 'Should be migrated to v3.0');
+  assert.strictEqual(config.variables.length, 2, 'Should have 2 variables');
+  assert.strictEqual(config.variables[0].name, 'client_name', 'First variable name should be client_name');
+  assert.strictEqual(config.variables[0].default, 'My Client', 'First variable default should be My Client');
+  assert.strictEqual(config.variables[1].name, 'project_type', 'Second variable name should be project_type');
+  assert.strictEqual(config.variables[1].default, 'web', 'Second variable default should be web');
+
+  // Clean up
+  if (fs.existsSync(CONFIG_PATH)) {
+    fs.unlinkSync(CONFIG_PATH);
+  }
+  if (fs.existsSync(backupPath)) {
+    fs.unlinkSync(backupPath);
+  }
+  
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+  
   if (fs.existsSync(testHome)) {
     fs.rmdirSync(testHome);
   }
 });
+
+test('loadConfig handles existing config file', () => {
+  // Don't delete the existing config file - let it be restored by the user
+  // This test verifies that loadConfig works with an existing config
+  const config = loadConfig();
+  
+  // Verify config is loaded correctly
+  assert.ok(config, 'Config should be loaded');
+  assert.ok(config.templates, 'Templates should exist');
+  assert.ok(config.version, 'Version should exist');
+});
+
+test('saveConfig preserves existing config when not deleting', () => {
+  // Save the current config to restore later
+  let savedConfig: PtConfig | null = null;
+  if (fs.existsSync(CONFIG_PATH)) {
+    savedConfig = loadConfig();
+  }
+
+  // Don't delete the config file - test saving without deletion
+  const config: PtConfig = {
+    version: '1.0.0',
+    templates: {
+      'test-template': {
+        description: 'Test',
+        folders: []
+      }
+    }
+  };
+
+  // Save config
+  saveConfig(config);
+  
+  // Load and verify
+  const loaded = loadConfig();
+  assert.strictEqual(loaded.version, '1.0.0');
+  assert.ok(loaded.templates['test-template']);
+
+  // Restore the original config if it existed
+  if (savedConfig) {
+    saveConfig(savedConfig);
+  }
+});