@garyr/pt-cli 0.38.0 → 0.40.0

package/dist/commands/addCommand.js

@@ -2,24 +2,114 @@ import fs from 'fs';
 import path from 'path';
 import chalk from 'chalk';
 import { loadConfig, saveConfig } from '../config.js';
+/**
+ * Validate JSON file exists and contains valid JSON
+ */
+function validateJsonFile(filePath) {
+    try {
+        // Check if file exists
+        if (!fs.existsSync(filePath)) {
+            return {
+                valid: false,
+                error: `File not found: ${filePath}`
+            };
+        }
+        // Check file size (reasonable limit to prevent reading huge files)
+        const stats = fs.statSync(filePath);
+        if (stats.size > 10 * 1024 * 1024) { // 10MB limit
+            return {
+                valid: false,
+                error: `File too large (${stats.size} bytes). Maximum size is 10MB.`
+            };
+        }
+        // Read and parse JSON
+        const content = fs.readFileSync(filePath, 'utf8');
+        if (!content.trim()) {
+            return {
+                valid: false,
+                error: 'File is empty'
+            };
+        }
+        const data = JSON.parse(content);
+        return { valid: true, data };
+    }
+    catch (e) {
+        const error = e;
+        return {
+            valid: false,
+            error: `JSON parse error: ${error.message}`
+        };
+    }
+}
+/**
+ * Validate template structure
+ */
+function validateTemplateStructure(data) {
+    if (!data || typeof data !== 'object') {
+        return {
+            valid: false,
+            error: 'Template data must be a JSON object'
+        };
+    }
+    // Basic structure validation
+    if (data.description && typeof data.description !== 'string') {
+        return {
+            valid: false,
+            error: 'Template description must be a string'
+        };
+    }
+    if (data.variables && Array.isArray(data.variables)) {
+        for (let i = 0; i < data.variables.length; i++) {
+            const v = data.variables[i];
+            if (!v.name || typeof v.name !== 'string') {
+                return {
+                    valid: false,
+                    error: `Variable at index ${i} must have a string 'name' field`
+                };
+            }
+        }
+    }
+    return { valid: true };
+}
 export function addCommand(name, jsonStr, options = {}) {
     const config = loadConfig();
+    // Determine if we're reading from file or string
+    const isFile = !!options.file;
+    let data;
     try {
-        let data;
-        if (options.file) {
+        if (isFile) {
+            // Validate file first
             const filePath = path.resolve(options.file);
-            data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            const validation = validateJsonFile(filePath);
+            if (!validation.valid) {
+                console.error(chalk.red(`Error: ${validation.error}`));
+                console.error(chalk.gray(`File: ${filePath}`));
+                process.exit(1);
+            }
+            data = validation.data;
         }
         else if (jsonStr) {
-            data = JSON.parse(jsonStr);
+            // Parse JSON string directly
+            try {
+                data = JSON.parse(jsonStr);
+            }
+            catch (e) {
+                const error = e;
+                console.error(chalk.red(`Error: Invalid JSON string - ${error.message}`));
+                process.exit(1);
+            }
         }
         else {
             console.error('Error: Either a JSON string or --file <path> must be provided.');
             process.exit(1);
         }
-        if (!config.templates)
-            config.templates = {};
-        // Basic validation: ensure we aren't accidentally adding a full config object
+        // Validate template structure
+        const structureValidation = validateTemplateStructure(data);
+        if (!structureValidation.valid) {
+            console.error(chalk.red(`Error: Invalid template structure - ${structureValidation.error}`));
+            process.exit(1);
+        }
+        // Check for full config object
         if (data && data.templates && typeof data.templates === 'object') {
             console.error(chalk.red('Error: The provided JSON appears to be a full configuration file, not a single template.'));
             console.error(chalk.gray('If you want to import a specific template from it, extract that template object first.'));
@@ -31,7 +121,7 @@ export function addCommand(name, jsonStr, options = {}) {
     }
     catch (e) {
         const error = e;
-        console.error(chalk.red(`Failed to parse template JSON: ${error.message}`));
+        console.error(chalk.red(`Failed to process template: ${error.message}`));
         process.exit(1);
     }
 }

package/dist/commands/configCommand.js

@@ -9,15 +9,22 @@ export function configCommand(templateName, options = {}) {
                     name: templateName,
                     ...config.templates[templateName]
                 };
-                console.log(JSON.stringify(output, null, 2));
+                // Safely drain stdout before allowing the process to close
+                process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
+                    process.exit(0);
+                });
             }
             else {
-                console.error(chalk.red(`Error: Template "${templateName}" not found.`));
-                process.exit(1);
+                process.stderr.write(chalk.red(`Error: Template "${templateName}" not found.\n`), () => {
+                    process.exit(1);
+                });
             }
         }
         else {
-            console.log(JSON.stringify(config, null, 2));
+            // Safely drain the entire global config payload
+            process.stdout.write(JSON.stringify(config, null, 2) + '\n', () => {
+                process.exit(0);
+            });
         }
         return;
     }

package/dist/commands/learnCommand.js

@@ -535,7 +535,11 @@ export async function learn(sourcePath, updateTemplate = null, options = {}) {
             name: targetName,
             ...templateConfig
         };
-        console.log(JSON.stringify(output, null, 2));
+        // Force the application to wait until every single byte of this JSON string 
+        // safely clears the operating system's pipe buffer before letting the process die.
+        process.stdout.write(JSON.stringify(output, null, 2) + '\n', () => {
+            process.exit(0);
+        });
         return;
     }
     config.templates[targetName] = templateConfig;
@@ -577,10 +581,10 @@ function extractStructure(dirPath, rootPath, ignorePatterns) {
             let info = "";
             const gitkeepPath = path.join(fullPath, '.gitkeep.md');
             const infoPath = path.join(fullPath, '.info.md');
-            if (fs.existsSync(gitkeepPath))
-                info = fs.readFileSync(gitkeepPath, 'utf-8').trim();
-            else if (fs.existsSync(infoPath))
+            if (fs.existsSync(infoPath))
                 info = fs.readFileSync(infoPath, 'utf-8').trim();
+            else if (fs.existsSync(gitkeepPath))
+                info = fs.readFileSync(gitkeepPath, 'utf-8').trim();
             nodes.push({ name: entry.name, info: info, children: children });
         }
     }