@garyr/pt-cli 0.32.0 → 0.32.1

package/README.md

@@ -119,12 +119,18 @@ pt init ./new-project --file my-template.json --yes
 An official agent skill is included in this repository: [`skills/agency-pt-operator/SKILL.md`](skills/agency-pt-operator/SKILL.md).
 
 Equipping your agent with this skill allows it to automatically use `pt-cli` to lay down standardized boilerplate and capture new architectures you develop together.
+
 ## Warning
 
 **⚠️ Beta Software Warning**: This project is in beta stage. While stable for most use cases, please make regular backups of your template configurations before running updates or major changes.
 
 **💾 Backup Paths**:
+
 - **Linux/macOS**: `~/.pt/` or `/home/username/.pt/` and `/Users/username/.pt/`
 - **Windows**: `%USERPROFILE%\.pt\` (typically `C:\Users\Username\.pt\`)
 
-Always back up these directories before installing new versions or making significant changes.
+Always back up these directories before installing new versions or making significant changes.
+
+## Example Templates
+
+There are a couple of [example templates](https://github.com/search?q=topic%3Atemplate-project+org%3Agaryritchie&type=Repositories) for you to try. These include utilities written in python to help streamline common file management tasks.

package/dist/commands/configCommand.js

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { loadConfig, getTemplateNames, CONFIG_PATH } from '../config.js';
+import { loadConfig, getTemplateNames, getConfigPath } from '../config.js';
 export function configCommand(templateName, options = {}) {
     const config = loadConfig();
     if (options.json) {
@@ -22,7 +22,7 @@ export function configCommand(templateName, options = {}) {
         return;
     }
     const names = getTemplateNames(config);
-    console.log(chalk.cyan('Config Location:'), CONFIG_PATH);
+    console.log(chalk.cyan('Config Location:'), getConfigPath());
     console.log(chalk.cyan('\nLearned Templates:'));
     if (names.length === 0) {
         console.log(chalk.gray('  (none)'));

package/dist/config.js

@@ -3,16 +3,20 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
-export const HOME_DIR = path.join(os.homedir(), '.pt');
-export const CONFIG_PATH = path.join(HOME_DIR, 'config.yaml');
+export function getHomeDir() {
+    return path.join(os.homedir(), '.pt');
+}
+export function getConfigPath() {
+    return path.join(getHomeDir(), 'config.yaml');
+}
 export function ensureConfigDir() {
-    if (!fs.existsSync(HOME_DIR)) {
-        fs.mkdirSync(HOME_DIR, { recursive: true });
+    if (!fs.existsSync(getHomeDir())) {
+        fs.mkdirSync(getHomeDir(), { recursive: true });
     }
 }
 export function loadConfig() {
     ensureConfigDir();
-    if (!fs.existsSync(CONFIG_PATH)) {
+    if (!fs.existsSync(getConfigPath())) {
         const defaultConfig = {
             version: '3.0',
             templates: {},
@@ -25,7 +29,7 @@ export function loadConfig() {
         return defaultConfig;
     }
     try {
-        const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+        const content = fs.readFileSync(getConfigPath(), 'utf-8');
         if (!content.trim()) {
             throw new Error("Config file is empty");
         }
@@ -81,7 +85,7 @@ export function loadConfig() {
         const error = err;
         console.error(chalk.red(`\nError loading config: ${error.message}`));
         // If we have a backup, maybe suggest using it
-        const backupPath = CONFIG_PATH + '.bak';
+        const backupPath = getConfigPath() + '.bak';
         if (fs.existsSync(backupPath)) {
             console.error(chalk.yellow(`A backup exists at ${backupPath}. You may want to restore it.`));
         }
@@ -113,17 +117,17 @@ export function saveConfig(config) {
         }
     }
     const content = YAML.stringify(config);
-    const tempPath = CONFIG_PATH + '.tmp';
-    const backupPath = CONFIG_PATH + '.bak';
+    const tempPath = getConfigPath() + '.tmp';
+    const backupPath = getConfigPath() + '.bak';
     try {
         // 1. Create a backup of the current valid config if it exists
-        if (fs.existsSync(CONFIG_PATH)) {
-            fs.copyFileSync(CONFIG_PATH, backupPath);
+        if (fs.existsSync(getConfigPath())) {
+            fs.copyFileSync(getConfigPath(), backupPath);
         }
         // 2. Write to a temporary file first (atomic save)
         fs.writeFileSync(tempPath, content);
         // 3. Rename temp file to actual config path
-        fs.renameSync(tempPath, CONFIG_PATH);
+        fs.renameSync(tempPath, getConfigPath());
     }
     catch (err) {
         const error = err;

package/package.json

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

package/skills/agency-pt-operator/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: agency-pt-operator
-description: Specialist in using pt-cli to scaffold project templates, capture boilerplate, and maintain standardized directory structures. Includes knowledge of default_post_config, global variables, and automatic variable detection.
+description: Specialist in using pt-cli to scaffold project templates, capture boilerplate, and maintain standardized directory structures. Includes knowledge of default_post_config, global variables, automatic variable detection, JSON template configs, and portable template workflows.
 ---
 
 # `pt-cli` Operator Skill
@@ -14,26 +14,30 @@ As an agent equipped with this skill, you have the ability to rapidly scaffold,
    - Run `pt config` to view available templates, their post-config tasks, and default post-config tasks.
 
 2. **Scaffolding (`pt init`):**
-   When a matching template exists, initialize it using the non-interactive flags.
+   When a matching template exists, initialize it using the non-interactive flags. URL targets (GitHub, Gitea, etc.) are automatically translated to tarball downloads.
    - **Command:** `pt init <template_name> <destination_path> --yes`
    - If the template requires variables, pass them: `pt init <template_name> <destination_path> --yes --vars key1=value1,key2=value2`
    - **Direct JSON scaffolding:** To scaffold from a JSON template file without registering it in `config.yaml`:
      `pt init <destination_path> --file <json_path> --yes`
    - *Never* run `pt init` without `--yes`, as interactive prompts will block you.
+   - **Dry-run:** Preview what would be created without making changes: `pt init <template_name> <destination_path> --yes --dry-run`
+   - **Skip post-config:** Skip running post-config tasks: `pt init <template_name> <destination_path> --yes --skip-post-config`
    - Note any errors from auto-executed post-config tasks (like `npm install` failing) and correct them if necessary.
 
 3. **Capturing Knowledge (`pt learn`):**
-   If you spend time establishing a new, complex directory structure or configuration (e.g., a specific flavor of an Express backend with testing hooks), save it!
+   If you spend time establishing a new, complex directory structure or configuration (e.g., a specific flavor of an Express backend with testing hooks), save it! Remote URLs (GitHub, Gitea, etc.) are automatically translated to tarball downloads.
    - **Command:** `pt learn <source_path> --name <template_name> --desc "<Description>" --yes`
-   - **Remote Templates:** You can also learn from a remote Git repository or archive URL directly! Pass the HTTP/HTTPS URL as the `<source_path>`:
+   - **Update existing template:** Update an existing template with new structure/files: `pt update <template_name> <source_path> --yes`
+   - **Remote Templates:** Learn from a remote Git repository or archive URL directly! Pass the HTTP/HTTPS URL as the `<source_path>`:
      `pt learn https://github.com/username/my-template --name my_template --desc "Description" --yes`
    - Explain to the user that you've captured this template for future use.
    - **Automatic Variable Detection:** `pt learn` and `pt update` automatically scan text files (at root and one level deep) for `{{ variable_name }}` placeholders. You can add these to files (e.g., `README.md`, `.makerc`) and run `pt update <template> . --yes` to have them registered as template variables without manual configuration.
-   - **JSON Template Config:** If the source directory contains a `.pt-template.json` or `template.json` file, `pt learn` will auto-detect name, description, variables, folders, copy_files, post_config, and post_copy from it — skipping the corresponding interactive prompts.
+   - **JSON Template Config:** If the source directory contains a `.pt-template.json` or `template.json` file, `pt learn` will auto-detect name, description, variables, folders, copy_files, post_config, and post_copy from it — skipping the corresponding interactive prompts. JSON config takes precedence over `.info.md` and shell scripts.
+   - **JSON Output:** Output template structure as JSON for sharing instead of saving: `pt learn <source_path> --json`
 
 4. **Template Maintenance (`pt rm`):**
    If a template is obsolete or requested for deletion, use `pt rm`.
-   - **Command:** `pt rm <template_name> --yes`
+   - **Command:** `pt rm <template_name> --yes` or `pt remove <template_name> --yes`
 
 ## Template Sharing & Portability
 
@@ -41,7 +45,7 @@ Templates are designed to be fully portable. There are two approaches to sharing
 
 ### 1. Directory-based Sharing (recommended for complete templates)
 
-Place a `.pt-template.json` at the root of your template directory. This file can include all template metadata:
+Place a `.pt-template.json` or `template.json` at the root of your template directory. This file can include all template metadata:
 
 ```json
 {
@@ -56,9 +60,9 @@ Place a `.pt-template.json` at the root of your template directory. This file ca
 }
 ```
 
-When someone runs `pt learn /path/to/shared-dir --yes`, all metadata is auto-detected from this file.
+When someone runs `pt learn /path/to/shared-dir --yes`, all metadata is auto-detected from this file. The priority order is: `.pt-template.json` > `template.json` > `.info.md` > `post_config.sh`/`.bat`.
 
-**Priority order:** `.pt-template.json` > `template.json` > `.info.md` > `post_config.sh`/`.bat`
+JSON config files also take precedence over shell scripts for post_config tasks.
 
 ### 2. JSON Export/Import (for config-only sharing)
 
@@ -80,6 +84,11 @@ The complete portable template workflow:
 2. Copy `.pt-template.json` into the template source directory
 3. Share the directory (zip, git repo, etc.)
 4. Recipient: `pt learn /path/to/shared-dir --yes` — auto-detects everything
+5. Or scaffold directly without registering: `pt init ./new-project --file .pt-template.json --yes`
+
+### JSON Output for Sharing
+
+You can output a template as JSON for sharing without saving it: `pt learn <source_path> --json`
 
 ## Default Post-Config
 
@@ -101,7 +110,7 @@ Global variables are defined in `~/.pt/config.yaml` under `variables`. They act
 - **Purpose:** They ensure that common metadata fields (like `author`, `license`, `project_version`) are consistently offered for inclusion in every new template you create.
 - **Inheritance:** When you `learn` a new project structure, these global variables are automatically merged with any detected variables (`{{ var }}`) and offered as part of the new template's variable list.
 - **Localization:** Once a template is saved, its variables are "stamped" in. Subsequent changes to global variables in the config will **not** retroactively affect old templates, ensuring stability and portability.
-- **Management:** Use `pt variables --set key=value` to update your global defaults. For bulk updates, use `pt variables --set --json '...'`.
+- **Management:** Use `pt variables --set key=value` to update your global defaults. For bulk updates, use `pt variables --set --json '...'`. To delete a global variable, use `pt variables --delete key`.
 
 ## Workflow Optimization
 
@@ -109,3 +118,25 @@ Global variables are defined in `~/.pt/config.yaml` under `variables`. They act
 1. Identify the closest matching template (`pt config`).
 2. Scaffold it non-interactively (`pt init ... --yes`).
 3. Make the specific manual code/configuration changes requested by the user on top of that scaffolded base.
+4. If the scaffold is close but needs updates, use `pt update <template_name> . --yes` to update the saved template with your changes.
+
+## Additional Notes
+
+- JSON variables take precedence over other variable sources during `pt update`.
+- Optional whitespace is allowed around template variables in the substitute function.
+- Trailing `.git` is automatically stripped from repository URLs.
+- Atomic saves, backups, and safe initialization logic prevent data loss.
+- Platform-specific post-config scripts (`.sh`/`.bat`) are executed automatically based on the OS.
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `pt learn <path>` | Learn a project structure from an existing directory |
+| `pt update <template> [path]` | Update an existing template with new structure/files |
+| `pt init [template] [dest]` | Initialize a new project from a learned template |
+| `pt config [template]` | Show current config location and list templates, or export a specific template |
+| `pt variables [pairs]` | View or set global variables (comma-separated key=value) |
+| `pt default-post-config` | View or set default post-config tasks |
+| `pt add <name> [json]` | Import/add a template from a JSON string or file |
+| `pt remove <template>` / `pt rm <template>` | Remove a learned template from the config |

package/src/commands/configCommand.ts

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { loadConfig, getTemplateNames, CONFIG_PATH } from '../config.js';
+import { loadConfig, getTemplateNames, getConfigPath } from '../config.js';
 
 export interface ConfigOptions {
   json?: boolean;
@@ -28,7 +28,7 @@ export function configCommand(templateName: string | undefined, options: ConfigO
   
   const names = getTemplateNames(config);
   
-  console.log(chalk.cyan('Config Location:'), CONFIG_PATH);
+  console.log(chalk.cyan('Config Location:'), getConfigPath());
   console.log(chalk.cyan('\nLearned Templates:'));
   if (names.length === 0) {
     console.log(chalk.gray('  (none)'));

package/src/config.ts

@@ -4,8 +4,13 @@ import path from 'path';
 import os from 'os';
 import chalk from 'chalk';
 
-export const HOME_DIR = path.join(os.homedir(), '.pt');
-export const CONFIG_PATH = path.join(HOME_DIR, 'config.yaml');
+export function getHomeDir(): string {
+  return path.join(os.homedir(), '.pt');
+}
+
+export function getConfigPath(): string {
+  return path.join(getHomeDir(), 'config.yaml');
+}
 
 export interface FolderNode {
   name: string;
@@ -63,14 +68,14 @@ export interface PtConfig {
 }
 
 export function ensureConfigDir() {
-  if (!fs.existsSync(HOME_DIR)) {
-    fs.mkdirSync(HOME_DIR, { recursive: true });
+  if (!fs.existsSync(getHomeDir())) {
+    fs.mkdirSync(getHomeDir(), { recursive: true });
   }
 }
 
 export function loadConfig(): PtConfig {
   ensureConfigDir();
-  if (!fs.existsSync(CONFIG_PATH)) {
+  if (!fs.existsSync(getConfigPath())) {
     const defaultConfig: PtConfig = {
       version: '3.0',
       templates: {},
@@ -84,7 +89,7 @@ export function loadConfig(): PtConfig {
   }
 
   try {
-    const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+    const content = fs.readFileSync(getConfigPath(), 'utf-8');
     if (!content.trim()) {
       throw new Error("Config file is empty");
     }
@@ -142,7 +147,7 @@ export function loadConfig(): PtConfig {
     const error = err as Error;
     console.error(chalk.red(`\nError loading config: ${error.message}`));
     // If we have a backup, maybe suggest using it
-    const backupPath = CONFIG_PATH + '.bak';
+    const backupPath = getConfigPath() + '.bak';
     if (fs.existsSync(backupPath)) {
       console.error(chalk.yellow(`A backup exists at ${backupPath}. You may want to restore it.`));
     }
@@ -175,20 +180,20 @@ export function saveConfig(config: PtConfig) {
   }
 
   const content = YAML.stringify(config);
-  const tempPath = CONFIG_PATH + '.tmp';
-  const backupPath = CONFIG_PATH + '.bak';
+  const tempPath = getConfigPath() + '.tmp';
+  const backupPath = getConfigPath() + '.bak';
 
   try {
     // 1. Create a backup of the current valid config if it exists
-    if (fs.existsSync(CONFIG_PATH)) {
-      fs.copyFileSync(CONFIG_PATH, backupPath);
+    if (fs.existsSync(getConfigPath())) {
+      fs.copyFileSync(getConfigPath(), backupPath);
     }
 
     // 2. Write to a temporary file first (atomic save)
     fs.writeFileSync(tempPath, content);
 
     // 3. Rename temp file to actual config path
-    fs.renameSync(tempPath, CONFIG_PATH);
+    fs.renameSync(tempPath, getConfigPath());
   } catch (err) {
     const error = err as Error;
     console.error(chalk.red(`\nFailed to save config: ${error.message}`));

package/tests/config-u.ts

@@ -0,0 +1,4 @@
+// Save original HOME before modifying
+const originalHome = process
+.env
+.HOME;

package/tests/config-utils.test.ts

@@ -16,7 +16,7 @@ import {
   shouldExcludeFile,
   sanitizePath,
   DEFAULT_EXCLUDES,
-  HOME_DIR,
+  getHomeDir,
   PtConfig,
 } from '../src/config.js';
 
@@ -31,30 +31,30 @@ after(() => {
 
 test('ensureConfigDir creates dir when it does not exist', () => {
   // Make sure the dir does NOT exist before the test
-  if (fs.existsSync(HOME_DIR)) {
-    fs.rmSync(HOME_DIR, { recursive: true, force: true });
+  if (fs.existsSync(getHomeDir())) {
+    fs.rmSync(getHomeDir(), { recursive: true, force: true });
   }
-  assert.ok(!fs.existsSync(HOME_DIR), 'Precondition: HOME_DIR should not exist');
+  assert.ok(!fs.existsSync(getHomeDir()), 'Precondition: getHomeDir() should not exist');
 
   ensureConfigDir();
 
-  assert.ok(fs.existsSync(HOME_DIR), 'HOME_DIR should be created');
-  assert.ok(fs.statSync(HOME_DIR).isDirectory(), 'HOME_DIR should be a directory');
+  assert.ok(fs.existsSync(getHomeDir()), 'getHomeDir() should be created');
+  assert.ok(fs.statSync(getHomeDir()).isDirectory(), 'getHomeDir() should be a directory');
 });
 
 test('ensureConfigDir does nothing when dir already exists', () => {
   // Ensure directory exists first
-  if (!fs.existsSync(HOME_DIR)) {
-    fs.mkdirSync(HOME_DIR, { recursive: true });
+  if (!fs.existsSync(getHomeDir())) {
+    fs.mkdirSync(getHomeDir(), { recursive: true });
   }
   // Place a marker file inside to prove the dir is not recreated
-  const markerPath = path.join(HOME_DIR, '.marker');
+  const markerPath = path.join(getHomeDir(), '.marker');
   fs.writeFileSync(markerPath, 'exists');
 
   ensureConfigDir();
 
-  assert.ok(fs.existsSync(HOME_DIR), 'HOME_DIR should still exist');
-  assert.ok(fs.existsSync(markerPath), 'Marker file inside HOME_DIR should still exist');
+  assert.ok(fs.existsSync(getHomeDir()), 'getHomeDir() should still exist');
+  assert.ok(fs.existsSync(markerPath), 'Marker file inside getHomeDir() should still exist');
 
   // Clean up marker
   fs.unlinkSync(markerPath);

package/tests/config.test.ts

@@ -1,17 +1,15 @@
-import { test, before, after } from 'node:test';
+import { test, after } from 'node:test';
 import assert from 'node:assert';
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 
 // Force a temporary home directory for testing before importing anything from the CLI
 const testHome = path.join(process.cwd(), '.test-home-config');
 
-// Mock os.homedir() to return the test directory (Node.js doesn't use HOME env var on Linux)
-const originalHomedir = os.homedir;
-os.homedir = () => testHome;
+// Set HOME environment variable before importing (needed for dynamic getters)
+process.env.HOME = testHome;
 
-import { normalizeVariable, saveConfig, loadConfig, PtConfig, CONFIG_PATH, HOME_DIR } from '../src/config.js';
+import { normalizeVariable, saveConfig, loadConfig, PtConfig, getConfigPath, getHomeDir } from '../src/config.js';
 
 test('normalizeVariable key ordering', () => {
   const variableInput = {
@@ -32,15 +30,15 @@ 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)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
@@ -68,11 +66,11 @@ test('saveConfig and loadConfig roundtrip', () => {
   // Save the config
   saveConfig(testConfig);
 
-  // Assert CONFIG_PATH exists and has been created
-  assert.ok(fs.existsSync(CONFIG_PATH), 'Config file should be created');
+  // Assert getConfigPath() exists and has been created
+  assert.ok(fs.existsSync(getConfigPath()), 'Config file should be created');
 
   // Verify key order in YAML string
-  const yamlContent = fs.readFileSync(CONFIG_PATH, 'utf-8');
+  const yamlContent = fs.readFileSync(getConfigPath(), 'utf-8');
   assert.ok(yamlContent.includes('name: myVar'), 'Should contain myVar variable');
   
   // Load the config back
@@ -96,8 +94,8 @@ test('saveConfig and loadConfig roundtrip', () => {
   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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -109,7 +107,7 @@ test('saveConfig and loadConfig roundtrip', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
@@ -148,15 +146,15 @@ test('normalizeVariable with all fields', () => {
 test('saveConfig creates backup on overwrite', () => {
   // Save the current config to restore later
   let savedConfig: PtConfig | null = null;
-  if (fs.existsSync(CONFIG_PATH)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
@@ -172,7 +170,7 @@ test('saveConfig creates backup on overwrite', () => {
 
   // Save first config
   saveConfig(config1);
-  assert.ok(fs.existsSync(CONFIG_PATH), 'Config file should be created');
+  assert.ok(fs.existsSync(getConfigPath()), 'Config file should be created');
 
   // Save second config (should create backup)
   saveConfig(config2);
@@ -183,8 +181,8 @@ test('saveConfig creates backup on overwrite', () => {
   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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -196,22 +194,22 @@ test('saveConfig creates backup on overwrite', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
 test('saveConfig atomic write behavior', () => {
   // Save the current config to restore later
   let savedConfig: PtConfig | null = null;
-  if (fs.existsSync(CONFIG_PATH)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
@@ -225,15 +223,15 @@ test('saveConfig atomic write behavior', () => {
   saveConfig(config);
   
   // Verify config exists
-  assert.ok(fs.existsSync(CONFIG_PATH), 'Config file should be created');
+  assert.ok(fs.existsSync(getConfigPath()), 'Config file should be created');
   
   // Verify no temp file remains
-  const tempPath = CONFIG_PATH + '.tmp';
+  const tempPath = getConfigPath() + '.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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -245,22 +243,22 @@ test('saveConfig atomic write behavior', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
 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)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
@@ -275,7 +273,7 @@ test('loadConfig returns default config when file missing', () => {
 
   // Clean up
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
   
   // Restore the original config if it existed
@@ -287,15 +285,15 @@ test('loadConfig returns default config when file missing', () => {
 test('saveConfig with variables normalizes key order', () => {
   // Save the current config to restore later
   let savedConfig: PtConfig | null = null;
-  if (fs.existsSync(CONFIG_PATH)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
@@ -336,8 +334,8 @@ test('saveConfig with variables normalizes key order', () => {
   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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -349,28 +347,33 @@ test('saveConfig with variables normalizes key order', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
 test('saveConfig with empty config file', () => {
   // Save the current config to restore later
   let savedConfig: PtConfig | null = null;
-  if (fs.existsSync(CONFIG_PATH)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
 
+  // Ensure the config directory exists
+  if (!fs.existsSync(getHomeDir())) {
+    fs.mkdirSync(getHomeDir(), { recursive: true });
+  }
+
   // Create empty config file
-  fs.writeFileSync(CONFIG_PATH, '');
+  fs.writeFileSync(getConfigPath(), '');
   
   // loadConfig calls process.exit(1) on error, so we need to mock it
   // to prevent the test runner from dying
@@ -394,8 +397,8 @@ test('saveConfig with empty config file', () => {
   }
 
   // Clean up
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -407,7 +410,7 @@ test('saveConfig with empty config file', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
@@ -429,15 +432,15 @@ test('normalizeVariable preserves field order', () => {
 test('saveConfig handles multiple templates', () => {
   // Save the current config to restore later
   let savedConfig: PtConfig | null = null;
-  if (fs.existsSync(CONFIG_PATH)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
@@ -466,8 +469,8 @@ test('saveConfig handles multiple templates', () => {
   assert.strictEqual(loaded.templates['template2'].description, 'Template 2');
 
   // Clean up
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -479,22 +482,22 @@ test('saveConfig handles multiple templates', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
 test('saveConfig handles templates with variables', () => {
   // Save the current config to restore later
   let savedConfig: PtConfig | null = null;
-  if (fs.existsSync(CONFIG_PATH)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
@@ -532,8 +535,8 @@ test('saveConfig handles templates with variables', () => {
   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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -545,26 +548,31 @@ test('saveConfig handles templates with variables', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
 test('loadConfig handles migration from v2.0', () => {
   // Save the current config to restore later
   let savedConfig: PtConfig | null = null;
-  if (fs.existsSync(CONFIG_PATH)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
 
+  // Ensure the config directory exists
+  if (!fs.existsSync(getHomeDir())) {
+    fs.mkdirSync(getHomeDir(), { recursive: true });
+  }
+
   // Create a v2.0 config
   const v2Config = {
     version: '2.0',
@@ -577,7 +585,7 @@ test('loadConfig handles migration from v2.0', () => {
     }
   };
 
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(v2Config));
+  fs.writeFileSync(getConfigPath(), JSON.stringify(v2Config));
   
   // Load config - should migrate to v3.0
   const config = loadConfig();
@@ -588,8 +596,8 @@ test('loadConfig handles migration from v2.0', () => {
   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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -601,26 +609,31 @@ test('loadConfig handles migration from v2.0', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
 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)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
 
+  // Ensure the config directory exists
+  if (!fs.existsSync(getHomeDir())) {
+    fs.mkdirSync(getHomeDir(), { recursive: true });
+  }
+
   // Create a v2.0 config with global_post_config
   const v2Config = {
     version: '2.0',
@@ -633,7 +646,7 @@ test('loadConfig handles migration from v2.0 with global_post_config', () => {
     ]
   };
 
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(v2Config));
+  fs.writeFileSync(getConfigPath(), JSON.stringify(v2Config));
   
   // Load config - should migrate to v3.0
   const config = loadConfig();
@@ -649,8 +662,8 @@ test('loadConfig handles migration from v2.0 with global_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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -662,26 +675,31 @@ test('loadConfig handles migration from v2.0 with global_post_config', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
 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)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
   // Clean up any existing test files
-  if (fs.existsSync(CONFIG_PATH)) {
-    fs.unlinkSync(CONFIG_PATH);
+  if (fs.existsSync(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
-  const backupPath = CONFIG_PATH + '.bak';
+  const backupPath = getConfigPath() + '.bak';
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
   }
 
+  // Ensure the config directory exists
+  if (!fs.existsSync(getHomeDir())) {
+    fs.mkdirSync(getHomeDir(), { recursive: true });
+  }
+
   // Create a v2.0 config with variables as Record<string, string>
   const v2Config = {
     version: '2.0',
@@ -692,7 +710,7 @@ test('loadConfig handles migration from v2.0 with variables', () => {
     }
   };
 
-  fs.writeFileSync(CONFIG_PATH, JSON.stringify(v2Config));
+  fs.writeFileSync(getConfigPath(), JSON.stringify(v2Config));
   
   // Load config - should migrate to v3.0
   const config = loadConfig();
@@ -706,8 +724,8 @@ test('loadConfig handles migration from v2.0 with variables', () => {
   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(getConfigPath())) {
+    fs.unlinkSync(getConfigPath());
   }
   if (fs.existsSync(backupPath)) {
     fs.unlinkSync(backupPath);
@@ -719,7 +737,7 @@ test('loadConfig handles migration from v2.0 with variables', () => {
   }
   
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome);
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });
 
@@ -737,7 +755,7 @@ test('loadConfig handles existing config file', () => {
 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)) {
+  if (fs.existsSync(getConfigPath())) {
     savedConfig = loadConfig();
   }
 
@@ -768,11 +786,8 @@ test('saveConfig preserves existing config when not deleting', () => {
 
 // Cleanup: restore original os.homedir function and clean up test directory
 after(() => {
-  // Restore original os.homedir function
-  os.homedir = originalHomedir;
-  
   // Clean up test home directory if it exists
   if (fs.existsSync(testHome)) {
-    fs.rmdirSync(testHome, { recursive: true });
+    fs.rmSync(testHome, { recursive: true, force: true });
   }
 });

package/tests/init.test.ts

@@ -8,7 +8,7 @@ const testHome = path.join(process.cwd(), '.test-home-init');
 process.env.HOME = testHome;
 
 import { init } from '../src/commands/initCommand.js';
-import { loadConfig, saveConfig, PtConfig, CONFIG_PATH } from '../src/config.js';
+import { loadConfig, saveConfig, PtConfig, getConfigPath } from '../src/config.js';
 
 // Helper to clean up test directories
 function cleanup(...paths: string[]) {

package/tests/learn.test.ts

@@ -9,7 +9,7 @@ const testHome = path.join(process.cwd(), '.test-home-learn');
 process.env.HOME = testHome;
 
 import { learn } from '../src/commands/learnCommand.js';
-import { loadConfig, saveConfig, PtConfig, CONFIG_PATH } from '../src/config.js';
+import { loadConfig, saveConfig, PtConfig, getConfigPath } from '../src/config.js';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -31,8 +31,8 @@ function rmrf(p: string) {
 
 /** Ensure a clean test config state (no leftover config files). */
 function cleanConfig() {
-  if (fs.existsSync(CONFIG_PATH)) fs.unlinkSync(CONFIG_PATH);
-  const bak = CONFIG_PATH + '.bak';
+  if (fs.existsSync(getConfigPath())) fs.unlinkSync(getConfigPath());
+  const bak = getConfigPath() + '.bak';
   if (fs.existsSync(bak)) fs.unlinkSync(bak);
 }