@jskit-ai/jskit-cli 0.2.10 → 0.2.12

package/src/server/optionInterpolation.js

@@ -116,14 +116,27 @@ function wordsToKebab(words) {
     .join("-");
 }
 
-function toSingularForm(value) {
+function resolveLastWordMutationInput(value) {
   const words = splitTextIntoWords(value);
   if (words.length < 1) {
-    return "";
+    return null;
   }
 
   const lastIndex = words.length - 1;
-  const last = words[lastIndex];
+  return {
+    words,
+    lastIndex,
+    last: words[lastIndex]
+  };
+}
+
+function toSingularForm(value) {
+  const input = resolveLastWordMutationInput(value);
+  if (!input) {
+    return "";
+  }
+
+  const { words, lastIndex, last } = input;
   if (!last) {
     return wordsToKebab(words);
   }
@@ -145,13 +158,12 @@ function toSingularForm(value) {
 }
 
 function toPluralForm(value) {
-  const words = splitTextIntoWords(value);
-  if (words.length < 1) {
+  const input = resolveLastWordMutationInput(value);
+  if (!input) {
     return "";
   }
 
-  const lastIndex = words.length - 1;
-  const last = words[lastIndex];
+  const { words, lastIndex, last } = input;
   if (!last) {
     return wordsToKebab(words);
   }

package/src/server/runCli.js

@@ -0,0 +1,103 @@
+function createRunCli({
+  parseArgs,
+  printUsage,
+  commandHandlers,
+  cleanupMaterializedPackageRoots,
+  createCliError
+} = {}) {
+  if (typeof parseArgs !== "function") {
+    throw new TypeError("createRunCli requires parseArgs.");
+  }
+  if (typeof printUsage !== "function") {
+    throw new TypeError("createRunCli requires printUsage.");
+  }
+  if (!commandHandlers || typeof commandHandlers !== "object") {
+    throw new TypeError("createRunCli requires commandHandlers.");
+  }
+  if (typeof cleanupMaterializedPackageRoots !== "function") {
+    throw new TypeError("createRunCli requires cleanupMaterializedPackageRoots.");
+  }
+  if (typeof createCliError !== "function") {
+    throw new TypeError("createRunCli requires createCliError.");
+  }
+
+  return async function runCli(argv = process.argv.slice(2), io = {}) {
+    const cwd = io.cwd || process.cwd();
+    const stdin = io.stdin || process.stdin;
+    const stdout = io.stdout || process.stdout;
+    const stderr = io.stderr || process.stderr;
+
+    try {
+      const { command, options, positional } = parseArgs(argv, { createCliError });
+      if (options.help || command === "help") {
+        printUsage(stdout);
+        return 0;
+      }
+
+      if (command === "create") {
+        return await commandHandlers.commandCreate({
+          positional,
+          options,
+          cwd,
+          io: { stdin, stdout, stderr }
+        });
+      }
+      if (command === "list") {
+        return await commandHandlers.commandList({ positional, options, cwd, stdout });
+      }
+      if (command === "show") {
+        return await commandHandlers.commandShow({ positional, options, stdout });
+      }
+      if (command === "add") {
+        return await commandHandlers.commandAdd({
+          positional,
+          options,
+          cwd,
+          io: { stdin, stdout, stderr }
+        });
+      }
+      if (command === "position") {
+        return await commandHandlers.commandPosition({
+          positional,
+          options,
+          cwd,
+          io: { stdin, stdout, stderr }
+        });
+      }
+      if (command === "update") {
+        return await commandHandlers.commandUpdate({
+          positional,
+          options,
+          cwd,
+          io: { stdin, stdout, stderr }
+        });
+      }
+      if (command === "remove") {
+        return await commandHandlers.commandRemove({
+          positional,
+          options,
+          cwd,
+          io: { stdin, stdout, stderr }
+        });
+      }
+      if (command === "doctor") {
+        return await commandHandlers.commandDoctor({ cwd, options, stdout });
+      }
+      if (command === "lint-descriptors") {
+        return await commandHandlers.commandLintDescriptors({ options, stdout });
+      }
+
+      throw createCliError(`Unhandled command: ${command}`, { showUsage: true });
+    } catch (error) {
+      stderr.write(`jskit: ${error?.message || String(error)}\n`);
+      if (error?.showUsage) {
+        printUsage(stderr);
+      }
+      return 1;
+    } finally {
+      await cleanupMaterializedPackageRoots();
+    }
+  };
+}
+
+export { createRunCli };

package/src/server/runtimeDeps.js

@@ -0,0 +1,55 @@
+function createCommandHandlerDeps(deps = {}) {
+  return {
+    createCliError: deps.createCliError,
+    createColorFormatter: deps.createColorFormatter,
+    resolveWrapWidth: deps.resolveWrapWidth,
+    writeWrappedItems: deps.writeWrappedItems,
+    normalizeRelativePath: deps.normalizeRelativePath,
+    normalizeRelativePosixPath: deps.normalizeRelativePosixPath,
+    resolveAppRootFromCwd: deps.resolveAppRootFromCwd,
+    loadLockFile: deps.loadLockFile,
+    loadPackageRegistry: deps.loadPackageRegistry,
+    loadBundleRegistry: deps.loadBundleRegistry,
+    loadAppLocalPackageRegistry: deps.loadAppLocalPackageRegistry,
+    mergePackageRegistries: deps.mergePackageRegistries,
+    resolvePackageIdInput: deps.resolvePackageIdInput,
+    resolveInstalledPackageIdInput: deps.resolveInstalledPackageIdInput,
+    resolveInstalledNodeModulePackageEntry: deps.resolveInstalledNodeModulePackageEntry,
+    hydratePackageRegistryFromInstalledNodeModules: deps.hydratePackageRegistryFromInstalledNodeModules,
+    validateInlineOptionsForPackage: deps.validateInlineOptionsForPackage,
+    resolveLocalDependencyOrder: deps.resolveLocalDependencyOrder,
+    validatePlannedCapabilityClosure: deps.validatePlannedCapabilityClosure,
+    resolvePackageOptions: deps.resolvePackageOptions,
+    applyPackageInstall: deps.applyPackageInstall,
+    applyPackagePositioning: deps.applyPackagePositioning,
+    adoptAppLocalPackageDependencies: deps.adoptAppLocalPackageDependencies,
+    loadAppPackageJson: deps.loadAppPackageJson,
+    resolveLocalPackageId: deps.resolveLocalPackageId,
+    createLocalPackageScaffoldFiles: deps.createLocalPackageScaffoldFiles,
+    fileExists: deps.fileExists,
+    applyPackageJsonField: deps.applyPackageJsonField,
+    toFileDependencySpecifier: deps.toFileDependencySpecifier,
+    writeJsonFile: deps.writeJsonFile,
+    writeFile: deps.writeFile,
+    mkdir: deps.mkdir,
+    path: deps.path,
+    inspectPackageOfferings: deps.inspectPackageOfferings,
+    buildFileWriteGroups: deps.buildFileWriteGroups,
+    listDeclaredCapabilities: deps.listDeclaredCapabilities,
+    buildCapabilityDetailsForPackage: deps.buildCapabilityDetailsForPackage,
+    formatPackageSubpathImport: deps.formatPackageSubpathImport,
+    normalizePlacementOutlets: deps.normalizePlacementOutlets,
+    normalizePlacementContributions: deps.normalizePlacementContributions,
+    shouldShowPackageExportTarget: deps.shouldShowPackageExportTarget,
+    classifyExportedSymbols: deps.classifyExportedSymbols,
+    deriveProviderDisplayName: deps.deriveProviderDisplayName,
+    restorePackageJsonField: deps.restorePackageJsonField,
+    readFileBufferIfExists: deps.readFileBufferIfExists,
+    removeEnvValue: deps.removeEnvValue,
+    removeManagedViteProxyEntries: deps.removeManagedViteProxyEntries,
+    hashBuffer: deps.hashBuffer,
+    rm: deps.rm
+  };
+}
+
+export { createCommandHandlerDeps };