complete-cli 1.0.5 → 1.0.7

package/dist/commands/CheckCommand.js

@@ -0,0 +1,141 @@
+import chalk from "chalk";
+import { Command, Option } from "clipanion";
+import { ReadonlySet } from "complete-common";
+import { $, 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);
+    $.sync `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 = await 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,12 @@
+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.',
+    });
+    async execute() {
+        await nukeDependencies();
+        console.log("Successfully reinstalled dependencies from npm.");
+    }
+}

package/dist/commands/PublishCommand.js

@@ -0,0 +1,162 @@
+import { Command, Option } from "clipanion";
+import { isSemanticVersion } from "complete-common";
+import { $, fatalError, getPackageJSONField, getPackageJSONVersion, getPackageManagerInstallCommand, getPackageManagerLockFileName, getPackageManagersForProject, isFileAsync, isGitRepository, isGitRepositoryClean, isLoggedInToNPM, readFile, updatePackageJSONDependencies, writeFileAsync, } 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.",
+    });
+    async execute() {
+        await validate();
+        await prePublish(this.versionBumpType, this.dryRun, this.skipLint, this.skipUpdate);
+        await publish(this.dryRun);
+    }
+}
+async function validate() {
+    const isRepository = await isGitRepository(CWD);
+    if (!isRepository) {
+        fatalError("Failed to publish since the current working directory is not inside of a git repository.");
+    }
+    const isRepositoryClean = await isGitRepositoryClean(CWD);
+    if (!isRepositoryClean) {
+        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.)");
+    }
+    const packageJSONExists = await isFileAsync("package.json");
+    if (!packageJSONExists) {
+        fatalError('Failed to find the "package.json" file in the current working directory.');
+    }
+    const isLoggedIn = await isLoggedInToNPM();
+    if (!isLoggedIn) {
+        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.
+ */
+async function prePublish(versionBumpType, dryRun, skipLint, skipUpdate) {
+    const packageManager = await getPackageManagerUsedForExistingProject();
+    await $ `git pull --rebase`;
+    await $ `git push`;
+    await updateDependencies(skipUpdate, dryRun, packageManager);
+    await incrementVersion(versionBumpType);
+    await unsetDevelopmentConstants();
+    await tryRunNPMScript("build");
+    if (!skipLint) {
+        await tryRunNPMScript("lint");
+    }
+}
+async function getPackageManagerUsedForExistingProject() {
+    const packageManagers = await 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;
+}
+async function updateDependencies(skipUpdate, dryRun, packageManager) {
+    if (skipUpdate) {
+        return;
+    }
+    console.log('Updating dependencies in the "package.json" file...');
+    const hasNewDependencies = await updatePackageJSONDependencies(undefined);
+    if (hasNewDependencies) {
+        const command = getPackageManagerInstallCommand(packageManager);
+        const commandParts = command.split(" ");
+        await $ `${commandParts}`;
+        if (!dryRun) {
+            await gitCommitAllAndPush("chore: update dependencies");
+        }
+    }
+}
+async function gitCommitAllAndPush(message) {
+    await $ `git add --all`;
+    await $ `git commit --message ${message}`;
+    await $ `git push`;
+    console.log(`Committed and pushed to the git repository with a message of: ${message}`);
+}
+async 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.
+    await $ `npm version ${versionBumpType} --no-git-tag-version`;
+}
+async function unsetDevelopmentConstants() {
+    const constantsTSPath = path.join(CWD, "src", "constants.ts");
+    const constantsTSExists = await isFileAsync(constantsTSPath);
+    if (!constantsTSExists) {
+        return;
+    }
+    const constantsTS = readFile(constantsTSPath);
+    const newConstantsTS = constantsTS
+        .replace("const IS_DEV = true", "const IS_DEV = false")
+        .replace("const DEBUG = true", "const DEBUG = false");
+    await writeFileAsync(constantsTSPath, newConstantsTS);
+}
+async function tryRunNPMScript(scriptName) {
+    console.log(`Running: ${scriptName}`);
+    const $$ = $({
+        reject: false,
+    });
+    const { exitCode } = await $$ `npm run ${scriptName}`;
+    if (exitCode !== 0) {
+        await $ `git reset --hard`; // Revert the version changes.
+        fatalError(`Failed to run "${scriptName}".`);
+    }
+}
+async function publish(dryRun) {
+    const projectName = getPackageJSONField(undefined, "name");
+    const version = getPackageJSONVersion(undefined);
+    if (dryRun) {
+        await $ `git reset --hard`; // Revert the version changes.
+    }
+    else {
+        const releaseGitCommitMessage = getReleaseGitCommitMessage(version);
+        await 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.
+        await $ `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,15 @@
+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.',
+    });
+    async execute() {
+        const hasNewDependencies = await 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);
+}