simplemdg-dev-cli 2.0.4 → 2.4.4

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));
+}

package/src/core/tooling.ts

@@ -0,0 +1,207 @@
+import { execa } from "execa";
+import chalk from "chalk";
+import { searchableSelectChoice } from "./prompts";
+
+export type TPackageManager = "winget" | "choco" | "scoop" | "brew" | "apt-get";
+
+type TInstallStrategy =
+  | { kind: "package-manager"; manager: TPackageManager; args: string[] }
+  | { kind: "npm-global"; packageName: string };
+
+type TExternalTool = {
+  command: string;
+  versionArgs: string[];
+  displayName: string;
+  docsUrl: string;
+  /** Best-effort install recipes per package manager (Windows/macOS/Linux). */
+  packageManagerArgs: Partial<Record<TPackageManager, string[]>>;
+  /** Set when the tool ships as a global npm package. */
+  npmGlobalPackage?: string;
+  manualHint: string;
+};
+
+const EXTERNAL_TOOLS: Record<string, TExternalTool> = {
+  cf: {
+    command: "cf",
+    versionArgs: ["version"],
+    displayName: "Cloud Foundry CLI",
+    docsUrl: "https://docs.cloudfoundry.org/cf-cli/install-go-cli.html",
+    packageManagerArgs: {
+      choco: ["install", "cloudfoundry-cli", "-y"],
+      brew: ["install", "cloudfoundry/tap/cf-cli@8"],
+    },
+    manualHint: "Windows installer: https://github.com/cloudfoundry/cli/releases",
+  },
+  cds: {
+    command: "cds",
+    versionArgs: ["--version"],
+    displayName: "SAP CAP CLI (@sap/cds-dk)",
+    docsUrl: "https://cap.cloud.sap/docs/tools/cds-cli",
+    packageManagerArgs: {},
+    npmGlobalPackage: "@sap/cds-dk",
+    manualHint: "Install globally with: npm install -g @sap/cds-dk",
+  },
+  git: {
+    command: "git",
+    versionArgs: ["--version"],
+    displayName: "Git",
+    docsUrl: "https://git-scm.com/downloads",
+    packageManagerArgs: {
+      winget: ["install", "-e", "--id", "Git.Git"],
+      choco: ["install", "git", "-y"],
+      scoop: ["install", "git"],
+      brew: ["install", "git"],
+      "apt-get": ["install", "-y", "git"],
+    },
+    manualHint: "Download Git from https://git-scm.com/downloads",
+  },
+};
+
+/**
+ * Check whether a command is resolvable on PATH. Uses the platform resolver
+ * (`where` on Windows, `which` elsewhere) so it also finds `.cmd`/`.ps1` shims
+ * (e.g. scoop, npm) without actually executing the tool.
+ */
+export async function isCommandAvailable(command: string): Promise<boolean> {
+  const finder = process.platform === "win32" ? "where" : "which";
+
+  try {
+    const result = await execa(finder, [command], { reject: false, shell: false, timeout: 15000 });
+    return !result.failed && (result.exitCode ?? 1) === 0 && result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function detectAvailablePackageManagers(): Promise<TPackageManager[]> {
+  const candidates: TPackageManager[] = process.platform === "win32"
+    ? ["winget", "choco", "scoop"]
+    : process.platform === "darwin"
+      ? ["brew"]
+      : ["apt-get"];
+
+  const available: TPackageManager[] = [];
+
+  for (const manager of candidates) {
+    if (await isCommandAvailable(manager)) {
+      available.push(manager);
+    }
+  }
+
+  return available;
+}
+
+async function resolveInstallStrategies(tool: TExternalTool): Promise<TInstallStrategy[]> {
+  const strategies: TInstallStrategy[] = [];
+  const managers = await detectAvailablePackageManagers();
+
+  for (const manager of managers) {
+    const args = tool.packageManagerArgs[manager];
+    if (args) {
+      strategies.push({ kind: "package-manager", manager, args });
+    }
+  }
+
+  if (tool.npmGlobalPackage && (await isCommandAvailable("npm"))) {
+    strategies.push({ kind: "npm-global", packageName: tool.npmGlobalPackage });
+  }
+
+  return strategies;
+}
+
+function describeStrategy(strategy: TInstallStrategy): string {
+  if (strategy.kind === "npm-global") {
+    return `npm install -g ${strategy.packageName}`;
+  }
+
+  return `${strategy.manager} ${strategy.args.join(" ")}`;
+}
+
+async function runInstallStrategy(strategy: TInstallStrategy): Promise<number> {
+  const [command, args] = strategy.kind === "npm-global"
+    ? ["npm", ["install", "-g", strategy.packageName]] as const
+    : [strategy.manager, strategy.args] as const;
+
+  console.log(chalk.gray(`Running: ${command} ${args.join(" ")}`));
+  const result = await execa(command, args as string[], { stdio: "inherit", reject: false, shell: false });
+  return result.exitCode ?? 1;
+}
+
+function printManualInstructions(tool: TExternalTool, strategies: TInstallStrategy[]): void {
+  console.log(chalk.yellow(`${tool.displayName} ('${tool.command}') is required but was not found on PATH.`));
+
+  if (strategies.length > 0) {
+    console.log("Install it with one of:");
+    for (const strategy of strategies) {
+      console.log(`  ${chalk.cyan(describeStrategy(strategy))}`);
+    }
+  }
+
+  console.log(chalk.gray(tool.manualHint));
+  console.log(chalk.gray(`Docs: ${tool.docsUrl}`));
+}
+
+/**
+ * Ensure an external CLI tool is installed before a command relies on it.
+ *
+ * When the tool is missing, offer to install it via a detected package manager
+ * (or npm for npm-backed tools). This fails fast and avoids the situation where
+ * a long interactive flow only discovers a missing prerequisite at the end.
+ */
+export async function ensureExternalTool(toolId: keyof typeof EXTERNAL_TOOLS | string): Promise<void> {
+  const tool = EXTERNAL_TOOLS[toolId];
+
+  if (!tool) {
+    return;
+  }
+
+  if (await isCommandAvailable(tool.command)) {
+    return;
+  }
+
+  const strategies = await resolveInstallStrategies(tool);
+  const interactive = Boolean(process.stdin.isTTY);
+
+  if (strategies.length === 0 || !interactive) {
+    printManualInstructions(tool, strategies);
+    throw new Error(`${tool.displayName} is required. Install it, then re-run this command.`);
+  }
+
+  console.log(chalk.yellow(`${tool.displayName} ('${tool.command}') is not installed.`));
+
+  const choice = await searchableSelectChoice({
+    message: `Install ${tool.displayName} now?`,
+    choices: [
+      ...strategies.map((strategy, index) => ({
+        title: `Install with ${describeStrategy(strategy)}`,
+        value: String(index),
+      })),
+      { title: "Skip and show manual instructions", value: "__SKIP__" },
+    ],
+    allowCustomValue: false,
+  });
+
+  if (choice === "__SKIP__") {
+    printManualInstructions(tool, strategies);
+    throw new Error(`${tool.displayName} is required. Install it, then re-run this command.`);
+  }
+
+  const strategy = strategies[Number(choice)];
+  const exitCode = await runInstallStrategy(strategy);
+
+  if (exitCode !== 0) {
+    console.log(chalk.red(`Install command failed (exit code ${exitCode}).`));
+    printManualInstructions(tool, strategies);
+    throw new Error(`Could not install ${tool.displayName} automatically.`);
+  }
+
+  if (await isCommandAvailable(tool.command)) {
+    console.log(chalk.green(`${tool.displayName} is now installed.`));
+    return;
+  }
+
+  // Many installers update PATH only for new shells.
+  console.log(chalk.yellow(`${tool.displayName} was installed, but it is not on PATH in this session yet.`));
+  console.log(chalk.gray("Open a new terminal so PATH refreshes, then re-run this command."));
+  throw new Error(`${tool.displayName} install completed; restart your terminal to use it.`);
+}

package/src/core/types.ts

@@ -0,0 +1,152 @@
+export type TKeyValueMap = Record<string, string>;
+
+export type TRepositoryInfo = {
+  repositoryPath: string;
+};
+
+export type TScannedVariable = {
+  variableName: string;
+  filePath: string;
+  occurrences: number;
+};
+
+export type TInstallRepositoryOptions = {
+  repositoryPath: string;
+  installCommand: string;
+  variableValues: Record<string, string>;
+  temporaryOverrides: Record<string, string>;
+  filePatterns: string[];
+  onLog?: (value: string) => void;
+  onErrorLog?: (value: string) => void;
+};
+
+export type TInstallRepositoryResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+export type TDoctorPackageResult = {
+  packageName: string;
+  versions: string[];
+  occurrences: TPackageOccurrence[];
+  hasMultipleVersions: boolean;
+};
+
+export type TPackageOccurrence = {
+  version?: string;
+  path?: string;
+};
+
+export type TLoadedLocationConflict = {
+  packageName: string;
+  rawMessage: string;
+};
+
+export type TPackageConflictInspection = {
+  packageName: string;
+  suggestedVersions: string[];
+  doctorResult: TDoctorPackageResult;
+};
+
+export type TCloudFoundryTarget = {
+  apiEndpoint?: string;
+  user?: string;
+  org?: string;
+  space?: string;
+};
+
+export type TCloudFoundryApp = {
+  name: string;
+  requestedState?: string;
+  processes?: string;
+  routes?: string;
+};
+
+export type TCloudFoundryOrgEntry = {
+  apiEndpoint: string;
+  region: string;
+  org: string;
+  spaceCount?: number;
+  spaces?: string[];
+  updatedAt: string;
+};
+
+export type TCloudFoundryLoginProfile = {
+  apiEndpoint: string;
+  org: string;
+  space?: string;
+  username: string;
+  password?: string;
+  updatedAt: string;
+};
+
+export type TCloudFoundryAppsCacheEntry = {
+  targetKey: string;
+  apps: TCloudFoundryApp[];
+  updatedAt: string;
+};
+
+export type TCloudFoundryCache = {
+  loginProfiles: TCloudFoundryLoginProfile[];
+  appListsByTarget: Record<string, TCloudFoundryAppsCacheEntry>;
+  orgsAcrossRegions: TCloudFoundryOrgEntry[];
+  orgsAcrossRegionsUpdatedAt?: string;
+  envFileNames: string[];
+  selectedApps: string[];
+};
+
+export type TCdsCache = {
+  profiles: string[];
+  ports: string[];
+  services: string[];
+  edmxOutputFileNames: string[];
+  models: string[];
+};
+
+export type TNpmrcPackageEntry = {
+  packageId: string;
+  packageName: string;
+  scope: string;
+  host: string;
+  updatedAt: string;
+};
+
+export type TNpmrcTokenEntry = {
+  scope: string;
+  host: string;
+  token: string;
+  label: string;
+  updatedAt: string;
+};
+
+export type TNpmrcProjectCache = {
+  projectName: string;
+  packageIds: string[];
+  packages: TNpmrcPackageEntry[];
+};
+
+export type TNpmrcCache = {
+  hosts: string[];
+  scopes: string[];
+  packageIds: string[];
+  packages: TNpmrcPackageEntry[];
+  packageIdsByProject: Record<string, TNpmrcProjectCache>;
+  tokens: string[];
+  tokenEntries: TNpmrcTokenEntry[];
+  outputFileNames: string[];
+};
+
+export type TSimpleMdgCache = {
+  variables: Record<string, string[]>;
+  overrides: Record<string, string[]>;
+  cloudFoundry: TCloudFoundryCache;
+  cds: TCdsCache;
+  npmrc: TNpmrcCache;
+};
+
+export type TParsedCloudFoundryEnvironment = {
+  VCAP_SERVICES?: unknown;
+  VCAP_APPLICATION?: unknown;
+  [key: string]: unknown;
+};

package/src/core/version-conflict.ts

@@ -0,0 +1,46 @@
+import { doctorPackage } from "./doctor";
+import { rememberResolvedOverrideVersions } from "./cache";
+import type { TLoadedLocationConflict, TPackageConflictInspection } from "./types";
+
+export { rememberResolvedOverrideVersions };
+
+export function parseLoadedLocationConflicts(output: string): TLoadedLocationConflict[] {
+  const result: TLoadedLocationConflict[] = [];
+  const lines = output.split(/\r?\n/);
+
+  for (const line of lines) {
+    if (!/loaded from different locations/i.test(line)) {
+      continue;
+    }
+
+    const packageMatch = line.match(/(@[\w.-]+\/[\w.-]+|[\w.-]+)(?=(?:\s|['"`]|,|:))/);
+
+    result.push({
+      packageName: packageMatch?.[1] ?? "@sap/cds",
+      rawMessage: line.trim(),
+    });
+  }
+
+  return result;
+}
+
+export async function inspectPackageConflicts(options: {
+  repositoryPath: string;
+  packageNames: string[];
+}): Promise<TPackageConflictInspection[]> {
+  const result: TPackageConflictInspection[] = [];
+
+  for (const packageName of options.packageNames) {
+    const doctorResult = await doctorPackage({ repositoryPath: options.repositoryPath, packageName });
+
+    if (doctorResult.hasMultipleVersions || doctorResult.occurrences.length > 1) {
+      result.push({
+        packageName,
+        doctorResult,
+        suggestedVersions: doctorResult.versions,
+      });
+    }
+  }
+
+  return result;
+}