forgeos 0.1.0-alpha.7 → 0.1.0-alpha.70

package/src/forge/compiler/orchestrator/run.ts

@@ -5,11 +5,18 @@ import {
 import type { GenerateOptions, GenerateResult } from "../types/cli.ts";
 import type { Diagnostic } from "../types/diagnostic.ts";
 import { classify } from "../classifier/classify.ts";
+import { getAppGraphProfile } from "../app-graph/profile.ts";
+import {
+  clearSignalProfile,
+  getSignalProfile,
+  resetSignalProfile,
+} from "../classifier/signals.ts";
 import type { ClassifiedPackage } from "../classifier/runtime-matrix.ts";
 import { buildRuntimeMatrix } from "../classifier/runtime-matrix.ts";
 import { emit } from "../emitter/emit.ts";
 import { PackageGraphCompiler } from "../package-graph/compiler.ts";
 import { resolveByPackageName } from "../recipes/registry.ts";
+import { applyWorkspaceRecipeProfile } from "../recipes/profiles.ts";
 import { checkImportGuards } from "./guards.ts";
 import {
   saveManifest,
@@ -25,8 +32,10 @@ import {
   formatCompileTimings,
   isCompileProfileEnabled,
   recordCompileTimings,
+  shouldPrintCompileProfile,
 } from "./profile.ts";
 import { plan } from "./plan.ts";
+import { getPlanProfile } from "./plan-profile.ts";
 import {
   buildAppGraphForSession,
   discoverForSession,
@@ -37,9 +46,10 @@ import { verifyLockIntegrity } from "./verify.ts";
 
 function classifyPackages(
   packageGraph: Awaited<ReturnType<PackageGraphCompiler["build"]>>["graph"],
+  workspaceRoot: string,
 ): ClassifiedPackage[] {
   return packageGraph.packages.map((api) => {
-    const recipe = resolveByPackageName(api.name) ?? undefined;
+    const recipe = applyWorkspaceRecipeProfile(resolveByPackageName(api.name), workspaceRoot);
     return {
       api,
       classification: classify(api, recipe),
@@ -100,6 +110,7 @@ export async function run(options: GenerateOptions): Promise<GenerateResult> {
 async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
   const profileEnabled = isCompileProfileEnabled();
   const runStarted = profileEnabled ? performance.now() : 0;
+  let fastCheckMs = 0;
   let generateCheckCache: GenerateResult["cache"] =
     options.check && !options.dryRun
       ? {
@@ -110,7 +121,9 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
       : undefined;
 
   if (options.check && !options.dryRun) {
+    const fastCheckStarted = profileEnabled ? performance.now() : 0;
     const fastCheck = runFastGenerateCheck(options.workspaceRoot);
+    fastCheckMs = profileEnabled ? performance.now() - fastCheckStarted : 0;
     if (fastCheck.kind === "hit") {
       return fastCheck.result;
     }
@@ -121,7 +134,9 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
     };
   }
 
+  const sessionStarted = profileEnabled ? performance.now() : 0;
   const session = getCompileSession(options.workspaceRoot);
+  const sessionMs = profileEnabled ? performance.now() - sessionStarted : 0;
 
   const discoverStarted = profileEnabled ? performance.now() : 0;
   const ctx = discoverForSession(session);
@@ -130,20 +145,40 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
 
   const pkgCompiler = new PackageGraphCompiler();
 
-  const graphStarted = profileEnabled ? performance.now() : 0;
-  const [appGraph, pkgResult] = await Promise.all([
-    buildAppGraphForSession(session),
-    pkgCompiler.build(ctx.dependencies, {
+  let appGraphMs = 0;
+  let packageGraphMs = 0;
+  const graphBuildStarted = profileEnabled ? performance.now() : 0;
+  const appGraphPromise = (async () => {
+    const started = profileEnabled ? performance.now() : 0;
+    const graph = await buildAppGraphForSession(session);
+    appGraphMs = profileEnabled ? performance.now() - started : 0;
+    return graph;
+  })();
+  const packageGraphPromise = (async () => {
+    const started = profileEnabled ? performance.now() : 0;
+    const result = await pkgCompiler.build(ctx.dependencies, {
       runtimeInspect: false,
       resolutionMode: "nodenext",
       cacheDir: ctx.cacheDir,
       concurrency: options.concurrency,
       lockfileHash: ctx.lockfileHash,
-    }),
-  ]);
-  const graphMs = profileEnabled ? performance.now() - graphStarted : 0;
+    });
+    packageGraphMs = profileEnabled ? performance.now() - started : 0;
+    return result;
+  })();
+  const [appGraph, pkgResult] = await Promise.all([appGraphPromise, packageGraphPromise]);
+  const graphBuildMs = profileEnabled ? performance.now() - graphBuildStarted : 0;
 
-  const classified = classifyPackages(pkgResult.graph);
+  const classifyStarted = profileEnabled ? performance.now() : 0;
+  if (profileEnabled) {
+    resetSignalProfile();
+  }
+  const classified = classifyPackages(pkgResult.graph, options.workspaceRoot);
+  const classifierSignals = profileEnabled ? getSignalProfile() : undefined;
+  if (profileEnabled) {
+    clearSignalProfile();
+  }
+  const classifyMs = profileEnabled ? performance.now() - classifyStarted : 0;
 
   const planStarted = profileEnabled ? performance.now() : 0;
   const emitPlan = plan({
@@ -160,8 +195,13 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
       ? "dry-run"
       : "write";
 
+  const runtimeMatrixStarted = profileEnabled ? performance.now() : 0;
   const matrix = buildRuntimeMatrix(classified);
+  const runtimeMatrixMs = profileEnabled ? performance.now() - runtimeMatrixStarted : 0;
+  const importGuardsStarted = profileEnabled ? performance.now() : 0;
   const guardDiagnostics = checkImportGuards(appGraph.moduleGraph, matrix);
+  const importGuardsMs = profileEnabled ? performance.now() - importGuardsStarted : 0;
+  const qualityGateStarted = profileEnabled ? performance.now() : 0;
   // Import guards fail `forge check`; generate/drift only surface them as warnings.
   const guardDiagnosticsForGate =
     mode === "check"
@@ -176,6 +216,7 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
     pkgResult.diagnostics,
     [...guardDiagnosticsForGate, ...(emitPlan.diagnostics ?? [])],
   );
+  const qualityGateMs = profileEnabled ? performance.now() - qualityGateStarted : 0;
 
   const emitStarted = profileEnabled ? performance.now() : 0;
   const emitResult = await emit(emitPlan, {
@@ -184,6 +225,7 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
   });
   const emitMs = profileEnabled ? performance.now() - emitStarted : 0;
 
+  const postEmitStarted = profileEnabled ? performance.now() : 0;
   const warnings: Diagnostic[] = [
     ...qualityDiagnostics.filter((d) => d.severity === "warning"),
     ...emitResult.warnings,
@@ -214,30 +256,6 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
     }
   }
 
-  if (profileEnabled) {
-    const totalMs = performance.now() - runStarted;
-    recordCompileTimings({
-      discoverMs,
-      appGraphMs: graphMs,
-      packageGraphMs: 0,
-      planMs,
-      emitMs,
-      totalMs,
-    });
-    const fsProfile = getFileSystemProfile();
-    process.stderr.write(`${formatCompileTimings({
-      discoverMs,
-      appGraphMs: graphMs,
-      packageGraphMs: 0,
-      planMs,
-      emitMs,
-      totalMs,
-    })}\n`);
-    if (fsProfile) {
-      process.stderr.write(`${formatFileSystemProfile(fsProfile)}\n`);
-    }
-  }
-
   const driftFailure =
     options.check &&
     (emitResult.changed.length > 0 ||
@@ -257,6 +275,56 @@ async function runUnlocked(options: GenerateOptions): Promise<GenerateResult> {
   const unchanged = emitResult.unchanged.filter((path) =>
     plannedPaths.has(path),
   );
+  const postEmitMs = profileEnabled ? performance.now() - postEmitStarted : 0;
+
+  if (profileEnabled) {
+    const totalMs = performance.now() - runStarted;
+    const appGraphProfile = getAppGraphProfile(appGraph);
+    const planProfile = getPlanProfile(emitPlan);
+    const unaccountedMs = Math.max(
+      0,
+      totalMs -
+        fastCheckMs -
+        sessionMs -
+        discoverMs -
+        graphBuildMs -
+        classifyMs -
+        planMs -
+        runtimeMatrixMs -
+        importGuardsMs -
+        qualityGateMs -
+        emitMs -
+        postEmitMs,
+    );
+    const timings = {
+      fastCheckMs,
+      sessionMs,
+      discoverMs,
+      graphBuildMs,
+      appGraphMs,
+      ...(appGraphProfile ? { appGraph: appGraphProfile } : {}),
+      packageGraphMs,
+      classifyMs,
+      ...(classifierSignals ? { classifierSignals } : {}),
+      planMs,
+      ...(planProfile ? { planDetail: planProfile } : {}),
+      runtimeMatrixMs,
+      importGuardsMs,
+      qualityGateMs,
+      emitMs,
+      postEmitMs,
+      unaccountedMs,
+      totalMs,
+    };
+    recordCompileTimings(timings);
+    const fsProfile = getFileSystemProfile();
+    if (shouldPrintCompileProfile()) {
+      process.stderr.write(`${formatCompileTimings(timings)}\n`);
+      if (fsProfile) {
+        process.stderr.write(`${formatFileSystemProfile(fsProfile)}\n`);
+      }
+    }
+  }
 
   return {
     changed,

package/src/forge/compiler/orchestrator/serialize.ts

@@ -86,6 +86,14 @@ function moduleGraphForAppGraphSnapshot(graph: AppGraph): AppGraph["moduleGraph"
   };
 }
 
+export function serializeConstFromJson(
+  exportName: string,
+  serializedJson: string,
+): string {
+  const parsed: unknown = JSON.parse(serializedJson.trimEnd());
+  return `export const ${exportName} = ${JSON.stringify(parsed, null, 2)} as const;\n`;
+}
+
 export function serializeAppGraphJson(graph: AppGraph): string {
   const payload = {
     schemaVersion: graph.schemaVersion,
@@ -100,26 +108,35 @@ export function serializeAppGraphJson(graph: AppGraph): string {
 }
 
 export function serializeAppGraphTs(graph: AppGraph): string {
-  const parsed: unknown = JSON.parse(serializeAppGraphJson(graph).trimEnd());
-  return `export const appGraph = ${JSON.stringify(parsed, null, 2)} as const;\n`;
+  return serializeConstFromJson("appGraph", serializeAppGraphJson(graph));
 }
 
 export function serializePackageGraphJson(graph: PackageGraph): string {
   return serializeCanonical(graph);
 }
 
-export function serializePackageGraphTs(graph: PackageGraph): string {
-  const parsed: unknown = JSON.parse(serializePackageGraphJson(graph).trimEnd());
-  return `export const packageGraph = ${JSON.stringify(parsed, null, 2)} as const;\n`;
+export function serializePackageGraphTs(_graph: PackageGraph): string {
+  return [
+    "import packageGraphJson from \"./packageGraph.json\" with { type: \"json\" };",
+    "",
+    "export type PackageGraph = typeof packageGraphJson;",
+    "export const packageGraph = packageGraphJson;",
+    "",
+  ].join("\n");
 }
 
 export function serializeRuntimeMatrixJson(matrix: RuntimeMatrix): string {
   return serializeCanonical(matrix);
 }
 
-export function serializeRuntimeMatrixTs(matrix: RuntimeMatrix): string {
-  const parsed: unknown = JSON.parse(serializeRuntimeMatrixJson(matrix).trimEnd());
-  return `export const runtimeMatrix = ${JSON.stringify(parsed, null, 2)} as const;\n`;
+export function serializeRuntimeMatrixTs(_matrix: RuntimeMatrix): string {
+  return [
+    "import runtimeMatrixJson from \"./runtimeMatrix.json\" with { type: \"json\" };",
+    "",
+    "export type RuntimeMatrix = typeof runtimeMatrixJson;",
+    "export const runtimeMatrix = runtimeMatrixJson;",
+    "",
+  ].join("\n");
 }
 
 export function serializeImportGuardsJson(
@@ -890,6 +907,7 @@ export function serializeSubscriptionManifestTs(
 }
 
 export function serializeApiJson(surface: ApiSurface): string {
+  const external = surface.external ?? { services: {}, commands: {}, queries: {} };
   return serializeCanonical({
     schemaVersion: surface.schemaVersion,
     generatorVersion: surface.generatorVersion,
@@ -899,6 +917,7 @@ export function serializeApiJson(surface: ApiSurface): string {
     liveQueries: surface.liveQueries,
     actions: surface.actions,
     workflows: surface.workflows,
+    external,
   });
 }
 
@@ -933,6 +952,12 @@ export function serializeReactManifestJson(
   return serializeCanonical(manifest);
 }
 
+export function serializeVueManifestJson(
+  manifest: import("../client-sdk/build-manifest.ts").VueManifest,
+): string {
+  return serializeCanonical(manifest);
+}
+
 export function serializeTestGraphJson(graph: TestGraph): string {
   return serializeCanonical(graph);
 }

package/src/forge/compiler/orchestrator/types.ts

@@ -3,7 +3,7 @@ import type { Dependency } from "../types/package-graph.ts";
 import type { PackageManager } from "../types/runtime.ts";
 import type { SourceFileIndex } from "./workspace-index.ts";
 
-export const ORCHESTRATOR_MANIFEST_VERSION = "1";
+export const ORCHESTRATOR_MANIFEST_VERSION = "2";
 
 export interface DiscoverContext {
   workspaceRoot: string;

package/src/forge/compiler/package-graph/compiler.ts

@@ -271,6 +271,7 @@ export class PackageGraphCompiler {
 
     const partialApi = {
       name: dep.name,
+      ...(packageJson.name && packageJson.name !== dep.name ? { packageName: packageJson.name } : {}),
       version: dep.version,
       packageManager: dep.packageManager,
       resolutionMode: opts.resolutionMode,
@@ -454,10 +455,11 @@ function portableDtsPath(dtsPath: string, dep: Pick<Dependency, "installPath" |
 }
 
 function readPackageJson(installPath: string): {
+  name?: string;
   exports?: unknown;
 } {
   const raw = readTextFile(join(installPath, "package.json"));
-  return JSON.parse(raw) as { exports?: unknown };
+  return JSON.parse(raw) as { name?: string; exports?: unknown };
 }
 
 function resolveSandboxBackend(

package/src/forge/compiler/package-graph/constants.ts

@@ -1,4 +1,4 @@
 export const PACKAGE_GRAPH_SCHEMA_VERSION = "1.0.0";
-export const PACKAGE_ANALYZER_VERSION = "0.2.0";
+export const PACKAGE_ANALYZER_VERSION = "0.2.1";
 export { GENERATOR_VERSION } from "../../version.ts";
 export const DEFAULT_PATTERN_EXPANSION_LIMIT = 50;

package/src/forge/compiler/package-graph/dts-extractor.ts

@@ -5,8 +5,21 @@ import { stubExportClassification } from "./capabilities-stub.ts";
 import { extractExamples, extractJsDoc } from "./jsdoc.ts";
 import { createResolutionCompilerOptions } from "./resolve.ts";
 import type { ResolutionMode } from "../types/runtime.ts";
+
+function canonicalizeNodeModulesImportPaths(text: string): string {
+  return text.replace(/import\("([^"]+)"/g, (match, importPath: string) => {
+    const normalized = importPath.replace(/\\/g, "/");
+    const marker = "/node_modules/";
+    const markerIndex = normalized.lastIndexOf(marker);
+    if (markerIndex < 0) {
+      return match;
+    }
+    return `import("${normalized.slice(markerIndex + marker.length)}"`;
+  });
+}
+
 export function normalizeSignatureText(text: string): string {
-  return text
+  return canonicalizeNodeModulesImportPaths(text)
     .replace(/\r\n/g, "\n")
     .replace(/\s+/g, " ")
     .trim();

package/src/forge/compiler/package-manager/adapter.ts

@@ -83,7 +83,10 @@ async function runInstall(
   executor: CommandExecutor,
 ): Promise<PmAddResult> {
   const ignoreScripts = opts.ignoreScripts ?? true;
-  const argv = buildAddCommand(pm, spec, { ignoreScripts });
+  const argv = buildAddCommand(pm, spec, {
+    ignoreScripts,
+    workspace: opts.workspace,
+  });
   const lockBefore = hashLockfiles(opts.cwd, pm);
 
   const result = await executor.run(argv, { cwd: opts.cwd });

package/src/forge/compiler/package-manager/commands.ts

@@ -2,6 +2,7 @@ import type { PackageManager } from "../types/runtime.ts";
 
 export interface BuildAddCommandOptions {
   ignoreScripts: boolean;
+  workspace?: string;
 }
 
 /**
@@ -27,6 +28,9 @@ export function buildAddCommand(
       if (ignoreScripts) {
         args.push("--ignore-scripts");
       }
+      if (options.workspace) {
+        args.push("--workspace", options.workspace);
+      }
       return args;
     }
     case "pnpm": {

package/src/forge/compiler/package-manager/executor.ts

@@ -88,11 +88,40 @@ export class PackageManagerCommandError extends Error {
   }
 }
 
+function quoteWindowsShellArg(arg: string): string {
+  if (/^[a-zA-Z0-9@._/:=-]+$/.test(arg)) {
+    return arg;
+  }
+  return `"${arg.replace(/(["^&|<>])/g, "^$1")}"`;
+}
+
+function spawnArgvForWindowsScript(originalArgv: string[], resolvedArgv: string[]): string[] {
+  const originalCommand = originalArgv[0] ?? resolvedArgv[0]!;
+  const command =
+    originalCommand.includes("\\") ||
+    originalCommand.includes("/") ||
+    isAbsolute(originalCommand)
+      ? resolvedArgv[0]!
+      : originalCommand;
+  const commandPart = command === originalCommand ? command : quoteWindowsShellArg(command);
+  const args = originalArgv.slice(1).map(quoteWindowsShellArg).join(" ");
+  return [
+    process.env.ComSpec ?? "cmd.exe",
+    "/d",
+    "/c",
+    `${commandPart}${args ? ` ${args}` : ""}`,
+  ];
+}
+
 export const defaultCommandExecutor: CommandExecutor = {
   async run(argv, options) {
     const resolvedArgv = resolvePackageManagerArgv(argv);
+    const spawnArgv =
+      process.platform === "win32" && /\.(?:cmd|bat)$/i.test(resolvedArgv[0] ?? "")
+        ? spawnArgvForWindowsScript(argv, resolvedArgv)
+        : resolvedArgv;
     return new Promise<CommandRunResult>((resolve, reject) => {
-      const child = spawn(resolvedArgv[0]!, resolvedArgv.slice(1), {
+      const child = spawn(spawnArgv[0]!, spawnArgv.slice(1), {
         cwd: options.cwd,
         env: options.env ?? process.env,
         windowsHide: true,

package/src/forge/compiler/package-manager/version.ts

@@ -1,23 +1,21 @@
-import { join } from "node:path";
+import { dirname, join, parse } from "node:path";
 import { nodeFileSystem } from "../fs/index.ts";
 import { parsePackageName } from "./parse-spec.ts";
 
-export function readInstalledVersion(
-  specOrName: string,
-  cwd: string,
-): string | null {
-  const name = parsePackageName(specOrName);
-  const segments = name.startsWith("@")
-    ? name.split("/")
-    : [name];
-  const pkgJsonPath = join(cwd, "node_modules", ...segments, "package.json");
+function packageJsonPath(cwd: string, packageName: string): string {
+  const segments = packageName.startsWith("@")
+    ? packageName.split("/")
+    : [packageName];
+  return join(cwd, "node_modules", ...segments, "package.json");
+}
 
-  if (!nodeFileSystem.exists(pkgJsonPath)) {
+function readVersionAt(path: string): string | null {
+  if (!nodeFileSystem.exists(path)) {
     return null;
   }
 
   try {
-    const pkg = JSON.parse((nodeFileSystem.readText(pkgJsonPath) ?? "")) as {
+    const pkg = JSON.parse((nodeFileSystem.readText(path) ?? "")) as {
       version?: string;
     };
     return typeof pkg.version === "string" ? pkg.version : null;
@@ -25,3 +23,29 @@ export function readInstalledVersion(
     return null;
   }
 }
+
+export function readInstalledVersion(
+  specOrName: string,
+  cwd: string,
+): string | null {
+  const name = parsePackageName(specOrName);
+  let current = cwd;
+  const root = parse(cwd).root;
+
+  while (true) {
+    const version = readVersionAt(packageJsonPath(current, name));
+    if (version) {
+      return version;
+    }
+
+    if (current === root) {
+      return null;
+    }
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}