genomic 4.0.2 → 5.0.1

package/esm/template/replace.js

@@ -0,0 +1,110 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { Transform } from 'stream';
+import { pipeline } from 'stream/promises';
+import { renderLicense, isSupportedLicense, findLicenseAuthor, findLicenseEmail, findLicenseValue, } from '../licenses';
+/**
+ * Replace variables in all files in the template directory
+ * @param templateDir - Path to the template directory
+ * @param outputDir - Path to the output directory
+ * @param extractedVariables - Variables extracted from the template
+ * @param answers - User answers for variable values
+ */
+export async function replaceVariables(templateDir, outputDir, extractedVariables, answers) {
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    await walkAndReplace(templateDir, outputDir, extractedVariables, answers);
+    await ensureLicenseFile(outputDir, answers);
+}
+/**
+ * Walk through directory and replace variables in files and filenames
+ * @param sourceDir - Source directory
+ * @param destDir - Destination directory
+ * @param extractedVariables - Variables extracted from the template
+ * @param answers - User answers for variable values
+ * @param sourceRelativePath - Current relative path in source (for recursion)
+ * @param destRelativePath - Current relative path in destination (for recursion)
+ */
+async function walkAndReplace(sourceDir, destDir, extractedVariables, answers, sourceRelativePath = '', destRelativePath = '') {
+    const currentSource = path.join(sourceDir, sourceRelativePath);
+    const entries = fs.readdirSync(currentSource, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourceEntryPath = path.join(currentSource, entry.name);
+        // Skip template configuration files - they should not be copied to output
+        if (entry.name === '.boilerplate.json' ||
+            entry.name === '.boilerplate.js' ||
+            entry.name === '.boilerplates.json') {
+            continue;
+        }
+        let newName = entry.name;
+        for (const replacer of extractedVariables.fileReplacers) {
+            if (answers[replacer.variable] !== undefined) {
+                newName = newName.replace(replacer.pattern, String(answers[replacer.variable]));
+            }
+        }
+        const destEntryPath = path.join(destDir, destRelativePath, newName);
+        if (entry.isDirectory()) {
+            if (!fs.existsSync(destEntryPath)) {
+                fs.mkdirSync(destEntryPath, { recursive: true });
+            }
+            await walkAndReplace(sourceDir, destDir, extractedVariables, answers, path.join(sourceRelativePath, entry.name), path.join(destRelativePath, newName));
+        }
+        else if (entry.isFile()) {
+            await replaceInFile(sourceEntryPath, destEntryPath, extractedVariables, answers);
+        }
+    }
+}
+async function ensureLicenseFile(outputDir, answers) {
+    const licenseValue = findLicenseValue(answers);
+    if (typeof licenseValue !== 'string' || licenseValue.trim() === '') {
+        return;
+    }
+    const selectedLicense = licenseValue.trim();
+    if (!isSupportedLicense(selectedLicense)) {
+        console.warn(`[@genomic/scaffolds] License "${selectedLicense}" is not supported by the built-in templates. Leaving template LICENSE file as-is.`);
+        return;
+    }
+    const author = findLicenseAuthor(answers) ?? 'Unknown Author';
+    const email = findLicenseEmail(answers) ?? '';
+    const content = renderLicense(selectedLicense, {
+        author: String(author),
+        email: String(email || ''),
+    });
+    if (!content) {
+        return;
+    }
+    const licensePath = path.join(outputDir, 'LICENSE');
+    fs.mkdirSync(path.dirname(licensePath), { recursive: true });
+    fs.writeFileSync(licensePath, content.trimEnd() + '\n', 'utf8');
+}
+/**
+ * Replace variables in a file using streams
+ * @param sourcePath - Source file path
+ * @param destPath - Destination file path
+ * @param extractedVariables - Variables extracted from the template
+ * @param answers - User answers for variable values
+ */
+async function replaceInFile(sourcePath, destPath, extractedVariables, answers) {
+    const destDir = path.dirname(destPath);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    const replaceTransform = new Transform({
+        transform(chunk, _encoding, callback) {
+            let content = chunk.toString();
+            for (const replacer of extractedVariables.contentReplacers) {
+                if (answers[replacer.variable] !== undefined) {
+                    content = content.replace(replacer.pattern, String(answers[replacer.variable]));
+                }
+            }
+            callback(null, Buffer.from(content));
+        }
+    });
+    try {
+        await pipeline(fs.createReadStream(sourcePath), replaceTransform, fs.createWriteStream(destPath));
+    }
+    catch (error) {
+        fs.copyFileSync(sourcePath, destPath);
+    }
+}

package/esm/template/templatizer.js

@@ -0,0 +1,73 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { extractVariables } from './extract';
+import { promptUser } from './prompt';
+import { replaceVariables } from './replace';
+export class Templatizer {
+    constructor() {
+        // Pure template processor - no configuration needed
+    }
+    /**
+     * Process a local template directory (extract + prompt + replace)
+     * @param templateDir - Local directory path (MUST be local, NOT git URL)
+     * @param outputDir - Output directory for generated project
+     * @param options - Processing options (argv overrides, noTty, prompter)
+     * @returns Processing result
+     */
+    async process(templateDir, outputDir, options) {
+        this.validateTemplateDir(templateDir);
+        // Handle subdirectory within template
+        const actualTemplateDir = options?.fromPath
+            ? path.join(templateDir, options.fromPath)
+            : templateDir;
+        this.validateTemplateDir(actualTemplateDir);
+        // Extract variables
+        const variables = await this.extract(actualTemplateDir);
+        // Prompt for values (pass through optional prompter)
+        const answers = await this.prompt(variables, options?.argv, options?.prompter, options?.noTty);
+        // Replace variables
+        await this.replace(actualTemplateDir, outputDir, variables, answers);
+        return {
+            outputDir,
+            variables,
+            answers,
+        };
+    }
+    /**
+     * Extract variables from template directory
+     */
+    async extract(templateDir) {
+        return extractVariables(templateDir);
+    }
+    /**
+     * Prompt user for variables
+     * @param extracted - Extracted variables from template
+     * @param argv - Pre-populated answers
+     * @param prompter - Optional existing Prompter instance to reuse
+     * @param noTty - Whether to disable TTY mode (only used when creating a new prompter)
+     */
+    async prompt(extracted, argv, prompter, noTty) {
+        return promptUser(extracted, argv ?? {}, prompter, noTty ?? false);
+    }
+    /**
+     * Replace variables in template
+     */
+    async replace(templateDir, outputDir, extracted, answers) {
+        return replaceVariables(templateDir, outputDir, extracted, answers);
+    }
+    /**
+     * Validate template directory exists and has content
+     */
+    validateTemplateDir(templateDir) {
+        if (!fs.existsSync(templateDir)) {
+            throw new Error(`Template directory does not exist: ${templateDir}`);
+        }
+        if (!fs.statSync(templateDir).isDirectory()) {
+            throw new Error(`Template path is not a directory: ${templateDir}`);
+        }
+        const entries = fs.readdirSync(templateDir);
+        if (entries.length === 0) {
+            throw new Error(`Template directory is empty: ${templateDir}`);
+        }
+    }
+}

package/esm/template/types.js

@@ -0,0 +1 @@
+export {};

package/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/utils/npm-version-check.js

@@ -0,0 +1,52 @@
+import { execSync } from 'child_process';
+/**
+ * Check if current package version is outdated compared to npm registry
+ * @param packageName - Package name to check
+ * @param currentVersion - Current version string
+ * @returns Version comparison result
+ */
+export async function checkNpmVersion(packageName, currentVersion) {
+    try {
+        const latestVersion = execSync(`npm view ${packageName} version`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        const isOutdated = compareVersions(currentVersion, latestVersion) < 0;
+        return {
+            currentVersion,
+            latestVersion,
+            isOutdated,
+        };
+    }
+    catch (error) {
+        return {
+            currentVersion,
+            latestVersion: null,
+            isOutdated: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Compare two semver version strings
+ * Returns: -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+export function compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 < p2)
+            return -1;
+        if (p1 > p2)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Print version warning to console if outdated
+ */
+export function warnIfOutdated(packageName, result) {
+    if (result.isOutdated && result.latestVersion) {
+        console.warn(`\n⚠️  New version available: ${result.currentVersion} → ${result.latestVersion}`);
+        console.warn(`   Run: npm install -g ${packageName}@latest\n`);
+    }
+}

package/esm/utils/types.js

@@ -0,0 +1 @@
+export {};

package/git/git-cloner.d.ts

@@ -0,0 +1,32 @@
+import { GitCloneOptions, GitCloneResult } from './types';
+export declare class GitCloner {
+    /**
+     * Clone a git repository to a destination
+     * @param url - Repository URL (will be normalized)
+     * @param destination - Target directory path
+     * @param options - Clone options (branch, depth)
+     * @returns Clone result with normalized URL and destination
+     */
+    clone(url: string, destination: string, options?: GitCloneOptions): GitCloneResult;
+    /**
+     * Clone to a temporary directory
+     * @param url - Repository URL
+     * @param options - Clone options
+     * @returns Clone result with temp directory path
+     */
+    cloneToTemp(url: string, options?: GitCloneOptions): GitCloneResult;
+    /**
+     * Normalize a URL to git-cloneable format
+     * Handles: org/repo -> https://github.com/org/repo.git
+     */
+    normalizeUrl(url: string): string;
+    /**
+     * Validate git URL format
+     */
+    validateUrl(url: string): boolean;
+    /**
+     * Remove .git directory from cloned repo
+     */
+    removeGitDir(directory: string): void;
+    private executeClone;
+}

package/git/git-cloner.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitCloner = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+class GitCloner {
+    /**
+     * Clone a git repository to a destination
+     * @param url - Repository URL (will be normalized)
+     * @param destination - Target directory path
+     * @param options - Clone options (branch, depth)
+     * @returns Clone result with normalized URL and destination
+     */
+    clone(url, destination, options) {
+        const normalizedUrl = this.normalizeUrl(url);
+        // Clean destination if exists
+        if (fs.existsSync(destination)) {
+            fs.rmSync(destination, { recursive: true, force: true });
+        }
+        this.executeClone(normalizedUrl, destination, options);
+        this.removeGitDir(destination);
+        return {
+            destination,
+            normalizedUrl,
+            branch: options?.branch,
+        };
+    }
+    /**
+     * Clone to a temporary directory
+     * @param url - Repository URL
+     * @param options - Clone options
+     * @returns Clone result with temp directory path
+     */
+    cloneToTemp(url, options) {
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'create-gen-'));
+        return this.clone(url, tempDir, options);
+    }
+    /**
+     * Normalize a URL to git-cloneable format
+     * Handles: org/repo -> https://github.com/org/repo.git
+     */
+    normalizeUrl(url) {
+        // Already a full URL
+        if (url.startsWith('git@') ||
+            url.startsWith('https://') ||
+            url.startsWith('http://')) {
+            return url;
+        }
+        // org/repo shorthand
+        if (/^[\w-]+\/[\w-]+$/.test(url)) {
+            return `https://github.com/${url}.git`;
+        }
+        return url;
+    }
+    /**
+     * Validate git URL format
+     */
+    validateUrl(url) {
+        const normalized = this.normalizeUrl(url);
+        return (normalized.startsWith('git@') ||
+            normalized.startsWith('https://') ||
+            normalized.startsWith('http://'));
+    }
+    /**
+     * Remove .git directory from cloned repo
+     */
+    removeGitDir(directory) {
+        const gitDir = path.join(directory, '.git');
+        if (fs.existsSync(gitDir)) {
+            fs.rmSync(gitDir, { recursive: true, force: true });
+        }
+    }
+    executeClone(url, destination, options) {
+        const branch = options?.branch;
+        const depth = options?.depth ?? 1;
+        const singleBranch = options?.singleBranch ?? true;
+        const branchArgs = branch ? ` --branch ${branch}` : '';
+        const singleBranchArgs = singleBranch ? ' --single-branch' : '';
+        const depthArgs = ` --depth ${depth}`;
+        const command = `git clone${branchArgs}${singleBranchArgs}${depthArgs} ${url} ${destination}`;
+        try {
+            (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+        }
+        catch (error) {
+            // Clean up on failure
+            if (fs.existsSync(destination)) {
+                fs.rmSync(destination, { recursive: true, force: true });
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to clone repository: ${errorMessage}`);
+        }
+    }
+}
+exports.GitCloner = GitCloner;

package/git/types.d.ts

@@ -0,0 +1,15 @@
+export interface GitCloneOptions {
+    branch?: string;
+    depth?: number;
+    singleBranch?: boolean;
+}
+export interface GitCloneResult {
+    destination: string;
+    normalizedUrl: string;
+    branch?: string;
+}
+export interface GitUrlValidation {
+    isValid: boolean;
+    normalized?: string;
+    error?: string;
+}

package/index.d.ts

@@ -1,4 +1,29 @@
-export * from './commander';
-export * from './prompt';
-export * from './question';
-export * from './resolvers';
+import { extractVariables } from './template/extract';
+import { promptUser } from './template/prompt';
+import { replaceVariables } from './template/replace';
+import { CreateGenOptions } from './types';
+export * from './cache/cache-manager';
+export * from './cache/types';
+export * from './git/git-cloner';
+export * from './git/types';
+export * from './scaffolder/template-scaffolder';
+export * from './scaffolder/types';
+export * from './template/templatizer';
+export * from './template/types';
+export * from './utils/npm-version-check';
+export * from './utils/types';
+export * from './template/extract';
+export * from './template/prompt';
+export * from './template/replace';
+export * from './types';
+export { extractVariables, promptUser, replaceVariables };
+/**
+ * @deprecated This function is deprecated and will be removed in the next major version.
+ * Use the modular approach with CacheManager, GitCloner, and Templatizer classes instead.
+ * See @genomic/scaffolds-test package for an example of the new orchestration pattern.
+ *
+ * Create a new project from a template repository
+ * @param options - Options for creating the project
+ * @returns Path to the generated project
+ */
+export declare function createGen(options: CreateGenOptions): Promise<string>;

package/index.js

@@ -14,7 +14,46 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./commander"), exports);
-__exportStar(require("./prompt"), exports);
-__exportStar(require("./question"), exports);
-__exportStar(require("./resolvers"), exports);
+exports.replaceVariables = exports.promptUser = exports.extractVariables = void 0;
+exports.createGen = createGen;
+const inquirerer_1 = require("inquirerer");
+const extract_1 = require("./template/extract");
+Object.defineProperty(exports, "extractVariables", { enumerable: true, get: function () { return extract_1.extractVariables; } });
+const prompt_1 = require("./template/prompt");
+Object.defineProperty(exports, "promptUser", { enumerable: true, get: function () { return prompt_1.promptUser; } });
+const replace_1 = require("./template/replace");
+Object.defineProperty(exports, "replaceVariables", { enumerable: true, get: function () { return replace_1.replaceVariables; } });
+const licenses_1 = require("./licenses");
+// Register the 'licenses' resolver for optionsFrom support
+// This allows boilerplate templates to use: "optionsFrom": "licenses"
+(0, inquirerer_1.registerDefaultResolver)('licenses', () => (0, licenses_1.listSupportedLicenses)());
+// Export new modular classes
+__exportStar(require("./cache/cache-manager"), exports);
+__exportStar(require("./cache/types"), exports);
+__exportStar(require("./git/git-cloner"), exports);
+__exportStar(require("./git/types"), exports);
+__exportStar(require("./scaffolder/template-scaffolder"), exports);
+__exportStar(require("./scaffolder/types"), exports);
+__exportStar(require("./template/templatizer"), exports);
+__exportStar(require("./template/types"), exports);
+__exportStar(require("./utils/npm-version-check"), exports);
+__exportStar(require("./utils/types"), exports);
+// Export template processing functions
+__exportStar(require("./template/extract"), exports);
+__exportStar(require("./template/prompt"), exports);
+__exportStar(require("./template/replace"), exports);
+// Export shared types
+__exportStar(require("./types"), exports);
+/**
+ * @deprecated This function is deprecated and will be removed in the next major version.
+ * Use the modular approach with CacheManager, GitCloner, and Templatizer classes instead.
+ * See @genomic/scaffolds-test package for an example of the new orchestration pattern.
+ *
+ * Create a new project from a template repository
+ * @param options - Options for creating the project
+ * @returns Path to the generated project
+ */
+async function createGen(options) {
+    throw new Error('createGen() has been deprecated. Please use CacheManager, GitCloner, and Templatizer classes for modular template processing. ' +
+        'See @genomic/scaffolds-test package for the new orchestration pattern.');
+}

package/licenses-templates/APACHE-2.0.txt

@@ -0,0 +1,18 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+Copyright (c) {{YEAR}} {{AUTHOR}}{{EMAIL_LINE}}
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+

package/licenses-templates/BSD-3-CLAUSE.txt

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) {{YEAR}} {{AUTHOR}}{{EMAIL_LINE}}
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

package/licenses-templates/CLOSED.txt

@@ -0,0 +1,20 @@
+Copyright (c) {{YEAR}} {{AUTHOR}}{{EMAIL_LINE}}
+
+All Rights Reserved.
+
+This software and associated documentation files (the "Software") are the
+exclusive property of the copyright holder. No part of the Software may be
+reproduced, distributed, modified, or transmitted in any form or by any means,
+including photocopying, recording, or other electronic or mechanical methods,
+without the prior written permission of the copyright holder.
+
+Unauthorized copying, modification, distribution, or use of this Software,
+via any medium, is strictly prohibited.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/licenses-templates/GPL-3.0.txt

@@ -0,0 +1,18 @@
+GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (c) {{YEAR}} {{AUTHOR}}{{EMAIL_LINE}}
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+

package/licenses-templates/ISC.txt

@@ -0,0 +1,16 @@
+ISC License
+
+Copyright (c) {{YEAR}} {{AUTHOR}}{{EMAIL_LINE}}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
+OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+

package/licenses-templates/MIT.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) {{YEAR}} {{AUTHOR}}{{EMAIL_LINE}}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/licenses-templates/MPL-2.0.txt

@@ -0,0 +1,8 @@
+Mozilla Public License Version 2.0
+
+Copyright (c) {{YEAR}} {{AUTHOR}}{{EMAIL_LINE}}
+
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at https://mozilla.org/MPL/2.0/.
+