@weldr/runr 0.4.0 → 0.7.2

package/dist/packs/actions.js

@@ -0,0 +1,176 @@
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { renderTemplate } from './renderer.js';
+/**
+ * Ensure .gitignore contains the specified entry.
+ * Idempotent: only adds if not already present.
+ */
+async function ensureGitignoreEntry(action, context) {
+    const gitignorePath = path.join(context.repoPath, action.path);
+    const entry = action.line;
+    try {
+        let content = '';
+        try {
+            content = await fsPromises.readFile(gitignorePath, 'utf-8');
+        }
+        catch {
+            // File doesn't exist, will be created
+        }
+        // Check if entry already exists
+        const lines = content.split('\n');
+        const hasEntry = lines.some(line => line.trim() === entry.trim());
+        if (hasEntry) {
+            return {
+                action,
+                executed: false,
+                message: `Entry "${entry}" already in ${action.path}`
+            };
+        }
+        if (context.dryRun) {
+            return {
+                action,
+                executed: false,
+                message: `[DRY RUN] Would add "${entry}" to ${action.path}`
+            };
+        }
+        // Add entry
+        const newContent = content.endsWith('\n') || content === ''
+            ? `${content}${entry}\n`
+            : `${content}\n${entry}\n`;
+        await fsPromises.writeFile(gitignorePath, newContent);
+        return {
+            action,
+            executed: true,
+            message: `Added "${entry}" to ${action.path}`
+        };
+    }
+    catch (error) {
+        return {
+            action,
+            executed: false,
+            message: `Failed to update ${action.path}`,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Create a file from template if it doesn't already exist.
+ * Idempotent: only creates if file is missing.
+ */
+async function createFileIfMissing(action, context) {
+    const targetPath = path.join(context.repoPath, action.path);
+    // Check "when" condition
+    if (action.when?.flag) {
+        const flagValue = context.flags[action.when.flag];
+        if (!flagValue) {
+            return {
+                action,
+                executed: false,
+                message: `Skipped ${action.path} (flag "${action.when.flag}" not set)`
+            };
+        }
+    }
+    // Check if file already exists
+    if (fs.existsSync(targetPath)) {
+        return {
+            action,
+            executed: false,
+            message: `File ${action.path} already exists`
+        };
+    }
+    try {
+        // Load template
+        const templateRelPath = context.templates[action.template];
+        if (!templateRelPath) {
+            return {
+                action,
+                executed: false,
+                message: `Template "${action.template}" not found in pack`,
+                error: 'Template not found in manifest'
+            };
+        }
+        const templatePath = path.join(context.packDir, templateRelPath);
+        // Security: Verify template path is within pack directory (prevent directory traversal)
+        const resolvedTemplatePath = path.resolve(templatePath);
+        const resolvedPackDir = path.resolve(context.packDir);
+        if (!resolvedTemplatePath.startsWith(resolvedPackDir + path.sep)) {
+            return {
+                action,
+                executed: false,
+                message: `Template path escapes pack directory: ${templateRelPath}`,
+                error: 'Invalid template path'
+            };
+        }
+        if (!fs.existsSync(templatePath)) {
+            return {
+                action,
+                executed: false,
+                message: `Template file not found: ${templateRelPath}`,
+                error: 'Template file missing'
+            };
+        }
+        if (context.dryRun) {
+            return {
+                action,
+                executed: false,
+                message: `[DRY RUN] Would create ${action.path} from template ${action.template}`
+            };
+        }
+        // Read and render template
+        const templateContent = await fsPromises.readFile(templatePath, 'utf-8');
+        const rendered = renderTemplate(templateContent, context.templateContext);
+        // Ensure parent directory exists
+        const parentDir = path.dirname(targetPath);
+        await fsPromises.mkdir(parentDir, { recursive: true });
+        // Write file
+        await fsPromises.writeFile(targetPath, rendered);
+        // Set permissions if specified
+        if (action.mode) {
+            const mode = parseInt(action.mode, 8);
+            await fsPromises.chmod(targetPath, mode);
+        }
+        return {
+            action,
+            executed: true,
+            message: `Created ${action.path} from template ${action.template}`
+        };
+    }
+    catch (error) {
+        return {
+            action,
+            executed: false,
+            message: `Failed to create ${action.path}`,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/**
+ * Execute a single init action
+ */
+export async function executeAction(action, context) {
+    switch (action.type) {
+        case 'ensure_gitignore_entry':
+            return ensureGitignoreEntry(action, context);
+        case 'create_file_if_missing':
+            return createFileIfMissing(action, context);
+        default:
+            return {
+                action,
+                executed: false,
+                message: 'Unknown action type',
+                error: `Unknown action type: ${action.type}`
+            };
+    }
+}
+/**
+ * Execute all init actions from a pack
+ */
+export async function executeActions(actions, context) {
+    const results = [];
+    for (const action of actions) {
+        const result = await executeAction(action, context);
+        results.push(result);
+    }
+    return results;
+}

package/dist/packs/loader.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Get the packs directory path (repo root / packs)
+ */
+function getPacksDir() {
+    // Go up from src/packs/loader.ts to repo root
+    return path.resolve(__dirname, '../../packs');
+}
+/**
+ * Get the packs directory path (public API for debugging)
+ */
+export function getPacksDirectory() {
+    return getPacksDir();
+}
+/**
+ * Validate a pack manifest
+ */
+function validatePackManifest(manifest, packDir) {
+    const errors = [];
+    // Check required fields
+    if (typeof manifest !== 'object' || manifest === null) {
+        errors.push('Manifest must be an object');
+        return { valid: false, errors };
+    }
+    if (manifest.pack_version !== 1) {
+        errors.push(`pack_version must be 1, got: ${manifest.pack_version}`);
+    }
+    if (typeof manifest.name !== 'string' || !manifest.name.match(/^[a-z][a-z0-9-]*$/)) {
+        errors.push(`name must be lowercase alphanumeric with hyphens, got: ${manifest.name}`);
+    }
+    if (typeof manifest.display_name !== 'string' || manifest.display_name.length === 0) {
+        errors.push('display_name is required and must be a non-empty string');
+    }
+    if (typeof manifest.description !== 'string' || manifest.description.length === 0) {
+        errors.push('description is required and must be a non-empty string');
+    }
+    // Validate templates (if provided)
+    if (manifest.templates) {
+        if (typeof manifest.templates !== 'object') {
+            errors.push('templates must be an object');
+        }
+        else {
+            for (const [key, templatePath] of Object.entries(manifest.templates)) {
+                if (typeof templatePath !== 'string') {
+                    errors.push(`Template path for "${key}" must be a string`);
+                    continue;
+                }
+                const fullPath = path.join(packDir, templatePath);
+                if (!fs.existsSync(fullPath)) {
+                    errors.push(`Template file not found: ${templatePath}`);
+                }
+            }
+        }
+    }
+    // Validate init_actions (if provided)
+    if (manifest.init_actions) {
+        if (!Array.isArray(manifest.init_actions)) {
+            errors.push('init_actions must be an array');
+        }
+        else {
+            for (let i = 0; i < manifest.init_actions.length; i++) {
+                const action = manifest.init_actions[i];
+                if (!action.type) {
+                    errors.push(`Action ${i}: missing type field`);
+                    continue;
+                }
+                if (action.type === 'ensure_gitignore_entry') {
+                    if (!action.path || typeof action.path !== 'string') {
+                        errors.push(`Action ${i}: ensure_gitignore_entry requires path (string)`);
+                    }
+                    if (!action.line || typeof action.line !== 'string') {
+                        errors.push(`Action ${i}: ensure_gitignore_entry requires line (string)`);
+                    }
+                }
+                else if (action.type === 'create_file_if_missing') {
+                    if (!action.path || typeof action.path !== 'string') {
+                        errors.push(`Action ${i}: create_file_if_missing requires path (string)`);
+                    }
+                    if (!action.template || typeof action.template !== 'string') {
+                        errors.push(`Action ${i}: create_file_if_missing requires template (string)`);
+                    }
+                    if (action.mode && !action.mode.match(/^0[0-7]{3}$/)) {
+                        errors.push(`Action ${i}: mode must be octal string (e.g., "0644")`);
+                    }
+                }
+                else {
+                    errors.push(`Action ${i}: unknown action type "${action.type}"`);
+                }
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Load a single pack from a directory
+ */
+function loadPack(packDir) {
+    const manifestPath = path.join(packDir, 'pack.json');
+    if (!fs.existsSync(manifestPath)) {
+        return null;
+    }
+    const packName = path.basename(packDir);
+    try {
+        const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+        const manifest = JSON.parse(manifestContent);
+        const validation = validatePackManifest(manifest, packDir);
+        return {
+            name: packName,
+            packDir,
+            manifest,
+            validation
+        };
+    }
+    catch (error) {
+        return {
+            name: packName,
+            packDir,
+            manifest: {},
+            validation: {
+                valid: false,
+                errors: [`Failed to parse pack.json: ${error instanceof Error ? error.message : String(error)}`]
+            }
+        };
+    }
+}
+/**
+ * Load all available packs
+ */
+export function loadAllPacks() {
+    const packsDir = getPacksDir();
+    if (!fs.existsSync(packsDir)) {
+        return [];
+    }
+    const entries = fs.readdirSync(packsDir, { withFileTypes: true });
+    const packs = [];
+    for (const entry of entries) {
+        // Skip non-directories and special directories
+        if (!entry.isDirectory() || entry.name.startsWith('_')) {
+            continue;
+        }
+        const packDir = path.join(packsDir, entry.name);
+        const pack = loadPack(packDir);
+        if (pack) {
+            packs.push(pack);
+        }
+    }
+    return packs;
+}
+/**
+ * Sanitize pack name to prevent directory traversal
+ */
+function sanitizePackName(name) {
+    // Only allow lowercase letters, numbers, and hyphens
+    // No dots, slashes, or other special characters
+    if (!name.match(/^[a-z][a-z0-9-]*$/)) {
+        return null;
+    }
+    // Additional check: ensure the sanitized name doesn't try to escape
+    const normalized = path.normalize(name);
+    if (normalized !== name || normalized.includes('..') || normalized.includes('/')) {
+        return null;
+    }
+    return name;
+}
+/**
+ * Load a specific pack by name
+ */
+export function loadPackByName(name) {
+    // Sanitize pack name to prevent directory traversal
+    const sanitizedName = sanitizePackName(name);
+    if (!sanitizedName) {
+        return null;
+    }
+    const packsDir = getPacksDir();
+    const packDir = path.join(packsDir, sanitizedName);
+    // Verify the resolved path is actually within packsDir (defense in depth)
+    const resolvedPackDir = path.resolve(packDir);
+    const resolvedPacksDir = path.resolve(packsDir);
+    if (!resolvedPackDir.startsWith(resolvedPacksDir + path.sep)) {
+        return null;
+    }
+    if (!fs.existsSync(packDir)) {
+        return null;
+    }
+    return loadPack(packDir);
+}
+/**
+ * Get a list of valid pack names
+ */
+export function getValidPackNames() {
+    const packs = loadAllPacks();
+    return packs.filter(p => p.validation.valid).map(p => p.name);
+}

package/dist/packs/renderer.js

@@ -0,0 +1,46 @@
+/**
+ * Simple template renderer for pack templates.
+ * Supports basic variable substitution using {{variable}} syntax.
+ */
+/**
+ * Render a template string with the provided context.
+ * Variables are denoted with {{variable_name}} syntax.
+ * Missing variables are replaced with empty string.
+ */
+export function renderTemplate(template, context) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, varName) => {
+        const value = context[varName];
+        return value !== undefined ? value : '';
+    });
+}
+/**
+ * Format verification commands as a bullet list for templates
+ */
+export function formatVerificationCommands(verification) {
+    const lines = [];
+    if (verification.tier0 && verification.tier0.length > 0) {
+        lines.push('**Tier 0 (fast checks)**:');
+        for (const cmd of verification.tier0) {
+            lines.push(`- \`${cmd}\``);
+        }
+        lines.push('');
+    }
+    if (verification.tier1 && verification.tier1.length > 0) {
+        lines.push('**Tier 1 (build)**:');
+        for (const cmd of verification.tier1) {
+            lines.push(`- \`${cmd}\``);
+        }
+        lines.push('');
+    }
+    if (verification.tier2 && verification.tier2.length > 0) {
+        lines.push('**Tier 2 (tests)**:');
+        for (const cmd of verification.tier2) {
+            lines.push(`- \`${cmd}\``);
+        }
+        lines.push('');
+    }
+    if (lines.length === 0) {
+        return 'No verification commands configured yet. Edit `.runr/runr.config.json` to add them.';
+    }
+    return lines.join('\n').trim();
+}