some renaming

command/upgrade/provider/deno_land_test.ts

@@ -122,8 +122,8 @@ Deno.test("DenoLandProvider", async (ctx) => {
 
       await upgrade({
         name: "foo",
-        currentVersion: "1.0.0",
-        version: "latest",
+        from: "1.0.0",
+        to: "latest",
         provider,
       });
 

command/upgrade/provider/github_test.ts

@@ -174,8 +174,8 @@ Deno.test("GithubProvider", async (ctx) => {
 
       await upgrade({
         name: "foo",
-        currentVersion: "1.0.0",
-        version: "latest",
+        from: "1.0.0",
+        to: "latest",
         provider,
       });
 

command/upgrade/provider/jsr_test.ts

@@ -125,8 +125,8 @@ Deno.test("JsrProvider", async (ctx) => {
 
       await upgrade({
         name: "foo",
-        currentVersion: "1.0.0",
-        version: "latest",
+        from: "1.0.0",
+        to: "latest",
         provider,
       });
 

command/upgrade/provider/nest_land_test.ts

@@ -122,8 +122,8 @@ Deno.test("NestLandProvider", async (ctx) => {
 
       await upgrade({
         name: "foo",
-        currentVersion: "1.0.0",
-        version: "latest",
+        from: "1.0.0",
+        to: "latest",
         provider,
       });
 

command/upgrade/provider/npm_test.ts

@@ -131,8 +131,8 @@ Deno.test("NpmProvider", async (ctx) => {
 
       await upgrade({
         name: "foo",
-        currentVersion: "1.0.0",
-        version: "latest",
+        from: "1.0.0",
+        to: "latest",
         provider,
       });
 

command/upgrade/runtime.ts

@@ -1,22 +1,22 @@
 import type { Logger } from "./logger.ts";
 import type { Provider } from "./provider.ts";
 
-/** Runtime specific upgrade options. */
-export interface RuntimeUpgradeOptions {
+/** Runtime specific options. */
+export interface RuntimeOptions {
   args?: Array<string>;
   main?: string;
 }
 
-/** Options for upgrading a package. */
-export interface UpgradePackageOptions extends RuntimeUpgradeOptions {
+/** Options for upgrading a package for a specific runtime. */
+export interface RuntimeUpgradeOptions extends RuntimeOptions {
   name: string;
-  version: string;
+  to: string;
   provider: Provider;
   verbose?: boolean;
   logger?: Logger;
 }
 
 /** Runtime handler. */
 export abstract class Runtime {
-  abstract upgrade(_options: UpgradePackageOptions): Promise<void>;
+  abstract upgrade(_options: RuntimeUpgradeOptions): Promise<void>;
 }

command/upgrade/runtime/deno_runtime.ts

@@ -1,24 +1,24 @@
 import { dim } from "@std/fmt/colors";
-import { Runtime, type UpgradePackageOptions } from "../runtime.ts";
+import { Runtime, type RuntimeUpgradeOptions } from "../runtime.ts";
 import type { Logger } from "../logger.ts";
 
 /** Deno specific upgrade options. */
-export interface DenoUpgradeOptions {
+export interface DenoRuntimeOptions {
   importMap?: string;
 }
 
 /** Deno specific package upgrade options. */
-export type DenoUpgradePackageOptions =
-  & UpgradePackageOptions
-  & DenoUpgradeOptions;
+export type DenoRuntimeUpgradeOptions =
+  & RuntimeUpgradeOptions
+  & DenoRuntimeOptions;
 
 /** Deno runtime upgrade handler. */
 export class DenoRuntime extends Runtime {
   async upgrade(
-    { provider, name, main, version, importMap, verbose, logger, args = [] }:
-      DenoUpgradePackageOptions,
+    { provider, name, main, to, importMap, verbose, logger, args = [] }:
+      DenoRuntimeUpgradeOptions,
   ): Promise<void> {
-    const specifier: string = provider.getSpecifier(name, version, main);
+    const specifier: string = provider.getSpecifier(name, to, main);
 
     const cmdArgs = ["install", `--name=${name}`, "--global", "--force"];
 

command/upgrade/runtime/node_runtime.ts

@@ -1,20 +1,20 @@
 import { dim } from "@std/fmt/colors";
 import type { Logger } from "../logger.ts";
-import type { Runtime, UpgradePackageOptions } from "../runtime.ts";
+import type { Runtime, RuntimeUpgradeOptions } from "../runtime.ts";
 
 export class NodeRuntime implements Runtime {
   upgrade(
     {
       provider,
       name,
       main,
-      version,
+      to,
       verbose,
       logger,
       args = [],
-    }: UpgradePackageOptions,
+    }: RuntimeUpgradeOptions,
   ): Promise<void> {
-    const specifier = provider.getSpecifier(name, version, main)
+    const specifier = provider.getSpecifier(name, to, main)
       .replace(/^(npm|jsr):/, "");
     const isJsr = provider.name === "jsr";
 

command/upgrade/upgrade.ts

@@ -1,26 +1,19 @@
 import { bold, dim, green, red } from "@std/fmt/colors";
 import { getRuntime } from "./get_runtime.ts";
-import type {
-  RuntimeUpgradeOptions,
-  UpgradePackageOptions,
-} from "./runtime.ts";
-import type { DenoUpgradeOptions } from "./runtime/deno_runtime.ts";
-
-type DenoRuntimeUpgradeOptions = RuntimeUpgradeOptions & DenoUpgradeOptions;
-type NodeRuntimeUpgradeOptions = RuntimeUpgradeOptions;
-type BunRuntimeUpgradeOptions = RuntimeUpgradeOptions;
+import type { RuntimeOptions, RuntimeUpgradeOptions } from "./runtime.ts";
+import type { DenoRuntimeOptions } from "./runtime/deno_runtime.ts";
 
 /** Runtime options map for supported runtimes. */
 export interface RuntimeOptionsMap {
-  deno?: DenoRuntimeUpgradeOptions;
-  node?: NodeRuntimeUpgradeOptions;
-  bun?: BunRuntimeUpgradeOptions;
+  deno?: RuntimeOptions & DenoRuntimeOptions;
+  node?: RuntimeOptions;
+  bun?: RuntimeOptions;
 }
 
 /** Options for upgrading a package from any supported runtime. */
-export interface UpgradeOptions extends UpgradePackageOptions {
+export interface UpgradeOptions extends RuntimeUpgradeOptions {
   runtime?: RuntimeOptionsMap;
-  currentVersion?: string;
+  from?: string;
   force?: boolean;
 }
 
@@ -35,32 +28,32 @@ export async function upgrade(
     args,
     runtime: runtimeOptions,
     provider,
-    version,
-    currentVersion,
+    to,
+    from,
     force,
     logger,
     verbose,
   }: UpgradeOptions,
 ): Promise<void> {
   if (
     force ||
-    !currentVersion ||
-    await provider.isOutdated(name, currentVersion, version)
+    !from ||
+    await provider.isOutdated(name, from, to)
   ) {
-    if (version === "latest") {
-      logger?.log(dim("Upgrading %s to the %s version"), name, version);
+    if (to === "latest") {
+      logger?.log(dim("Upgrading %s to the %s version"), name, to);
       const { latest } = await provider.getVersions(name);
-      version = latest;
+      to = latest;
     } else {
-      logger?.log(dim("Upgrading %s to version %s"), name, version);
+      logger?.log(dim("Upgrading %s to version %s"), name, to);
     }
 
     try {
       if (provider.upgrade) {
         await provider.upgrade({
           args,
           name,
-          version,
+          to,
           main,
           logger,
           verbose,
@@ -73,7 +66,7 @@ export async function upgrade(
           args,
           ...(runtimeOptions?.[runtimeName] ?? {}),
           name,
-          version,
+          to,
           main,
           provider,
           logger,
@@ -84,8 +77,8 @@ export async function upgrade(
       logger?.error(
         red(
           `Failed to upgrade ${bold(name)} ${
-            currentVersion ? `from version ${bold(currentVersion)} ` : ""
-          }to ${bold(version)}.`,
+            from ? `from version ${bold(from)} ` : ""
+          }to ${bold(to)}.`,
         ),
       );
       throw error;
@@ -94,10 +87,10 @@ export async function upgrade(
     logger?.info(
       green(
         `Successfully upgraded ${bold(name)} from version ${
-          bold(currentVersion ?? "")
-        } to ${bold(version)}!`,
+          bold(from ?? "")
+        } to ${bold(to)}!`,
       ),
-      dim(`(${provider.getRepositoryUrl(name, version)})`),
+      dim(`(${provider.getRepositoryUrl(name, to)})`),
     );
   }
 }

command/upgrade/upgrade_command.ts

@@ -5,12 +5,12 @@ import { Command } from "../command.ts";
 import { EnumType } from "../types/enum.ts";
 import { createLogger } from "./logger.ts";
 import type { Provider, Versions } from "./provider.ts";
-import type { RuntimeUpgradeOptions } from "./runtime.ts";
+import type { RuntimeOptions } from "./runtime.ts";
 import { type RuntimeOptionsMap, upgrade } from "./upgrade.ts";
 
 export interface UpgradeCommandOptions<
   TProvider extends Provider = Provider,
-> extends RuntimeUpgradeOptions {
+> extends RuntimeOptions {
   provider: TProvider | Array<TProvider>;
   runtime?: RuntimeOptionsMap;
 }
@@ -93,8 +93,8 @@ export class UpgradeCommand extends Command {
         try {
           await upgrade({
             name,
-            version,
-            currentVersion,
+            to: version,
+            from: currentVersion,
             force,
             provider,
             verbose,

examples/command/upgrade_command.ts

@@ -9,7 +9,7 @@ import { NestLandProvider } from "../../command/upgrade/provider/nest_land.ts";
 
 await new Command()
   .name("codeview")
-  .version("0.2.2")
+  .version("0.2.1")
   .command(
     "upgrade",
     new UpgradeCommand({