comment-variables 0.0.5 → 0.2.0

package/comments.config.js

@@ -1,6 +1,5 @@
-import { test } from "./import.js";
-
 const config = {
+  // for testing
   levelOne: {
     levelTwo: {
       levelThree: "Level three.",
@@ -11,14 +10,24 @@ const config = {
       levelThreeAlso: "Also level three here.",
       levelThreeToo: "This too is level three.",
       // test: "LEVELONE#LEVELTWO#LEVELTHREE", // errors
-      [`level$Three#First
-        whitespace`]: `This is level three
-      with whitespaces. `,
-      testing: 2,
+      // [`level$Three#First
+      //   whitespace`]: `This is level three
+      // with whitespaces. `, // fails
+      // testing: 2, // fails
+      // ".'e": "",
     },
   },
+  // for deving
+  jsDoc: {
+    exitDueToFailure: "Terminates the whole process with a 'failure' code (1).",
+  },
 };
 
-export default config;
+// export default config;
+
+const trueConfig = {
+  data: config,
+  ignores: ["chocolat.js"],
+};
 
-// This too is level three.
+export default trueConfig;

package/library/_commons/constants/bases.js

@@ -0,0 +1,77 @@
+import fs from "fs";
+import path from "path";
+
+import tseslint from "typescript-eslint";
+
+// plugin name
+export const commentVariablesPluginName = "comment-variables";
+
+// rule names
+export const resolveRuleName = "resolve";
+export const compressRuleName = "compress";
+
+// current working directory
+export const cwd = process.cwd();
+
+// to prevent accidental changes
+export const hasPackageJson = fs.existsSync(path.join(cwd, "package.json"));
+// to prevent irreversible changes
+export const hasGitFolder = fs.existsSync(path.join(cwd, ".git"));
+
+// comments.config.js
+export const defaultConfigFileName = "comments.config.js";
+
+// flags
+export const configFlag = "--config";
+export const lintConfigImportsFlag = "--lint-config-imports";
+export const myIgnoresOnlyFlag = "--my-ignores-only";
+
+// ESLint ignores
+export const knownIgnores = [
+  ".next",
+  ".react-router",
+  "node_modules",
+  ".parcel-cache",
+  ".react-router-parcel",
+  "dist",
+];
+
+// ESLint file globs
+export const allJSTSFileGlobs = [
+  "**/*.js",
+  "**/*.jsx",
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.mjs",
+  "**/*.cjs",
+];
+export const allMDFileGlobs = ["**/*.md"];
+export const allMDVirtualJSTSFileGlobs = [
+  "**/*.md/*.js",
+  "**/*.md/*.jsx",
+  "**/*.md/*.ts",
+  "**/*.md/*.tsx",
+  "**/*.md/*.cjs",
+  "**/*.md/*.mjs",
+];
+
+// default ESLint config language options
+export const typeScriptAndJSXCompatible = {
+  // for compatibility with TypeScript (.ts and .tsx)
+  parser: tseslint.parser,
+  // for compatibility with JSX (React, etc.)
+  parserOptions: {
+    ecmaFeatures: {
+      jsx: true,
+    },
+  },
+};
+
+// messageId
+export const placeholderMessageId = "placeholderMessageId";
+
+// regexes
+export const configKeyRegex = /^[\p{Ll}\p{Lu}\p{Lo}\p{Pd}\p{Pc}\p{N}\s]+$/u;
+export const flattenedConfigKeyRegex = /^[\p{Lu}\p{Lo}\p{Pd}\p{Pc}\p{N}#]+$/u; // same as configKeyRegex but without lowercase letters (\p{Ll}), without whitespaces (\s which are replaced by underscores) and with the '#' character (that links each subkey together)
+export const flattenedConfigPlaceholderRegex =
+  /\$COMMENT#([\p{Lu}\p{Lo}\p{Pd}\p{Pc}\p{N}_#]+)/gu; // same as flattenedConfigKeyRegex but taking the prefix $COMMENT# into consideration, removing ^ and $ in the capture group, globally

package/library/_commons/rules/compress.js

@@ -0,0 +1,78 @@
+import { placeholderMessageId } from "../constants/bases.js";
+
+import { escapeRegex } from "..//utilities/helpers.js";
+
+/**
+ *
+ * @param {{[key: string]: string}} reversedFlattenedConfig
+ * @returns
+ */
+const makeRule = (reversedFlattenedConfig) => {
+  // Turns the whole reversedFlattenedConfig from an object to an array of key-value arrays sorted by the descending length of each key to prevent partial replacements.
+  const sortedReversedFlattenedConfig = Object.entries(
+    reversedFlattenedConfig
+  ).sort(([a], [b]) => b.length - a.length);
+
+  /** @type {import('@typescript-eslint/utils').TSESLint.RuleModule<string, []>} */
+  const rule = {
+    meta: {
+      type: "suggestion",
+      docs: {
+        description:
+          "Compresses comments into $COMMENT#* placeholder(s) in comment line(s) or block(s).",
+      },
+      messages: {
+        [placeholderMessageId]:
+          "Compressed comments into $COMMENT#* placeholder(s) in comment line(s) or block(s).",
+      },
+      fixable: "code",
+      schema: [],
+    },
+    create(context) {
+      const sourceCode = context.sourceCode;
+      const comments = sourceCode
+        .getAllComments()
+        .filter((e) => e.type !== "Shebang");
+
+      for (const comment of comments) {
+        let fixedText = comment.value;
+        let modified = false;
+
+        for (const [
+          resolvedValue,
+          commentKey,
+        ] of sortedReversedFlattenedConfig) {
+          const pattern = new RegExp(
+            `(?<=\\s|^)${escapeRegex(resolvedValue)}(?=\\s|$)`,
+            "g"
+          );
+
+          fixedText = fixedText.replace(pattern, () => {
+            modified = true;
+            return `$COMMENT#${commentKey}`;
+          });
+        }
+
+        if (modified && fixedText !== comment.value) {
+          context.report({
+            loc: comment.loc,
+            messageId: placeholderMessageId,
+            fix(fixer) {
+              const fullCommentText =
+                comment.type === "Block"
+                  ? `/*${fixedText}*/`
+                  : `//${fixedText}`;
+              return fixer.replaceText(comment, fullCommentText);
+            },
+          });
+        }
+      }
+
+      return {};
+    },
+  };
+
+  return rule;
+};
+
+export default makeRule; // compress

package/library/_commons/rules/resolve.js

@@ -0,0 +1,77 @@
+import {
+  placeholderMessageId,
+  flattenedConfigPlaceholderRegex,
+} from "../constants/bases.js";
+
+/**
+ *
+ * @param {{[key: string]: string}} flattenedConfig
+ * @returns
+ */
+const makeRule = (flattenedConfig) => {
+  /** @type {import('@typescript-eslint/utils').TSESLint.RuleModule<string, []>} */
+  const rule = {
+    meta: {
+      type: "suggestion",
+      docs: {
+        description:
+          "Resolves $COMMENT#* placeholder(s) in comment line(s) or block(s).",
+      },
+      messages: {
+        [placeholderMessageId]:
+          "Resolved $COMMENT#* placeholder(s) in comment line(s) or block(s).",
+      },
+      fixable: "code",
+      schema: [],
+    },
+    create: (context) => {
+      const sourceCode = context.sourceCode;
+      const comments = sourceCode
+        .getAllComments()
+        .filter((e) => e.type !== "Shebang");
+
+      for (const comment of comments) {
+        const matches = [
+          ...comment.value.matchAll(flattenedConfigPlaceholderRegex),
+        ];
+
+        if (matches.length === 0) continue;
+
+        let fixedText = comment.value;
+        let hasValidFix = false;
+
+        for (const match of matches) {
+          const fullMatch = match[0]; // e.g. $COMMENT#LEVELONE#LEVELTWO
+          const key = match[1]; // e.g. LEVELONE#LEVELTWO
+          const replacement = flattenedConfig[key];
+
+          if (replacement) {
+            fixedText = fixedText.replace(fullMatch, replacement);
+            hasValidFix = true;
+          }
+        }
+
+        if (hasValidFix && fixedText !== comment.value) {
+          context.report({
+            loc: comment.loc,
+            messageId: placeholderMessageId,
+            fix(fixer) {
+              const range = comment.range;
+              const prefix = comment.type === "Block" ? "/*" : "//";
+              const suffix = comment.type === "Block" ? "*/" : "";
+              const newComment = `${prefix}${fixedText}${suffix}`;
+
+              return fixer.replaceTextRange(range, newComment);
+            },
+          });
+        }
+      }
+
+      return {};
+    },
+  };
+
+  return rule;
+};
+
+export default makeRule; // resolve

package/library/_commons/utilities/flows.js

@@ -0,0 +1,102 @@
+import { ESLint } from "eslint";
+import markdown from "@eslint/markdown";
+
+import {
+  commentVariablesPluginName,
+  resolveRuleName,
+  compressRuleName,
+  allJSTSFileGlobs,
+  allMDFileGlobs,
+  allMDVirtualJSTSFileGlobs,
+  typeScriptAndJSXCompatible,
+} from "../constants/bases.js";
+
+import makeResolveRule from "../rules/resolve.js";
+import makeCompressRule from "../rules/compress.js";
+
+const coreCommentsFlow = async (
+  ruleName,
+  ignores,
+  makeCommentsRule,
+  flattenedConfigData
+) => {
+  const eslint = new ESLint({
+    fix: true,
+    errorOnUnmatchedPattern: false,
+    overrideConfigFile: true,
+    overrideConfig: [
+      {
+        files: allJSTSFileGlobs,
+        ignores,
+        languageOptions: typeScriptAndJSXCompatible,
+        plugins: {
+          [commentVariablesPluginName]: {
+            rules: {
+              [ruleName]: makeCommentsRule(flattenedConfigData),
+            },
+          },
+        },
+        rules: {
+          [`${commentVariablesPluginName}/${ruleName}`]: "warn", // doesn't block builds, just applies fix
+        },
+      },
+      {
+        files: allMDFileGlobs,
+        ignores,
+        plugins: { markdown },
+        processor: "markdown/markdown",
+      },
+      {
+        files: allMDVirtualJSTSFileGlobs,
+        ignores,
+        languageOptions: typeScriptAndJSXCompatible,
+        rules: {
+          [`${commentVariablesPluginName}/${ruleName}`]: "warn",
+        },
+      },
+    ],
+  });
+
+  const results = await eslint.lintFiles([
+    ...allJSTSFileGlobs,
+    ...allMDFileGlobs,
+  ]);
+  await ESLint.outputFixes(results);
+
+  console.log({ results });
+
+  const resolvedOrCompressed =
+    ruleName === resolveRuleName
+      ? "Resolved"
+      : ruleName === compressRuleName
+      ? "Compressed"
+      : "Unknown rule name'd";
+
+  const total = results.reduce((sum, r) => {
+    const add = r.output ? 1 : 0;
+    return sum + add;
+  }, 0);
+
+  console.log(
+    `✅ ${resolvedOrCompressed} ${total} comment${total === 1 ? "" : "s"}.`
+  );
+};
+
+export const resolveCommentsFlow = async (ignores, flattenedConfigData) =>
+  coreCommentsFlow(
+    resolveRuleName,
+    ignores,
+    makeResolveRule,
+    flattenedConfigData
+  );
+
+export const compressCommentsFlow = async (
+  ignores,
+  reversedFlattenedConfigData
+) =>
+  coreCommentsFlow(
+    compressRuleName,
+    ignores,
+    makeCompressRule,
+    reversedFlattenedConfigData
+  );

package/library/_commons/utilities/helpers.js

@@ -0,0 +1,15 @@
+/* exitDueToFailure */
+
+/**
+ * Terminates the whole process with a 'failure' code (1).
+ * @returns Never.
+ */
+export const exitDueToFailure = () => process.exit(1);
+
+/**
+ * Escapes all regex characters with a `"\"` in a string to prepare it for use in a regex
+ * @param {string} string The string.
+ * @returns The string with regex characters escaped.
+ */
+export const escapeRegex = (string) =>
+  string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/{run-with-config.js → library/_commons/utilities/run-with-config.js}

@@ -3,14 +3,16 @@ import { pathToFileURL } from "url";
 
 import { z } from "zod";
 
-function flattenConfig(
-  config,
+import { configKeyRegex } from "../constants/bases.js";
+
+function flattenConfigData(
+  configData,
   normalizedPath = "",
   map = {},
   pathStack = [],
-  reversedFlattenedConfig = {}
+  reversedFlattenedConfigData = {}
 ) {
-  for (const [key, value] of Object.entries(config)) {
+  for (const [key, value] of Object.entries(configData)) {
     const currentPath = [...pathStack, key];
     normalizedPath = currentPath
       .map((k) => k.toUpperCase())
@@ -31,18 +33,18 @@ function flattenConfig(
         __source: currentPath.join(" > "), // for debugging
       };
     } else if (typeof value === "object") {
-      flattenConfig(value, normalizedPath, map, currentPath);
+      flattenConfigData(value, normalizedPath, map, currentPath);
     }
   }
 
-  const flattenedConfig = Object.fromEntries(
+  const flattenedConfigData = Object.fromEntries(
     Object.entries(map).map(([k, v]) => [k, v.value])
   ); // strip metadata
 
   const set = new Set();
 
   // the integrity of the config needs to be established before working with it
-  for (const value of Object.values(flattenedConfig)) {
+  for (const value of Object.values(flattenedConfigData)) {
     if (set.has(value)) {
       // checks that no two values are duplicate
       throw new Error(
@@ -52,11 +54,14 @@ function flattenConfig(
     set.add(value);
   }
 
-  for (const [key, value] of Object.entries(flattenedConfig)) {
-    reversedFlattenedConfig[value] = key;
+  for (const [key, value] of Object.entries(flattenedConfigData)) {
+    reversedFlattenedConfigData[value] = key;
   }
 
-  return { flattenedConfig, reversedFlattenedConfig };
+  return {
+    flattenedConfigData,
+    reversedFlattenedConfigData,
+  };
 }
 
 export async function runWithConfig(configPath) {
@@ -71,11 +76,15 @@ export async function runWithConfig(configPath) {
   const config = configModule.default;
 
   // Step 3: Validate config object
-  if (!config || typeof config !== "object") {
-    console.warn("Invalid config format. Exiting.");
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    console.warn(
+      "Invalid config format. The config should be an object. Exiting."
+    );
     return null;
   }
 
+  // data
+
   const RecursiveObject = z
     .lazy(() =>
       z.record(
@@ -121,18 +130,48 @@ export async function runWithConfig(configPath) {
             path: [key],
           });
         }
+        if (!configKeyRegex.test(key)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `Key "${key}" should only include whitespaces (s), lowercase letters (Ll), uppercase letters (Lu), other letters (Lo), numbers (N), dash punctuation (Pd), and connector punctuation (Pc).`,
+            path: [key],
+          });
+        }
       }
     });
 
-  const result = RecursiveObject.safeParse(config);
+  const recursiveObjectResult = RecursiveObject.safeParse(config.data);
+
+  if (!recursiveObjectResult.success) {
+    console.warn("Config data could not pass validation from zod.");
+    recursiveObjectResult.error.errors.map((e) => console.log(e.message));
+    return null;
+  }
+
+  // ignores
+
+  const StringArraySchema = z.array(
+    z.string({
+      message: `The config's "ignores" key array should be made of string or be empty.`,
+    }),
+    {
+      message: `The config's "ignores" key value should be an array of strings (or at the very least an empty array).`,
+    }
+  );
+
+  const stringArraySchemaResult = StringArraySchema.safeParse(config.ignores);
 
-  if (!result.success) {
-    console.warn("Config could not pass validation from zod.");
-    result.error.errors.map((e) => console.log(e.message));
+  if (!stringArraySchemaResult.success) {
+    console.warn("Config ignores could not pass validation from zod.");
+    stringArraySchemaResult.error.errors.map((e) => console.log(e.message));
     return null;
   }
 
   // Step 4: Do your thing
   console.log("Running with config:", config);
-  return { ...flattenConfig(config), configPath };
+  return {
+    ...flattenConfigData(config.data), // finalized
+    configPath, // finalized
+    passedIgnores: config.ignores, // could be treated here eventually
+  };
 }

package/library/index.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// The shebang (#!) is necessary to communicate with Unix-based systems, like Linux and macOS. On Windows, it is ignored, but npm tooling bridges the gap by generating wrappers that make the CLI work anyway.
+
+import path from "path";
+
+import {
+  cwd,
+  hasPackageJson,
+  hasGitFolder,
+  defaultConfigFileName,
+  configFlag,
+  lintConfigImportsFlag,
+  myIgnoresOnlyFlag,
+  knownIgnores,
+} from "./_commons/constants/bases.js";
+
+import { exitDueToFailure } from "./_commons/utilities/helpers.js";
+import { runWithConfig } from "./_commons/utilities/run-with-config.js";
+import { findAllImports } from "./_commons/utilities/find-all-imports.js";
+
+import {
+  resolveCommentsFlow,
+  compressCommentsFlow,
+} from "./_commons/utilities/flows.js";
+
+// ENSURES THE CLI TOOL ONLY RUN IN FOLDERS THAT POSSESS A package.json FILE AND A .git FOLDER.
+
+if (!hasPackageJson) {
+  console.error(
+    "ERROR. No package.json file found in this directory. Aborting to prevent accidental changes."
+  );
+  exitDueToFailure();
+}
+if (!hasGitFolder) {
+  console.error(
+    "ERROR. No git folder found in this directory. Aborting to prevent irreversible changes."
+  );
+  exitDueToFailure();
+}
+
+// GATHERS COMMANDS.
+
+const commands = process.argv;
+
+// OBTAINS THE VALIDATED FLATTENED CONFIG, REVERSE FLATTENED CONFIG, AND CONFIG PATH.
+
+// extracts the position of the --config flag
+const configFlagIndex = commands.indexOf(configFlag);
+// determines if there's a valid config flag input
+const hasConfigFlag = configFlagIndex >= 2;
+// determines if there's an actual config path passed to the config flag
+const passedConfig = commands[configFlagIndex + 1];
+// gets the absolute passed config path if the --config flag is set
+const passedConfigPath =
+  hasConfigFlag && passedConfig ? path.join(cwd, passedConfig) : null;
+// defaults to comments.config.js if no --config flag is set
+const rawConfigPath = passedConfigPath ?? path.join(cwd, defaultConfigFileName);
+
+const results = await runWithConfig(rawConfigPath);
+if (!results) exitDueToFailure();
+
+const {
+  flattenedConfigData,
+  reversedFlattenedConfigData,
+  configPath,
+  passedIgnores,
+} = results;
+
+console.log("Flattened config is:", flattenedConfigData);
+console.log("Reversed flattened config is:", reversedFlattenedConfigData);
+console.log("Config path is:", configPath);
+console.log("Passed ignores are:", passedIgnores);
+
+// VALIDATES THE REVERSABILITY OF THE CONCEIVED flattenedConfigData
+
+const keys = new Set([...Object.keys(flattenedConfigData)]);
+const values = new Set([...Object.values(flattenedConfigData)]);
+
+keys.forEach((key) => {
+  if (values.has(key)) {
+    console.error(
+      `The key "${key}" is and shouldn't be among the values of flattenedConfigData.`
+    );
+    exitDueToFailure();
+  }
+});
+
+// ADDRESSES THE --lint-config-imports FLAG, GIVEN THAT THE FILES IMPORTED BY THE CONFIG ARE IGNORED BY DEFAULT.
+
+const lintConfigImports = commands.indexOf(lintConfigImportsFlag) >= 2;
+const rawConfigPathIgnores = lintConfigImports
+  ? [configPath]
+  : [...findAllImports(configPath)];
+
+// the ignore paths must be relative
+const configPathIgnores = rawConfigPathIgnores.map((e) =>
+  path.relative(cwd, e)
+);
+
+console.log(
+  lintConfigImports ? "Config path ignore is:" : "Config path ignores are:",
+  configPathIgnores
+);
+
+// ADDRESSES THE --my-ignores-only FLAG, GIVEN THAT KNOWN IGNORES ARE IGNORED BY DEFAULT
+
+const myIgnoresOnly = commands.indexOf(myIgnoresOnlyFlag) >= 2;
+const rawIgnores = [...configPathIgnores, ...passedIgnores];
+const ignores = myIgnoresOnly ? rawIgnores : [...rawIgnores, ...knownIgnores];
+
+console.log("Ignores are:", ignores);
+
+// ADDRESSES THE CORE COMMANDS "resolve" AND "compress".
+
+const coreCommand = commands[2];
+
+switch (coreCommand) {
+  case "resolve":
+    await resolveCommentsFlow(ignores, flattenedConfigData);
+    break;
+  case "compress":
+    await compressCommentsFlow(ignores, reversedFlattenedConfigData);
+    break;
+  case undefined: // falls through the default
+  default:
+    if (coreCommand && !coreCommand.startsWith("--"))
+      console.log(
+        `Core command not recognized. Choose between "resolve" and "compress".`
+      );
+    else
+      console.log(
+        `If these settings are correct with you, feel free to initiate the command "resolve" to resolve comments, or "compress" to compress them back to their $COMMENT#* forms.${
+          passedConfigPath || lintConfigImports || myIgnoresOnly
+            ? " (And DON'T FORGET YOUR FLAGS!)"
+            : ""
+        }`
+      );
+    break;
+}
+
+/* Notes
+I'm going to have to redo this, but for now I just want to vibe code it in order to see how it is possible to make this. 
+Edit: Code vibing, not vibe coding. That's what I did here.
+*/

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "comment-variables",
-  "version": "0.0.5",
-  "description": "",
+  "version": "0.2.0",
+  "description": "A CLI tool for configuring, managing and maintaining JavaScript comments as JavaScript variables.",
   "bin": {
-    "jscomments": "./index.js",
-    "comment-variables": "./index.js"
+    "jscomments": "./library/index.js",
+    "comment-variables": "./library/index.js"
   },
-  "main": "index.js",
+  "main": "library/index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/LutherTS/jscomments.git"
@@ -14,13 +14,19 @@
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": [],
-  "author": "",
+  "keywords": [
+    "cli",
+    "javascript",
+    "comments",
+    "variables"
+  ],
+  "author": "Luther Tchofo Safo <luther@tchofo-safo-portfolio.me>",
   "license": "MIT",
   "type": "module",
   "dependencies": {
+    "@eslint/markdown": "^6.5.0",
     "eslint": "^9.29.0",
-    "get-sourcecode-from-file-path": "^1.0.0",
+    "get-sourcecode-from-file-path": "^1.0.1",
     "resolve-importing-path": "^1.0.2",
     "tsconfig-paths": "^4.2.0",
     "typescript-eslint": "^8.34.1",

package/comments.config.ts

@@ -1,24 +0,0 @@
-import { test } from "./import.js";
-
-const config = {
-  levelOne: {
-    levelTwo: {
-      levelThree: "Level three.",
-      // levelthree: "Also level three.", // errors
-      // alsoLevelThree: "Level three.", // errors
-      levelThreeBis: "Level three bis.",
-      levelThreeTer: "Level three ter.",
-      levelThreeAlso: "Also level three here.",
-      levelThreeToo: "This too is level three.",
-      // test: "LEVELONE#LEVELTWO#LEVELTHREE", // errors
-    },
-  },
-};
-
-export default config;
-
-// This too is level three.
-
-/* Notes
-I'll need to install TypeScript to test this.
-*/

package/import.js

@@ -1,5 +0,0 @@
-import { test2 } from "./import2.js";
-
-export const test = test2;
-
-// This too is level three.

package/import2.js

@@ -1 +0,0 @@
-export const test2 = "test2";

package/index.js

@@ -1,343 +0,0 @@
-#!/usr/bin/env node
-// The hashbang (#!) is necessary to communicate with Unix-based systems, like Linux and macOS. On Windows, it is ignored, but npm tooling bridges the gap by generating wrappers that make the CLI work anyway.
-
-import path from "path";
-import fs from "fs";
-
-import { ESLint } from "eslint";
-import tseslint from "typescript-eslint";
-
-import { runWithConfig } from "./run-with-config.js";
-import { findAllImports } from "./find-all-imports.js";
-
-const cwd = process.cwd();
-
-// ENSURES THE CLI TOOL ONLY RUN IN FOLDERS THAT POSSESS A package.json FILE AND A .git FOLDER.
-
-const hasPackageJson = fs.existsSync(path.join(cwd, "package.json"));
-if (!hasPackageJson) {
-  console.error(
-    "ERROR. No package.json file found in this directory. Aborting to prevent accidental changes."
-  );
-  process.exit(1);
-}
-const hasGitFolder = fs.existsSync(path.join(cwd, ".git"));
-if (!hasGitFolder) {
-  console.error(
-    "ERROR. No git folder found in this directory. Aborting to prevent irreversible changes."
-  );
-  process.exit(1);
-}
-
-// GATHERS COMMANDS.
-
-const commands = process.argv;
-
-// OBTAINS THE VALIDATED FLATTENED CONFIG, REVERSE FLATTENED CONFIG, AND CONFIG PATH.
-
-const configFlagIndex = commands.indexOf("--config");
-const passedConfigPath =
-  configFlagIndex >= 2 ? path.join(cwd, commands[configFlagIndex + 1]) : null;
-const rawConfigPath = passedConfigPath ?? path.join(cwd, "comments.config.js");
-
-const results = await runWithConfig(rawConfigPath);
-if (!results) process.exit(1);
-
-const { flattenedConfig, reversedFlattenedConfig, configPath } = results;
-console.log("Config path is:", configPath);
-console.log("Verified flattened config is:", flattenedConfig);
-console.log("Reversed flattened config is:", reversedFlattenedConfig);
-
-const keys = new Set([...Object.keys(flattenedConfig)]);
-const values = new Set([...Object.values(flattenedConfig)]);
-
-// VALIDATES ONE LAST TIME THE REVERSABILITY OF flattenedConfig AND reversedFlattenedConfig.
-
-keys.forEach((key) => {
-  if (values.has(key)) {
-    console.error(
-      `The key "${key}" is and shouldn't be among the values of flattenedConfig.`
-    );
-    process.exit(1);
-  }
-});
-
-// ADDRESSES THE --include-config-imports FLAG, GIVEN THAT THE FILES IMPORTED BY THE CONFIG ARE IGNORED BY DEFAULT.
-
-const includeConfigImports = commands.indexOf("--include-config-imports") >= 2;
-const rawConfigIgnores = includeConfigImports
-  ? [configPath]
-  : [...findAllImports(configPath)];
-
-// the ignore paths must be relative
-const configIgnores = rawConfigIgnores.map((e) => path.relative(cwd, e));
-console.log(
-  includeConfigImports ? "Config ignore is:" : "Config ignores are",
-  configIgnores
-);
-
-// DEFINES DEFAULT ESLINT IGNORES AND FILES.
-
-const knownIgnores = [
-  ".next",
-  ".react-router",
-  "node_modules",
-  ".parcel-cache",
-  ".react-router-parcel",
-  "dist",
-];
-
-const allJSTSFileGlobs = [
-  "**/*.tsx",
-  "**/*.ts",
-  "**/*.jsx",
-  "**/*.js",
-  "**/*.mjs",
-  "**/*.cjs",
-];
-
-// MAKES THE FLOW FOR resolveCommentsInProject.
-
-const typeScriptAndJSXCompatible = {
-  // for compatibility with TypeScript (.ts and .tsx)
-  parser: tseslint.parser,
-  // for compatibility with JSX (React, etc.)
-  parserOptions: {
-    ecmaFeatures: {
-      jsx: true,
-    },
-  },
-};
-
-/** @type {import('@typescript-eslint/utils').TSESLint.RuleModule<string, []>} */
-const jsCommentsRule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Resolve $COMMENT#... using js-comments config.",
-    },
-    messages: {
-      message: `Resolved $COMMENT placeholder(s) in comment.`,
-    },
-    fixable: "code",
-    schema: [],
-  },
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    const comments = sourceCode
-      .getAllComments()
-      .filter((e) => e.type !== "Shebang");
-
-    for (const comment of comments) {
-      const matches = [...comment.value.matchAll(/\$COMMENT#([A-Z0-9#_]+)/g)];
-
-      if (matches.length === 0) continue;
-
-      let fixedText = comment.value;
-      let hasValidFix = false;
-
-      for (const match of matches) {
-        const fullMatch = match[0]; // e.g. $COMMENT#LEVELONE#LEVELTWO
-        const key = match[1]; // e.g. LEVELONE#LEVELTWO
-        const replacement = flattenedConfig[key];
-
-        if (replacement) {
-          fixedText = fixedText.replace(fullMatch, replacement);
-          hasValidFix = true;
-        }
-      }
-
-      if (hasValidFix && fixedText !== comment.value) {
-        context.report({
-          loc: comment.loc,
-          messageId: "message",
-          fix(fixer) {
-            const range = comment.range;
-            const prefix = comment.type === "Block" ? "/*" : "//";
-            const suffix = comment.type === "Block" ? "*/" : "";
-            const newComment = `${prefix}${fixedText}${suffix}`;
-
-            return fixer.replaceTextRange(range, newComment);
-          },
-        });
-      }
-    }
-
-    return {};
-  },
-};
-
-async function resolveCommentsInProject(fileGlobs = allJSTSFileGlobs) {
-  const ruleName = "js-comments/js-comments-autofix";
-
-  const eslint = new ESLint({
-    fix: true,
-    errorOnUnmatchedPattern: false,
-    overrideConfigFile: true,
-    overrideConfig: [
-      {
-        files: fileGlobs,
-        ignores: [...configIgnores, ...knownIgnores], // 🚫 Ensure config isn't linted
-        languageOptions: typeScriptAndJSXCompatible,
-        plugins: {
-          "js-comments": {
-            rules: {
-              "js-comments-autofix": jsCommentsRule,
-            },
-          },
-        },
-        rules: {
-          [ruleName]: "warn", // Don't block builds, just apply fix
-        },
-      },
-    ],
-  });
-
-  const results = await eslint.lintFiles(fileGlobs);
-  await ESLint.outputFixes(results);
-
-  console.log({ results });
-
-  const total = results.reduce((sum, r) => {
-    const add = r.output ? 1 : 0;
-    return sum + add;
-  }, 0);
-  console.log(`✅ Resolved ${total} comment${total === 1 ? "" : "s"}.`);
-}
-
-// MAKES THE FLOW FOR compressCommentsInProject.
-
-const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-
-const makeReverseJsCommentsRule = (reversedFlattenedConfig) => {
-  // Sort the resolved values by descending length to prevent partial replacements.
-  const sortedReversedFlattenedConfig = Object.entries(
-    reversedFlattenedConfig
-  ).sort(([a], [b]) => b.length - a.length);
-
-  /** @type {import('@typescript-eslint/utils').TSESLint.RuleModule<string, []>} */
-  const reverseJsCommentsRule = {
-    meta: {
-      type: "suggestion",
-      docs: {
-        description: "Resolve $COMMENT#... using js-comments config in reverse",
-      },
-      messages: {
-        message: `Comment compressed.`,
-      },
-      fixable: "code",
-      schema: [],
-    },
-    create(context) {
-      const sourceCode = context.sourceCode;
-      const comments = sourceCode
-        .getAllComments()
-        .filter((e) => e.type !== "Shebang");
-
-      for (const comment of comments) {
-        let fixedText = comment.value;
-        let modified = false;
-
-        for (const [
-          resolvedValue,
-          commentKey,
-        ] of sortedReversedFlattenedConfig) {
-          const pattern = new RegExp(
-            `(?<=\\s|^)${escapeRegex(resolvedValue)}(?=\\s|$)`,
-            "g"
-          );
-
-          fixedText = fixedText.replace(pattern, () => {
-            modified = true;
-            return `$COMMENT#${commentKey}`;
-          });
-        }
-
-        if (modified && fixedText !== comment.value) {
-          context.report({
-            loc: comment.loc,
-            messageId: "message",
-            fix(fixer) {
-              const fullCommentText =
-                comment.type === "Block"
-                  ? `/*${fixedText}*/`
-                  : `//${fixedText}`;
-              return fixer.replaceText(comment, fullCommentText);
-            },
-          });
-        }
-      }
-
-      return {};
-    },
-  };
-
-  return reverseJsCommentsRule;
-};
-
-async function compressCommentsInProject(fileGlobs = allJSTSFileGlobs) {
-  const ruleName = "js-comments/js-comments-autofix";
-
-  const eslint = new ESLint({
-    fix: true,
-    errorOnUnmatchedPattern: false,
-    overrideConfigFile: true,
-    overrideConfig: [
-      {
-        files: fileGlobs,
-        ignores: [...configIgnores, ...knownIgnores], // 🚫 Ensure config isn't linted
-        languageOptions: typeScriptAndJSXCompatible,
-        plugins: {
-          "js-comments": {
-            rules: {
-              "js-comments-autofix": makeReverseJsCommentsRule(
-                reversedFlattenedConfig
-              ),
-            },
-          },
-        },
-        rules: {
-          [ruleName]: "warn", // Don't block builds, just apply fix
-        },
-      },
-    ],
-  });
-
-  const results = await eslint.lintFiles(fileGlobs);
-  await ESLint.outputFixes(results);
-
-  console.log({ results });
-
-  const total = results.reduce((sum, r) => {
-    const add = r.output ? 1 : 0;
-    return sum + add;
-  }, 0);
-  console.log(`✅ Compressed ${total} comment${total === 1 ? "" : "s"}.`);
-}
-
-// ADDRESSES THE CORE COMMANDS "resolve" AND "compress".
-
-const coreCommand = commands[2];
-
-switch (coreCommand) {
-  case "resolve":
-    await resolveCommentsInProject();
-    break;
-  case "compress":
-    await compressCommentsInProject();
-    break;
-  case undefined:
-    console.log(
-      `If these settings are correct with you, feel free to initiate the command "resolve" to resolve comments, or "compress" to compress them back to their $COMMENT#* forms.`
-    );
-    break;
-  default:
-    console.log(
-      `Core command not recognized. Choose between "resolve" and "compress".`
-    );
-    break;
-}
-
-/* Notes
-I'm going to have to redo this, but for now I just want to vibe code it in order to see how it is possible to make this. 
-*/

package/test-file.js

@@ -1,7 +0,0 @@
-/* 
-$COMMENT#LEVELONE#LEVELTWO#LEVELTHREE
-$COMMENT#LEVELONE#LEVELTWO#LEVELTHREEBIS
-$COMMENT#LEVELONE#LEVELTWO#LEVELTHREETER
-$COMMENT#LEVELONE#LEVELTWO#LEVELTHREEALSO
-$COMMENT#LEVELONE#LEVELTWO#LEVELTHREETOO
-*/