complete-cli 1.0.1-dev.0

package/LICENSE

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 The Complete Contributors
+
+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/README.md

@@ -0,0 +1,7 @@
+# `complete-cli`
+
+[![npm version](https://img.shields.io/npm/v/complete-cli.svg)](https://www.npmjs.com/package/complete-cli)
+
+This package contains a CLI tool that helps you bootstrap [TypeScript](https://www.typescriptlang.org/) projects.
+
+Please see the [docs](https://complete-ts.github.io/complete-cli) for more information.

package/dist/commands/CheckCommand.js

@@ -0,0 +1,141 @@
+import chalk from "chalk";
+import { Command, Option } from "clipanion";
+import { ReadonlySet } from "complete-common";
+import { $s, deleteFileOrDirectory, fatalError, isDirectory, isFile, readFile, writeFile, } from "complete-node";
+import klawSync from "klaw-sync";
+import path from "node:path";
+import { ACTION_YML, ACTION_YML_TEMPLATE_PATH, CWD, TEMPLATES_DYNAMIC_DIR, TEMPLATES_STATIC_DIR, } from "../constants.js";
+import { getTruncatedText } from "./check/getTruncatedText.js";
+const URL_PREFIX = "https://raw.githubusercontent.com/complete-ts/complete/main/packages/complete-cli/file-templates";
+export class CheckCommand extends Command {
+    static paths = [["check"], ["c"]];
+    ignore = Option.String("-i,--ignore", {
+        description: "Comma separated list of file names to ignore.",
+    });
+    verbose = Option.Boolean("-v,--verbose", false, {
+        description: "Enable verbose output.",
+    });
+    static usage = Command.Usage({
+        description: "Check the template files of the current TypeScript project to see if they are up to date.",
+    });
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async execute() {
+        let oneOrMoreErrors = false;
+        const ignore = this.ignore ?? "";
+        const ignoreFileNames = ignore.split(",");
+        const ignoreFileNamesSet = new ReadonlySet(ignoreFileNames);
+        // First, check the static files.
+        if (checkTemplateDirectory(TEMPLATES_STATIC_DIR, ignoreFileNamesSet, this.verbose)) {
+            oneOrMoreErrors = true;
+        }
+        // Second, check dynamic files that require specific logic.
+        if (checkIndividualFiles(ignoreFileNamesSet, this.verbose)) {
+            oneOrMoreErrors = true;
+        }
+        if (oneOrMoreErrors) {
+            fatalError("The check command failed.");
+        }
+    }
+}
+function checkTemplateDirectory(templateDirectory, ignoreFileNamesSet, verbose) {
+    let oneOrMoreErrors = false;
+    for (const klawItem of klawSync(templateDirectory)) {
+        const templateFilePath = klawItem.path;
+        if (isDirectory(templateFilePath)) {
+            continue;
+        }
+        const originalFileName = path.basename(templateFilePath);
+        if (originalFileName === "main.ts") {
+            continue;
+        }
+        const relativeTemplateFilePath = path.relative(templateDirectory, templateFilePath);
+        const templateFileName = path.basename(relativeTemplateFilePath);
+        let projectFilePath = path.join(CWD, relativeTemplateFilePath);
+        switch (templateFileName) {
+            case "_cspell.config.jsonc": {
+                projectFilePath = path.join(projectFilePath, "..", "cspell.config.jsonc");
+                break;
+            }
+            case "_gitattributes": {
+                projectFilePath = path.join(projectFilePath, "..", ".gitattributes");
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        const projectFileName = path.basename(projectFilePath);
+        if (ignoreFileNamesSet.has(projectFileName)) {
+            continue;
+        }
+        if (!compareTextFiles(projectFilePath, templateFilePath, verbose)) {
+            oneOrMoreErrors = true;
+        }
+    }
+    return oneOrMoreErrors;
+}
+function checkIndividualFiles(ignoreFileNamesSet, verbose) {
+    let oneOrMoreErrors = false;
+    if (!ignoreFileNamesSet.has(ACTION_YML)) {
+        const templateFilePath = ACTION_YML_TEMPLATE_PATH;
+        const relativeTemplateFilePath = path.relative(TEMPLATES_DYNAMIC_DIR, templateFilePath);
+        const projectFilePath = path.join(CWD, relativeTemplateFilePath);
+        if (!compareTextFiles(projectFilePath, templateFilePath, verbose)) {
+            oneOrMoreErrors = true;
+        }
+    }
+    return oneOrMoreErrors;
+}
+/** @returns Whether the project file is valid in reference to the template file. */
+function compareTextFiles(projectFilePath, templateFilePath, verbose) {
+    if (!isFile(projectFilePath)) {
+        console.log(`Failed to find the following file: ${projectFilePath}`);
+        printTemplateLocation(templateFilePath);
+        return false;
+    }
+    const projectFileObject = getTruncatedFileText(projectFilePath, new Set(), new Set());
+    const templateFileObject = getTruncatedFileText(templateFilePath, projectFileObject.ignoreLines, projectFileObject.linesBeforeIgnore);
+    if (projectFileObject.text === templateFileObject.text) {
+        return true;
+    }
+    console.log(`The contents of the following file do not match: ${chalk.red(projectFilePath)}`);
+    printTemplateLocation(templateFilePath);
+    if (verbose) {
+        const originalTemplateFile = readFile(templateFilePath);
+        const originalProjectFile = readFile(projectFilePath);
+        console.log("--- Original template file: ---\n");
+        console.log(originalTemplateFile);
+        console.log();
+        console.log("--- Original project file: ---\n");
+        console.log(originalProjectFile);
+        console.log();
+        console.log("--- Parsed template file: ---\n");
+        console.log(templateFileObject.text);
+        console.log();
+        console.log("--- Parsed project file: ---\n");
+        console.log(projectFileObject.text);
+        console.log();
+    }
+    const tempProjectFilePath = path.join(CWD, "tempProjectFile.txt");
+    const tempTemplateFilePath = path.join(CWD, "tempTemplateFile.txt");
+    writeFile(tempProjectFilePath, projectFileObject.text);
+    writeFile(tempTemplateFilePath, templateFileObject.text);
+    $s `diff ${tempProjectFilePath} ${tempTemplateFilePath} --ignore-blank-lines`;
+    deleteFileOrDirectory(tempProjectFilePath);
+    deleteFileOrDirectory(tempTemplateFilePath);
+    return false;
+}
+function getTruncatedFileText(filePath, ignoreLines, linesBeforeIgnore) {
+    const fileName = path.basename(filePath);
+    const fileContents = readFile(filePath);
+    return getTruncatedText(fileName, fileContents, ignoreLines, linesBeforeIgnore);
+}
+function printTemplateLocation(templateFilePath) {
+    const unixPath = templateFilePath.split(path.sep).join(path.posix.sep);
+    const match = unixPath.match(/.+\/file-templates\/(?<urlSuffix>.+)/);
+    if (match === null || match.groups === undefined) {
+        fatalError(`Failed to parse the template file path: ${templateFilePath}`);
+    }
+    const { urlSuffix } = match.groups;
+    console.log(`You can find the template at: ${chalk.green(`${URL_PREFIX}/${urlSuffix}`)}\n`);
+}

package/dist/commands/InitCommand.js

@@ -0,0 +1,64 @@
+import { Command, Option } from "clipanion";
+import path from "node:path";
+import { promptGitHubRepoOrGitRemoteURL } from "../git.js";
+import { promptEnd, promptStart } from "../prompt.js";
+import { checkIfProjectPathExists } from "./init/checkIfProjectPathExists.js";
+import { createProject } from "./init/createProject.js";
+import { getAuthorName } from "./init/getAuthorName.js";
+import { getProjectPath } from "./init/getProjectPath.js";
+import { getPackageManagerUsedForNewProject } from "./init/packageManager.js";
+import { vsCodeInit } from "./init/vsCodeInit.js";
+export class InitCommand extends Command {
+    static paths = [["init"], ["i"]];
+    // The first positional argument.
+    name = Option.String({
+        required: false,
+    });
+    yes = Option.Boolean("-y,--yes", false, {
+        description: 'Answer yes to every dialog option, similar to how "npm init --yes" works.',
+    });
+    useCurrentDirectory = Option.Boolean("--use-current-directory", false, {
+        description: "Use the current directory as the root for the project.",
+    });
+    customDirectory = Option.String("--custom-directory", {
+        description: "Initialize the project into the specified directory (instead of creating a new one based on the name or using the current working directory).",
+    });
+    vsCode = Option.Boolean("--vscode", false, {
+        description: "Open the project in VSCode after initialization.",
+    });
+    npm = Option.Boolean("--npm", false, {
+        description: "Use npm as the package manager.",
+    });
+    yarn = Option.Boolean("--yarn", false, {
+        description: "Use yarn as the package manager.",
+    });
+    pnpm = Option.Boolean("--pnpm", false, {
+        description: "Use pnpm as the package manager.",
+    });
+    skipGit = Option.Boolean("--skip-git", false, {
+        description: "Do not initialize Git.",
+    });
+    skipInstall = Option.Boolean("--skip-install", false, {
+        description: "Do not automatically install the dependencies after initializing the project.",
+    });
+    forceName = Option.Boolean("-f,--force-name", false, {
+        description: "Allow project names that are normally illegal.",
+    });
+    static usage = Command.Usage({
+        description: "Initialize a new TypeScript project.",
+    });
+    async execute() {
+        promptStart();
+        const packageManager = getPackageManagerUsedForNewProject(this);
+        // Prompt the end-user for some information (and validate it as we go).
+        const { projectPath, createNewDir } = await getProjectPath(this.name, this.useCurrentDirectory, this.customDirectory, this.yes, this.forceName);
+        await checkIfProjectPathExists(projectPath, this.yes);
+        const projectName = path.basename(projectPath);
+        const authorName = await getAuthorName();
+        const gitRemoteURL = await promptGitHubRepoOrGitRemoteURL(projectName, this.yes, this.skipGit);
+        // Now that we have asked the user all of the questions we need, we can create the project.
+        await createProject(projectName, authorName, projectPath, createNewDir, gitRemoteURL, this.skipInstall, packageManager);
+        await vsCodeInit(projectPath, this.vsCode, this.yes);
+        promptEnd("Initialization completed.");
+    }
+}

package/dist/commands/NukeCommand.js

@@ -0,0 +1,13 @@
+import { Command } from "clipanion";
+import { nukeDependencies } from "complete-node";
+export class NukeCommand extends Command {
+    static paths = [["nuke"], ["n"]];
+    static usage = Command.Usage({
+        description: 'Delete the "node_modules" directory and the package lock file, then reinstall the dependencies for the project.',
+    });
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async execute() {
+        nukeDependencies();
+        console.log("Successfully reinstalled dependencies from npm.");
+    }
+}

package/dist/commands/PublishCommand.js

@@ -0,0 +1,158 @@
+import { Command, Option } from "clipanion";
+import { isSemanticVersion } from "complete-common";
+import { $, $s, fatalError, getPackageJSONField, getPackageJSONVersion, getPackageManagerInstallCommand, getPackageManagerLockFileName, getPackageManagersForProject, isFile, isGitRepository, isGitRepositoryClean, isLoggedInToNPM, readFile, updatePackageJSONDependencies, writeFile, } from "complete-node";
+import path from "node:path";
+import { CWD, DEFAULT_PACKAGE_MANAGER } from "../constants.js";
+export class PublishCommand extends Command {
+    static paths = [["publish"], ["p"]];
+    // The first positional argument.
+    versionBumpType = Option.String({
+        required: true,
+    });
+    dryRun = Option.Boolean("--dry-run", false, {
+        description: "Skip committing/uploading & perform a Git reset afterward.",
+    });
+    skipLint = Option.Boolean("--skip-lint", false, {
+        description: "Skip linting before publishing.",
+    });
+    skipUpdate = Option.Boolean("--skip-update", false, {
+        description: "Skip updating the npm dependencies.",
+    });
+    static usage = Command.Usage({
+        description: "Bump the version & publish a new release.",
+    });
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async execute() {
+        validate();
+        prePublish(this.versionBumpType, this.dryRun, this.skipLint, this.skipUpdate);
+        publish(this.dryRun);
+    }
+}
+function validate() {
+    if (!isGitRepository(CWD)) {
+        fatalError("Failed to publish since the current working directory is not inside of a git repository.");
+    }
+    if (!isGitRepositoryClean(CWD)) {
+        fatalError("Failed to publish since the Git repository was dirty. Before publishing, you must push any current changes to git. (Version commits should not contain any code changes.)");
+    }
+    if (!isFile("package.json")) {
+        fatalError('Failed to find the "package.json" file in the current working directory.');
+    }
+    if (!isLoggedInToNPM()) {
+        fatalError('Failed to publish since you are not logged in to npm. Try doing "npm login".');
+    }
+}
+/**
+ * Before uploading the project, we want to update dependencies, increment the version, and perform
+ * some other steps.
+ */
+function prePublish(versionBumpType, dryRun, skipLint, skipUpdate) {
+    const packageManager = getPackageManagerUsedForExistingProject();
+    $s `git pull --rebase`;
+    $s `git push`;
+    updateDependencies(skipUpdate, dryRun, packageManager);
+    incrementVersion(versionBumpType);
+    unsetDevelopmentConstants();
+    tryRunNPMScript("build");
+    if (!skipLint) {
+        tryRunNPMScript("lint");
+    }
+}
+function getPackageManagerUsedForExistingProject() {
+    const packageManagers = getPackageManagersForProject(CWD);
+    if (packageManagers.length > 1) {
+        const packageManagerLockFileNames = packageManagers
+            .map((packageManager) => getPackageManagerLockFileName(packageManager))
+            .map((packageManagerLockFileName) => `"${packageManagerLockFileName}"`)
+            .join(" & ");
+        fatalError(`Multiple different kinds of package manager lock files were found (${packageManagerLockFileNames}). You should delete the ones that you are not using so that this program can correctly detect your package manager.`);
+    }
+    const packageManager = packageManagers[0];
+    if (packageManager !== undefined) {
+        return packageManager;
+    }
+    return DEFAULT_PACKAGE_MANAGER;
+}
+function updateDependencies(skipUpdate, dryRun, packageManager) {
+    if (skipUpdate) {
+        return;
+    }
+    console.log('Updating dependencies in the "package.json" file...');
+    const hasNewDependencies = updatePackageJSONDependencies(undefined);
+    if (hasNewDependencies) {
+        const command = getPackageManagerInstallCommand(packageManager);
+        const commandParts = command.split(" ");
+        $s `${commandParts}`;
+        if (!dryRun) {
+            gitCommitAllAndPush("chore: update dependencies");
+        }
+    }
+}
+function gitCommitAllAndPush(message) {
+    $s `git add --all`;
+    $s `git commit --message ${message}`;
+    $s `git push`;
+    console.log(`Committed and pushed to the git repository with a message of: ${message}`);
+}
+function incrementVersion(versionBumpType) {
+    if (versionBumpType === "none") {
+        return;
+    }
+    if (versionBumpType === "dev") {
+        throw new Error('The version bump type of "dev" is not currently supported.');
+    }
+    if (versionBumpType !== "major" &&
+        versionBumpType !== "minor" &&
+        versionBumpType !== "patch" &&
+        versionBumpType !== "dev" &&
+        !isSemanticVersion(versionBumpType)) {
+        fatalError('The version must be one of "major", "minor", "patch", "dev", "none", or a specific semantic version like "1.2.3".');
+    }
+    // We always use `npm` here to avoid differences with the version command between package
+    // managers. The "--no-git-tag-version" flag will prevent npm from both making a commit and adding
+    // a tag.
+    $s `npm version ${versionBumpType} --no-git-tag-version`;
+}
+function unsetDevelopmentConstants() {
+    const constantsTSPath = path.join(CWD, "src", "constants.ts");
+    if (!isFile(constantsTSPath)) {
+        return;
+    }
+    const constantsTS = readFile(constantsTSPath);
+    const newConstantsTS = constantsTS
+        .replace("const IS_DEV = true", "const IS_DEV = false")
+        .replace("const DEBUG = true", "const DEBUG = false");
+    writeFile(constantsTSPath, newConstantsTS);
+}
+function tryRunNPMScript(scriptName) {
+    console.log(`Running: ${scriptName}`);
+    const $$ = $({
+        reject: false,
+    });
+    const { exitCode } = $$.sync `npm run ${scriptName}`;
+    if (exitCode !== 0) {
+        $s `git reset --hard`; // Revert the version changes.
+        fatalError(`Failed to run "${scriptName}".`);
+    }
+}
+function publish(dryRun) {
+    const projectName = getPackageJSONField(undefined, "name");
+    const version = getPackageJSONVersion(undefined);
+    if (dryRun) {
+        $s `git reset --hard`; // Revert the version changes.
+    }
+    else {
+        const releaseGitCommitMessage = getReleaseGitCommitMessage(version);
+        gitCommitAllAndPush(releaseGitCommitMessage);
+        // - The "--access=public" flag is only technically needed for the first publish (unless the
+        //   package is a scoped package), but it is saved here for posterity.
+        // - The "--ignore-scripts" flag is needed since the "npm publish" command will run the
+        //   "publish" script in the "package.json" file, causing an infinite loop.
+        $s `npm publish --access=public --ignore-scripts`;
+    }
+    const dryRunSuffix = dryRun ? " (dry-run)" : "";
+    console.log(`Published ${projectName} version ${version} successfully${dryRunSuffix}.`);
+}
+function getReleaseGitCommitMessage(version) {
+    return `chore: release ${version}`;
+}

package/dist/commands/UpdateCommand.js

@@ -0,0 +1,16 @@
+import { Command } from "clipanion";
+import { updatePackageJSONDependencies } from "complete-node";
+export class UpdateCommand extends Command {
+    static paths = [["update"], ["u"]];
+    static usage = Command.Usage({
+        description: 'Invoke "npm-check-updates" to update the dependencies inside of the "package.json" file and then install them.',
+    });
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async execute() {
+        const hasNewDependencies = updatePackageJSONDependencies();
+        const msg = hasNewDependencies
+            ? "Successfully installed new Node.js dependencies."
+            : "There were no new dependency updates from npm.";
+        console.log(msg);
+    }
+}

package/dist/commands/check/check.test.js

@@ -0,0 +1,86 @@
+import { strictEqual } from "node:assert";
+import test from "node:test";
+import { getTruncatedText } from "./getTruncatedText.js";
+test("no markers", () => {
+    const templateText = `
+line 1
+line 2
+line 3
+`.trim();
+    const { text } = getTruncatedText("test", templateText, new Set(), new Set());
+    strictEqual(text, templateText);
+});
+test("customization marker", () => {
+    const templateText = `
+line 1
+@template-customization-start
+line 2
+@template-customization-end
+line 3
+  `.trim();
+    const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+    const { text } = getTruncatedText("test", templateText, new Set(), new Set());
+    strictEqual(text, expectedTemplateText);
+});
+test("ignore block marker part 1", () => {
+    const templateText = `
+line 1
+@template-ignore-block-start
+// line 2
+@template-ignore-block-end
+line 3
+  `.trim();
+    const parsedTemplateText = `
+line 1
+line 3
+  `.trim();
+    const { text, ignoreLines } = getTruncatedText("test", templateText, new Set(), new Set());
+    strictEqual(text, parsedTemplateText);
+    strictEqual(ignoreLines.size, 1);
+    strictEqual([...ignoreLines][0], "line 2");
+});
+test("ignore block marker part 2", () => {
+    const templateText = `
+line 1
+line 2
+line 3
+  `.trim();
+    const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+    const { text } = getTruncatedText("test", templateText, new Set(["line 2"]), new Set());
+    strictEqual(text, expectedTemplateText);
+});
+test("ignore next line part 1", () => {
+    const templateText = `
+line 1
+@template-ignore-next-line
+line 2
+line 3
+  `.trim();
+    const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+    const { text, linesBeforeIgnore } = getTruncatedText("test", templateText, new Set(), new Set());
+    strictEqual(linesBeforeIgnore.size, 1);
+    strictEqual([...linesBeforeIgnore][0], "line 1");
+    strictEqual(text, expectedTemplateText);
+});
+test("ignore next line part 2", () => {
+    const templateText = `
+line 1
+line 2
+line 3
+  `.trim();
+    const expectedTemplateText = `
+line 1
+line 3
+  `.trim();
+    const { text } = getTruncatedText("test", templateText, new Set(), new Set(["line 1"]));
+    strictEqual(text, expectedTemplateText);
+});

package/dist/commands/check/getTruncatedText.js

@@ -0,0 +1,139 @@
+import { getEnumValues, trimPrefix } from "complete-common";
+import { fatalError, getPackageManagerLockFileNames, PackageManager, } from "complete-node";
+const MARKER_CUSTOMIZATION_START = "@template-customization-start";
+const MARKER_CUSTOMIZATION_END = "@template-customization-end";
+const MARKER_IGNORE_BLOCK_START = "@template-ignore-block-start";
+const MARKER_IGNORE_BLOCK_END = "@template-ignore-block-end";
+const MARKER_IGNORE_NEXT_LINE = "@template-ignore-next-line";
+const PACKAGE_MANAGER_STRINGS = [
+    "PACKAGE_MANAGER_NAME",
+    "PACKAGE_MANAGER_INSTALL_COMMAND",
+    "PACKAGE_MANAGER_LOCK_FILE_NAME",
+    ...getEnumValues(PackageManager),
+    ...getPackageManagerLockFileNames(),
+];
+/**
+ * @param fileName Used to perform some specific rules based on the template file name.
+ * @param text The text to parse.
+ * @param ignoreLines A set of lines to remove from the text.
+ * @param linesBeforeIgnore A set of lines that will trigger the subsequent line to be ignored.
+ * @returns The text of the file with all text removed between any flagged markers (and other
+ *          specific hard-coded exclusions), as well as an array of lines that had a
+ *          "ignore-next-line" marker below them.
+ */
+export function getTruncatedText(fileName, text, ignoreLines, linesBeforeIgnore) {
+    const lines = text.split("\n");
+    const newLines = [];
+    const newIgnoreLines = new Set();
+    const newLinesBeforeIgnore = new Set();
+    let isSkipping = false;
+    let isIgnoring = false;
+    let shouldIgnoreNextLine = false;
+    let previousLine = "";
+    for (const line of lines) {
+        if (line.trim() === "") {
+            continue;
+        }
+        if (ignoreLines.has(line.trim())) {
+            continue;
+        }
+        if (shouldIgnoreNextLine) {
+            shouldIgnoreNextLine = false;
+            continue;
+        }
+        if (linesBeforeIgnore.has(line)) {
+            shouldIgnoreNextLine = true;
+        }
+        // -------------
+        // Marker checks
+        // -------------
+        if (line.includes(MARKER_CUSTOMIZATION_START)) {
+            isSkipping = true;
+            continue;
+        }
+        if (line.includes(MARKER_CUSTOMIZATION_END)) {
+            isSkipping = false;
+            continue;
+        }
+        if (line.includes(MARKER_IGNORE_BLOCK_START)) {
+            isIgnoring = true;
+            continue;
+        }
+        if (line.includes(MARKER_IGNORE_BLOCK_END)) {
+            isIgnoring = false;
+            continue;
+        }
+        if (line.includes(MARKER_IGNORE_NEXT_LINE)) {
+            shouldIgnoreNextLine = true;
+            // We mark the previous line so that we know the next line to skip in the template.
+            if (previousLine.trim() === "") {
+                fatalError(`You cannot have a "${MARKER_IGNORE_NEXT_LINE}" marker before a blank line in the "${fileName}" file.`);
+            }
+            newLinesBeforeIgnore.add(previousLine);
+            continue;
+        }
+        if (isIgnoring) {
+            const baseLine = trimPrefix(line.trim(), "// ");
+            newIgnoreLines.add(baseLine);
+            continue;
+        }
+        // --------------------
+        // Specific file checks
+        // --------------------
+        // We should ignore imports in JavaScript or TypeScript files.
+        if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
+            if (line === "import {") {
+                isSkipping = true;
+                continue;
+            }
+            if (line.startsWith("} from ")) {
+                isSkipping = false;
+                continue;
+            }
+            if (line.startsWith("import ")) {
+                continue;
+            }
+        }
+        // End-users can have different ignored words.
+        if (fileName === "cspell.config.jsonc" ||
+            fileName === "_cspell.config.jsonc") {
+            if (line.match(/"words": \[.*]/) !== null) {
+                continue;
+            }
+            if (line.includes('"words": [')) {
+                isSkipping = true;
+                continue;
+            }
+            if ((line.endsWith("]") || line.endsWith("],")) && isSkipping) {
+                isSkipping = false;
+                continue;
+            }
+        }
+        if (fileName === "ci.yml" || fileName === "action.yml") {
+            // End-users can have different package managers.
+            if (hasPackageManagerString(line)) {
+                continue;
+            }
+            // Ignore comments, since end-users are expected to delete the explanations.
+            if (line.match(/^\s*#/) !== null) {
+                continue;
+            }
+        }
+        // ------------
+        // Final checks
+        // ------------
+        if (!isSkipping) {
+            newLines.push(line);
+            previousLine = line;
+        }
+    }
+    const newText = newLines.join("\n");
+    return {
+        text: newText,
+        ignoreLines: newIgnoreLines,
+        linesBeforeIgnore: newLinesBeforeIgnore,
+    };
+}
+function hasPackageManagerString(line) {
+    return PACKAGE_MANAGER_STRINGS.some((string) => line.includes(string));
+}

package/dist/commands/init/checkIfProjectPathExists.js

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+import { deleteFileOrDirectory, fileOrDirectoryExists, isDirectory, } from "complete-node";
+import { CWD } from "../../constants.js";
+import { getInputYesNo, promptEnd, promptLog } from "../../prompt.js";
+export async function checkIfProjectPathExists(projectPath, yes) {
+    if (projectPath === CWD || !fileOrDirectoryExists(projectPath)) {
+        return;
+    }
+    const fileType = isDirectory(projectPath) ? "directory" : "file";
+    if (yes) {
+        deleteFileOrDirectory(projectPath);
+        promptLog(`Deleted ${fileType}: ${chalk.green(projectPath)}`);
+        return;
+    }
+    promptLog(`A ${fileType} already exists with a name of: ${chalk.green(projectPath)}`);
+    const shouldDelete = await getInputYesNo("Do you want me to delete it?");
+    if (!shouldDelete) {
+        promptEnd("Ok then. Goodbye.");
+    }
+    deleteFileOrDirectory(projectPath);
+}