feat(create-gen-app): auto-generate LICENSE files from templates

- Add built-in license templates (MIT, Apache-2.0, ISC) in `src/licenses.ts`
- Automatically generate or overwrite LICENSE file based on user's selection
- Replace placeholders (year, author name, email) with user-provided values
- Show friendly warning when template doesn't support selected license type
- Update `replaceVariables` to call `ensureLicenseFile()` after file replacement
- Add unit tests for license template rendering
- Update integration tests to validate LICENSE file generation in real GitHub flows
- Document license generation feature in README

This ensures generated projects always have proper LICENSE files matching the
user's selection, whether the template originally included one or not.

Author: sdqede

packages/create-gen-app/README.md

@@ -23,6 +23,7 @@ A TypeScript library for cloning and customizing template repositories with vari
 - Load custom questions from `.questions.json` or `.questions.js` files
 - Interactive prompts using inquirerer with CLI argument support
 - Stream-based file processing for efficient variable replacement
+- Auto-generate `LICENSE` file content (MIT, Apache-2.0, ISC) based on user answers
 
 ## Installation
 

packages/create-gen-app/__tests__/cli.test.ts

@@ -52,6 +52,13 @@ describe("CLI integration (GitHub templates)", () => {
       const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
       expect(pkg.name).toBe(answers.PACKAGE_IDENTIFIER);
       expect(pkg.license).toBe(answers.LICENSE);
+
+      const licenseContent = fs.readFileSync(
+        path.join(workspace.outputDir, "LICENSE"),
+        "utf8"
+      );
+      expect(licenseContent).toContain("MIT License");
+      expect(licenseContent).toContain(answers.USERFULLNAME);
     } finally {
       cleanupWorkspace(workspace);
     }

packages/create-gen-app/__tests__/create-gen-flow.test.ts

@@ -43,6 +43,12 @@ describe("createGen integration (GitHub templates)", () => {
         ".questions.json"
       );
       expect(fs.existsSync(questionsJsonPath)).toBe(false);
+
+      const licensePath = path.join(workspace.outputDir, "LICENSE");
+      expect(fs.existsSync(licensePath)).toBe(true);
+      const licenseContent = fs.readFileSync(licensePath, "utf8");
+      expect(licenseContent).toContain(answers.USERFULLNAME);
+      expect(licenseContent).toContain("MIT License");
     } finally {
       cleanupWorkspace(workspace);
     }

packages/create-gen-app/__tests__/licenses.test.ts

@@ -0,0 +1,25 @@
+import { renderLicense, isSupportedLicense, listSupportedLicenses } from "../src/licenses";
+
+describe("license templates", () => {
+  it("renders MIT license with author and email", () => {
+    const content = renderLicense("MIT", {
+      author: "Test User",
+      email: "test@example.com",
+      year: "2099",
+    });
+    expect(content).toContain("Test User");
+    expect(content).toContain("<test@example.com>");
+    expect(content).toContain("2099");
+  });
+
+  it("falls back when license not supported", () => {
+    expect(renderLicense("UNKNOWN", {})).toBeNull();
+    expect(isSupportedLicense("UNKNOWN")).toBe(false);
+  });
+
+  it("lists supported licenses", () => {
+    const supported = listSupportedLicenses();
+    expect(supported).toEqual(expect.arrayContaining(["MIT", "APACHE-2.0", "ISC"]));
+  });
+});
+

packages/create-gen-app/src/licenses.ts

@@ -0,0 +1,109 @@
+const PLACEHOLDER_PATTERN = /{{(\w+)}}/g;
+
+interface LicenseContext {
+  year: string;
+  author: string;
+  email: string;
+}
+
+const LICENSE_TEMPLATES: Record<string, string> = {
+  MIT: `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.
+`,
+  "APACHE-2.0": `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.
+`,
+  ISC: `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.
+`,
+};
+
+export type SupportedLicense = keyof typeof LICENSE_TEMPLATES;
+
+export function isSupportedLicense(name: string): name is SupportedLicense {
+  return name.toUpperCase() in LICENSE_TEMPLATES;
+}
+
+export function renderLicense(
+  licenseName: string,
+  context: Partial<LicenseContext>
+): string | null {
+  if (!licenseName) {
+    return null;
+  }
+  const normalized = licenseName.toUpperCase() as SupportedLicense;
+  const template = LICENSE_TEMPLATES[normalized];
+  if (!template) {
+    return null;
+  }
+
+  const ctx: LicenseContext = {
+    year: context.year ?? new Date().getFullYear().toString(),
+    author: context.author ?? "Unknown Author",
+    email: context.email ?? "",
+  };
+
+  const emailLine = ctx.email ? ` <${ctx.email}>` : "";
+
+  return template.replace(PLACEHOLDER_PATTERN, (_, rawKey: string) => {
+    const key = rawKey.toUpperCase();
+    if (key === "EMAIL_LINE") {
+      return emailLine;
+    }
+    const normalizedKey = key.toLowerCase() as keyof LicenseContext;
+    const value = ctx[normalizedKey];
+    return value || "";
+  });
+}
+
+export function listSupportedLicenses(): string[] {
+  return Object.keys(LICENSE_TEMPLATES);
+}
+

packages/create-gen-app/src/replace.ts

@@ -4,6 +4,7 @@ import { Transform } from 'stream';
 import { pipeline } from 'stream/promises';
 
 import { ExtractedVariables } from './types';
+import { renderLicense, isSupportedLicense } from './licenses';
 
 /**
  * Replace variables in all files in the template directory
@@ -23,6 +24,7 @@ export async function replaceVariables(
   }
 
   await walkAndReplace(templateDir, outputDir, extractedVariables, answers);
+  await ensureLicenseFile(outputDir, answers);
 }
 
 /**
@@ -79,6 +81,49 @@ async function walkAndReplace(
   }
 }
 
+async function ensureLicenseFile(
+  outputDir: string,
+  answers: Record<string, any>
+): Promise<void> {
+  const licenseValue = answers?.LICENSE;
+  if (typeof licenseValue !== 'string' || licenseValue.trim() === '') {
+    return;
+  }
+
+  const selectedLicense = licenseValue.trim();
+  if (!isSupportedLicense(selectedLicense)) {
+    console.warn(
+      `[create-gen-app] License "${selectedLicense}" is not supported by the built-in templates. Leaving template LICENSE file as-is.`
+    );
+    return;
+  }
+
+  const author =
+    answers?.USERFULLNAME ??
+    answers?.AUTHOR ??
+    answers?.AUTHORFULLNAME ??
+    answers?.USERNAME ??
+    'Unknown Author';
+
+  const email = answers?.USEREMAIL ?? answers?.EMAIL ?? '';
+
+  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');
+  console.log(
+    `[create-gen-app] LICENSE updated with ${selectedLicense} template.`
+  );
+}
+
 /**
  * Replace variables in a file using streams
  * @param sourcePath - Source file path

packages/create-gen-app/test-utils/integration-helpers.ts

@@ -25,7 +25,10 @@ export function cleanupWorkspace(workspace: TempWorkspace): void {
   fs.rmSync(workspace.baseDir, { recursive: true, force: true });
 }
 
-export function buildAnswers(suffix: string): Record<string, string> {
+export function buildAnswers(
+  suffix: string,
+  overrides: Partial<Record<string, string>> = {}
+): Record<string, string> {
   const safeSuffix = suffix.replace(/[^a-z0-9]/gi, "-").toLowerCase();
   return {
     USERFULLNAME: `Test User ${suffix}`,
@@ -37,6 +40,7 @@ export function buildAnswers(suffix: string): Record<string, string> {
     ACCESS: "public",
     LICENSE: "MIT",
     PACKAGE_IDENTIFIER: `integration-${safeSuffix}`,
+    ...overrides,
   };
 }