simplemdg-dev-cli 2.0.4 → 2.4.5

package/src/core/npmrc.ts

@@ -0,0 +1,171 @@
+import path from "node:path";
+import fs from "fs-extra";
+
+export type TNpmrcConfig = {
+  host: string;
+  scope: string;
+  packageId: string;
+  token: string;
+  outputFileName: string;
+  alwaysAuth: boolean;
+};
+
+function trimSlashes(value: string): string {
+  return value.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+}
+
+export function normalizeNpmScope(scope: string): string {
+  const trimmedScope = scope.trim();
+  if (!trimmedScope) {
+    throw new Error("Scope is required");
+  }
+
+  return trimmedScope.startsWith("@") ? trimmedScope : `@${trimmedScope}`;
+}
+
+export function normalizeGitLabHost(host: string): string {
+  return trimSlashes(host.replace(/^https?:\/\//, ""));
+}
+
+export function buildGitLabNpmRegistryUrl(options: { host: string; packageId: string }): string {
+  const host = normalizeGitLabHost(options.host);
+  const packageId = options.packageId.trim();
+
+  if (!/^\d+$/.test(packageId)) {
+    throw new Error("Package ID must be a number");
+  }
+
+  return `https://${host}/api/v4/projects/${packageId}/packages/npm/`;
+}
+
+export function buildGitLabNpmAuthRegistryPath(options: { host: string; packageId: string }): string {
+  const host = normalizeGitLabHost(options.host);
+  const packageId = options.packageId.trim();
+
+  if (!/^\d+$/.test(packageId)) {
+    throw new Error("Package ID must be a number");
+  }
+
+  return `//${host}/api/v4/projects/${packageId}/packages/npm/`;
+}
+
+function removeExistingManagedLines(options: {
+  currentContent: string;
+  scope: string;
+  host: string;
+}): string[] {
+  const normalizedScope = normalizeNpmScope(options.scope);
+  const normalizedHost = normalizeGitLabHost(options.host);
+
+  return options.currentContent
+    .split(/\r?\n/)
+    .filter((line) => {
+      const trimmedLine = line.trim();
+
+      if (!trimmedLine) {
+        return false;
+      }
+
+      if (trimmedLine.startsWith(`${normalizedScope}:registry=`)) {
+        return false;
+      }
+
+      if (trimmedLine.includes(`${normalizedHost}/api/v4/projects/`) && trimmedLine.includes("/packages/npm/:_authToken=")) {
+        return false;
+      }
+
+      if (trimmedLine === "always-auth=true" || trimmedLine === "always-auth=false") {
+        return false;
+      }
+
+      return true;
+    });
+}
+
+export async function writeNpmrcFile(options: TNpmrcConfig): Promise<string> {
+  const outputPath = path.resolve(process.cwd(), options.outputFileName);
+  const existingContent = await fs.pathExists(outputPath) ? await fs.readFile(outputPath, "utf8") : "";
+  const preservedLines = removeExistingManagedLines({
+    currentContent: existingContent,
+    scope: options.scope,
+    host: options.host,
+  });
+
+  const scope = normalizeNpmScope(options.scope);
+  const registryUrl = buildGitLabNpmRegistryUrl({ host: options.host, packageId: options.packageId });
+  const authRegistryPath = buildGitLabNpmAuthRegistryPath({ host: options.host, packageId: options.packageId });
+
+  const managedLines = [
+    `${scope}:registry=${registryUrl}`,
+    `${authRegistryPath}:_authToken=${options.token.trim()}`,
+    `always-auth=${options.alwaysAuth ? "true" : "false"}`,
+  ];
+
+  const nextContent = [...preservedLines, ...managedLines].join("\n") + "\n";
+
+  await fs.writeFile(outputPath, nextContent, "utf8");
+  return outputPath;
+}
+
+export function parsePackageIdList(input: string): string[] {
+  return [...new Set(input
+    .split(/[\s,;]+/)
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .filter((value) => /^\d+$/.test(value)))] ;
+}
+
+export async function readPackageJsonName(repositoryPath: string): Promise<string | undefined> {
+  const packageJsonPath = path.join(repositoryPath, "package.json");
+
+  if (!(await fs.pathExists(packageJsonPath))) {
+    return undefined;
+  }
+
+  const packageJson = await fs.readJson(packageJsonPath).catch(() => undefined) as { name?: string } | undefined;
+  return packageJson?.name;
+}
+
+export type TParsedPackageInput = {
+  packageId: string;
+  packageName: string;
+};
+
+export function parsePackageInputList(input: string): TParsedPackageInput[] {
+  const entries: TParsedPackageInput[] = [];
+  const keys = new Set<string>();
+
+  for (const rawLine of input.split(/\r?\n/)) {
+    const trimmedLine = rawLine.trim();
+
+    if (!trimmedLine) {
+      continue;
+    }
+
+    const tokens = trimmedLine.split(/[|,;\t]+/).map((value) => value.trim()).filter(Boolean);
+    const firstNumericTokenIndex = tokens.findIndex((value) => /^\d+$/.test(value));
+
+    if (firstNumericTokenIndex >= 0) {
+      const packageId = tokens[firstNumericTokenIndex];
+      const packageNameTokens = tokens.filter((_, index) => index !== firstNumericTokenIndex);
+      const packageName = packageNameTokens.join(" - ").trim() || packageId;
+      const key = packageId;
+
+      if (!keys.has(key)) {
+        keys.add(key);
+        entries.push({ packageId, packageName });
+      }
+
+      continue;
+    }
+
+    for (const packageId of parsePackageIdList(trimmedLine)) {
+      if (!keys.has(packageId)) {
+        keys.add(packageId);
+        entries.push({ packageId, packageName: packageId });
+      }
+    }
+  }
+
+  return entries;
+}

package/src/core/process.ts

@@ -0,0 +1,75 @@
+import { execa } from "execa";
+
+export type TCommandResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+export async function runCommand(command: string, args: string[], options?: { cwd?: string; reject?: boolean }): Promise<TCommandResult> {
+  const result = await execa(command, args, {
+    cwd: options?.cwd,
+    reject: options?.reject ?? false,
+    all: false,
+    shell: false,
+  });
+
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode ?? 0,
+  };
+}
+
+export async function runCommandInherit(command: string, args: string[], options?: { cwd?: string }): Promise<number> {
+  const result = await execa(command, args, {
+    cwd: options?.cwd,
+    stdio: "inherit",
+    reject: false,
+    shell: false,
+  });
+
+  return result.exitCode ?? 0;
+}
+
+export function splitCommand(commandLine: string): { command: string; args: string[] } {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: '"' | "'" | undefined;
+
+  for (let index = 0; index < commandLine.length; index += 1) {
+    const character = commandLine[index];
+
+    if ((character === '"' || character === "'") && !quote) {
+      quote = character;
+      continue;
+    }
+
+    if (quote && character === quote) {
+      quote = undefined;
+      continue;
+    }
+
+    if (!quote && /\s/.test(character)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += character;
+  }
+
+  if (current) {
+    tokens.push(current);
+  }
+
+  const [command, ...args] = tokens;
+
+  if (!command) {
+    throw new Error("Command is required");
+  }
+
+  return { command, args };
+}

package/src/core/prompts.ts

@@ -0,0 +1,225 @@
+import prompts from "prompts";
+
+const CUSTOM_VALUE_PREFIX = "__SMDG_CUSTOM_VALUE__:";
+
+function normalizeValue(value: string): string {
+  return value.trim();
+}
+
+function uniqueValues(values: Array<string | undefined>): string[] {
+  return [...new Set(values.map((value) => normalizeValue(value ?? "")).filter(Boolean))];
+}
+
+function scoreMatch(input: string, value: string): number {
+  const normalizedInput = input.toLowerCase().trim();
+  const normalizedValue = value.toLowerCase();
+
+  if (!normalizedInput) {
+    return 0;
+  }
+
+  if (normalizedValue === normalizedInput) {
+    return 100;
+  }
+
+  if (normalizedValue.startsWith(normalizedInput)) {
+    return 80;
+  }
+
+  if (normalizedValue.includes(normalizedInput)) {
+    return 60;
+  }
+
+  const inputParts = normalizedInput.split(/\s+/).filter(Boolean);
+
+  if (inputParts.every((part) => normalizedValue.includes(part))) {
+    return 40;
+  }
+
+  return -1;
+}
+
+function buildSearchableChoices(options: {
+  input: string;
+  choices: prompts.Choice[];
+  allowCustomValue: boolean;
+  customValueTitle?: (value: string) => string;
+}): prompts.Choice[] {
+  const input = normalizeValue(options.input);
+  const scoredChoices = options.choices
+    .map((choice, index) => {
+      const title = String(choice.title ?? "");
+      const value = String(choice.value ?? choice.title ?? "");
+      const score = input ? Math.max(scoreMatch(input, title), scoreMatch(input, value)) : 0;
+
+      return { choice, index, score };
+    })
+    .filter((item) => !input || item.score >= 0)
+    .sort((left, right) => right.score - left.score || left.index - right.index)
+    .map((item) => item.choice);
+
+  const hasExactMatch = options.choices.some((choice) => {
+    const title = String(choice.title ?? "").trim().toLowerCase();
+    const value = String(choice.value ?? choice.title ?? "").trim().toLowerCase();
+    const normalizedInput = input.toLowerCase();
+
+    return title === normalizedInput || value === normalizedInput;
+  });
+
+  if (options.allowCustomValue && input && !hasExactMatch) {
+    return [
+      ...scoredChoices,
+      {
+        title: options.customValueTitle?.(input) ?? `Use typed value: ${input}`,
+        value: `${CUSTOM_VALUE_PREFIX}${input}`,
+      },
+    ];
+  }
+
+  return scoredChoices;
+}
+
+export async function searchableSelectChoice<TValue extends string>(options: {
+  message: string;
+  choices: Array<{ title: string; value: TValue; description?: string }>;
+  validateCustomValue?: (value: string) => true | string;
+  allowCustomValue?: boolean;
+  customValueTitle?: (value: string) => string;
+  limit?: number;
+}): Promise<string> {
+  const allowCustomValue = options.allowCustomValue ?? true;
+  const validate = options.validateCustomValue ?? ((value: string) => value.trim() ? true : "Value is required");
+  const choices = options.choices.map((choice) => ({
+    title: choice.title,
+    value: choice.value,
+    description: choice.description,
+  }));
+
+  if (choices.length === 0) {
+    const response = await prompts({
+      type: "text",
+      name: "value",
+      message: options.message,
+      validate,
+    });
+
+    if (!response.value) {
+      throw new Error("Cancelled");
+    }
+
+    return String(response.value).trim();
+  }
+
+  const response = await prompts({
+    type: "autocomplete",
+    name: "value",
+    message: options.message,
+    choices,
+    initial: 0,
+    limit: options.limit ?? 12,
+    suggest: async (input: string, currentChoices: prompts.Choice[]) => buildSearchableChoices({
+      input,
+      choices: currentChoices,
+      allowCustomValue,
+      customValueTitle: options.customValueTitle,
+    }),
+  });
+
+  if (!response.value) {
+    throw new Error("Cancelled");
+  }
+
+  const selectedValue = String(response.value);
+
+  if (selectedValue.startsWith(CUSTOM_VALUE_PREFIX)) {
+    const customValue = selectedValue.slice(CUSTOM_VALUE_PREFIX.length).trim();
+    const validationResult = validate(customValue);
+
+    if (validationResult !== true) {
+      throw new Error(validationResult);
+    }
+
+    return customValue;
+  }
+
+  return selectedValue;
+}
+
+export async function searchableSelectOrInput(options: {
+  message: string;
+  values: string[];
+  initialValue?: string;
+  inputMessage?: string;
+  validate?: (value: string) => true | string;
+  allowCustomValue?: boolean;
+  customValueTitle?: (value: string) => string;
+  limit?: number;
+}): Promise<string> {
+  const values = uniqueValues([options.initialValue, ...options.values]);
+  const choices = values.map((value) => ({ title: value, value }));
+  const allowCustomValue = options.allowCustomValue ?? true;
+  const validate = options.validate ?? ((value: string) => value.trim() ? true : "Value is required");
+
+  if (choices.length > 0) {
+    const response = await prompts({
+      type: "autocomplete",
+      name: "value",
+      message: options.message,
+      choices,
+      initial: 0,
+      limit: options.limit ?? 12,
+      suggest: async (input: string, currentChoices: prompts.Choice[]) => buildSearchableChoices({
+        input,
+        choices: currentChoices,
+        allowCustomValue,
+        customValueTitle: options.customValueTitle,
+      }),
+    });
+
+    if (!response.value) {
+      throw new Error("Cancelled");
+    }
+
+    const selectedValue = String(response.value);
+
+    if (selectedValue.startsWith(CUSTOM_VALUE_PREFIX)) {
+      const customValue = selectedValue.slice(CUSTOM_VALUE_PREFIX.length).trim();
+      const validationResult = validate(customValue);
+
+      if (validationResult !== true) {
+        throw new Error(validationResult);
+      }
+
+      return customValue;
+    }
+
+    return selectedValue;
+  }
+
+  const input = await prompts({
+    type: "text",
+    name: "value",
+    message: options.inputMessage ?? options.message,
+    initial: options.initialValue ?? values[0] ?? "",
+    validate,
+  });
+
+  if (!input.value) {
+    throw new Error("Cancelled");
+  }
+
+  return String(input.value).trim();
+}
+
+export async function selectFromHistoryOrInput(options: {
+  message: string;
+  values: string[];
+  initialValue?: string;
+  inputMessage?: string;
+  validate?: (value: string) => true | string;
+}): Promise<string> {
+  return searchableSelectOrInput({
+    ...options,
+    allowCustomValue: true,
+  });
+}

package/src/core/repository.ts

@@ -0,0 +1,36 @@
+import path from "node:path";
+import fs from "fs-extra";
+import type { TRepositoryInfo } from "./types";
+
+export async function findNearestRepository(startPath: string): Promise<TRepositoryInfo | undefined> {
+  let currentPath = path.resolve(startPath);
+
+  while (true) {
+    if (await fs.pathExists(path.join(currentPath, "package.json"))) {
+      return { repositoryPath: currentPath };
+    }
+
+    const parentPath = path.dirname(currentPath);
+
+    if (parentPath === currentPath) {
+      return undefined;
+    }
+
+    currentPath = parentPath;
+  }
+}
+
+export async function resolveRepositoryPath(cwd: string): Promise<string> {
+  const absoluteCwd = path.resolve(cwd);
+  const repository = await findNearestRepository(absoluteCwd);
+
+  if (repository?.repositoryPath) {
+    return repository.repositoryPath;
+  }
+
+  if (await fs.pathExists(path.join(absoluteCwd, "package.json"))) {
+    return absoluteCwd;
+  }
+
+  throw new Error(`Cannot find repository from ${absoluteCwd}`);
+}

package/src/core/scanner.ts

@@ -0,0 +1,41 @@
+import path from "node:path";
+import fs from "fs-extra";
+import fastGlob from "fast-glob";
+import type { TScannedVariable } from "./types";
+
+const VARIABLE_PATTERN = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+
+export async function scanRepositoryVariables(options: {
+  repositoryPath: string;
+  filePatterns: string[];
+}): Promise<TScannedVariable[]> {
+  const filePaths = await fastGlob(options.filePatterns, {
+    cwd: options.repositoryPath,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ["node_modules/**", "dist/**", ".git/**"],
+  });
+
+  const result: TScannedVariable[] = [];
+
+  for (const filePath of filePaths) {
+    const content = await fs.readFile(filePath, "utf8");
+    const occurrencesByVariable = new Map<string, number>();
+    let match: RegExpExecArray | null;
+
+    while ((match = VARIABLE_PATTERN.exec(content)) !== null) {
+      const variableName = match[1];
+      occurrencesByVariable.set(variableName, (occurrencesByVariable.get(variableName) ?? 0) + 1);
+    }
+
+    for (const [variableName, occurrences] of occurrencesByVariable.entries()) {
+      result.push({
+        variableName,
+        occurrences,
+        filePath: path.relative(options.repositoryPath, filePath),
+      });
+    }
+  }
+
+  return result.sort((left, right) => left.variableName.localeCompare(right.variableName));
+}