forgeos 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/forge/cli/deps.ts

@@ -23,6 +23,7 @@ import {
   listOutdatedFromFixture,
   parseUpgradeTarget,
 } from "../compiler/package-upgrades/planner.ts";
+import { parsePackageName } from "../compiler/package-manager/parse-spec.ts";
 import {
   applyUpgradePlan,
   rollbackUpgradePlan,
@@ -72,15 +73,55 @@ function readGeneratedJson<T>(workspaceRoot: string, relative: string): T | null
   return JSON.parse(raw) as T;
 }
 
-function planPathFor(workspaceRoot: string, planIdOrPath: string): string {
-  if (nodeFileSystem.exists(planIdOrPath)) {
-    return planIdOrPath;
-  }
-  const direct = join(workspaceRoot, planIdOrPath);
-  if (nodeFileSystem.exists(direct)) {
-    return direct;
+function resolvePlanPathFor(
+  workspaceRoot: string,
+  planIdOrPath: string,
+): { ok: true; path: string } | { ok: false; diagnostics: Diagnostic[] } {
+  const candidates = [
+    planIdOrPath,
+    join(workspaceRoot, planIdOrPath),
+    join(workspaceRoot, ".forge", "upgrades", planIdOrPath, "plan.json"),
+  ];
+
+  for (const candidate of candidates) {
+    if (!nodeFileSystem.exists(candidate)) {
+      continue;
+    }
+    if (!nodeFileSystem.isDirectory(candidate)) {
+      return { ok: true, path: candidate };
+    }
+    const nestedPlan = join(candidate, "plan.json");
+    if (nodeFileSystem.exists(nestedPlan) && !nodeFileSystem.isDirectory(nestedPlan)) {
+      return { ok: true, path: nestedPlan };
+    }
+    return {
+      ok: false,
+      diagnostics: [{
+        severity: "error",
+        code: "FORGE_DEPS_TARGET_NOT_FOUND",
+        message: `upgrade plan directory '${planIdOrPath}' does not contain plan.json`,
+        fixHint: "Pass the plan.json file returned by forge deps upgrade-plan, or rerun upgrade-plan.",
+        suggestedCommands: [
+          `forge deps upgrade-apply ${nestedPlan} --json`,
+          "forge deps upgrade-plan <package> --to latest --json",
+        ],
+      }],
+    };
   }
-  return join(workspaceRoot, ".forge", "upgrades", planIdOrPath, "plan.json");
+
+  return {
+    ok: false,
+    diagnostics: [{
+      severity: "error",
+      code: "FORGE_DEPS_TARGET_NOT_FOUND",
+      message: `upgrade plan '${planIdOrPath}' was not found`,
+      fixHint: "Use the planDir or plan.json path returned by forge deps upgrade-plan.",
+      suggestedCommands: [
+        `forge deps upgrade-apply .forge/upgrades/${planIdOrPath}/plan.json --json`,
+        "forge deps upgrade-plan <package> --to latest --json",
+      ],
+    }],
+  };
 }
 
 function findPackage(workspaceRoot: string, packageName: string): {
@@ -92,7 +133,9 @@ function findPackage(workspaceRoot: string, packageName: string): {
   const lock = nodeFileSystem.exists(join(workspaceRoot, "forge.lock"))
     ? (JSON.parse((nodeFileSystem.readText(join(workspaceRoot, "forge.lock")) ?? "")) as ForgeLock)
     : null;
-  const pkg = graph?.packages.find((candidate) => candidate.name === packageName);
+  const pkg = graph?.packages.find((candidate) =>
+    candidate.name === packageName || candidate.packageName === packageName
+  );
   return { graph, pkg, lock };
 }
 
@@ -241,6 +284,53 @@ function runtimeCompatPackage(workspaceRoot: string, packageName: string): DepsC
   };
 }
 
+function normalizePackageInput(packageSpec: string | undefined): {
+  packageName?: string;
+  requestedPackageSpec?: string;
+} {
+  if (!packageSpec) {
+    return {};
+  }
+  const packageName = parsePackageName(packageSpec);
+  return {
+    packageName,
+    ...(packageName !== packageSpec ? { requestedPackageSpec: packageSpec } : {}),
+  };
+}
+
+function withPackageInput(
+  result: DepsCommandResult,
+  packageName: string,
+  requestedPackageSpec: string | undefined,
+): DepsCommandResult {
+  if (!requestedPackageSpec) {
+    return result;
+  }
+  const data = result.data && typeof result.data === "object" && !Array.isArray(result.data)
+    ? {
+        requestedPackageSpec,
+        package: packageName,
+        ...(result.data as Record<string, unknown>),
+      }
+    : {
+        requestedPackageSpec,
+        package: packageName,
+      };
+  return {
+    ...result,
+    data,
+    diagnostics: result.diagnostics.map((diagnostic) =>
+      diagnostic.code === "FORGE_DEPS_PACKAGE_NOT_INSTALLED"
+        ? {
+            ...diagnostic,
+            message: `${diagnostic.message} (requested spec: '${requestedPackageSpec}')`,
+            fixHint: "Forge strips version/range suffixes for deps lookup. Run forge generate, then retry with the normalized package name if needed.",
+          }
+        : diagnostic,
+    ),
+  };
+}
+
 export async function runDepsCommand(options: DepsCommandOptions): Promise<DepsCommandResult> {
   if (options.subcommand === "outdated") {
     return {
@@ -251,41 +341,60 @@ export async function runDepsCommand(options: DepsCommandOptions): Promise<DepsC
     };
   }
 
+  const packageInput = normalizePackageInput(options.packageName);
+  const packageName = packageInput.packageName;
+
   if (options.subcommand === "inspect") {
-    if (!options.packageName) {
+    if (!packageName) {
       return missingPackage();
     }
-    return inspectPackage(options.workspaceRoot, options.packageName);
+    return withPackageInput(
+      inspectPackage(options.workspaceRoot, packageName),
+      packageName,
+      packageInput.requestedPackageSpec,
+    );
   }
 
   if (options.subcommand === "api") {
-    if (!options.packageName) {
+    if (!packageName) {
       return missingPackage();
     }
-    return inspectPackageApi(options.workspaceRoot, options.packageName, options.symbolName);
+    return withPackageInput(
+      inspectPackageApi(options.workspaceRoot, packageName, options.symbolName),
+      packageName,
+      packageInput.requestedPackageSpec,
+    );
   }
 
   if (options.subcommand === "trace") {
-    if (!options.packageName) {
+    if (!packageName) {
       return missingPackage();
     }
-    return tracePackage(options.workspaceRoot, options.packageName);
+    return withPackageInput(
+      tracePackage(options.workspaceRoot, packageName),
+      packageName,
+      packageInput.requestedPackageSpec,
+    );
   }
 
   if (options.subcommand === "runtime-compat") {
-    if (!options.packageName) {
+    if (!packageName) {
       return missingPackage();
     }
-    return runtimeCompatPackage(options.workspaceRoot, options.packageName);
+    return withPackageInput(
+      runtimeCompatPackage(options.workspaceRoot, packageName),
+      packageName,
+      packageInput.requestedPackageSpec,
+    );
   }
 
   if (options.subcommand === "diff" || options.subcommand === "upgrade-plan" || options.subcommand === "risk") {
-    if (!options.packageName) {
+    if (!packageName) {
       return missingPackage();
     }
     const planned = await createUpgradePlan({
       workspaceRoot: options.workspaceRoot,
-      packageName: options.packageName,
+      packageName,
       target: parseUpgradeTarget(options.target),
       writeArtifacts: options.subcommand !== "diff" && options.subcommand !== "risk",
     });
@@ -314,21 +423,29 @@ export async function runDepsCommand(options: DepsCommandOptions): Promise<DepsC
               planDir: planned.planDir,
             };
 
-    return {
+    return withPackageInput({
       ok: planned.ok,
       data,
       diagnostics: planned.diagnostics,
       exitCode: planned.exitCode,
-    };
+    }, packageName, packageInput.requestedPackageSpec);
   }
 
   if (options.subcommand === "upgrade-apply") {
     if (!options.planPath) {
       return missingPlan();
     }
+    const resolvedPlan = resolvePlanPathFor(options.workspaceRoot, options.planPath);
+    if (!resolvedPlan.ok) {
+      return {
+        ok: false,
+        diagnostics: resolvedPlan.diagnostics,
+        exitCode: 1,
+      };
+    }
     const applied = await applyUpgradePlan({
       workspaceRoot: options.workspaceRoot,
-      planPath: planPathFor(options.workspaceRoot, options.planPath),
+      planPath: resolvedPlan.path,
       yes: options.yes,
       allowScripts: options.allowScripts,
       skipTests: options.skipTests,
@@ -340,6 +457,7 @@ export async function runDepsCommand(options: DepsCommandOptions): Promise<DepsC
         applied: applied.applied,
         rolledBack: applied.rolledBack,
         reinstallCommand: applied.plan?.rollback.reinstallCommand,
+        planPath: resolvedPlan.path,
       },
       diagnostics: applied.diagnostics,
       exitCode: applied.exitCode,
@@ -350,15 +468,24 @@ export async function runDepsCommand(options: DepsCommandOptions): Promise<DepsC
     if (!options.planPath) {
       return missingPlan();
     }
+    const resolvedPlan = resolvePlanPathFor(options.workspaceRoot, options.planPath);
+    if (!resolvedPlan.ok) {
+      return {
+        ok: false,
+        diagnostics: resolvedPlan.diagnostics,
+        exitCode: 1,
+      };
+    }
     const rolledBack = rollbackUpgradePlan({
       workspaceRoot: options.workspaceRoot,
-      planPath: planPathFor(options.workspaceRoot, options.planPath),
+      planPath: resolvedPlan.path,
     });
     return {
       ok: rolledBack.ok,
       data: {
         rolledBack: rolledBack.rolledBack,
         reinstallCommand: rolledBack.plan?.rollback.reinstallCommand,
+        planPath: resolvedPlan.path,
       },
       diagnostics: rolledBack.diagnostics,
       exitCode: rolledBack.exitCode,