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

package/src/forge/compiler/make-registry/build.ts

@@ -34,8 +34,9 @@ export function buildMakeRegistry(generatorVersion: string): MakeRegistryArtifac
       "forge make list --json",
       "forge make explain <primitive> --json",
       "forge make ui --framework vite --dry-run --json",
+      "forge make ui --framework nuxt --dry-run --json",
       "forge make ai-chat support --dry-run --json",
-      "forge make resource <name> --fields title:text,status:enum(open,closed) --dry-run --json",
+      "forge make resource <name> --fields title:text,status:enum=open+closed --dry-run --json",
       "forge make resource <name> --fields title:text --with-ui --yes",
       "forge make apply <planId>",
       "forge make rollback <planId>",
@@ -113,16 +114,14 @@ export function buildMakeRegistry(generatorVersion: string): MakeRegistryArtifac
       },
       {
         name: "ui",
-        summary: "Add a Vite React frontend shell with ForgeProvider devAuth and a generated client bridge.",
+        summary: "Add a Vite React or Nuxt Vue frontend shell with generated Forge client bindings.",
         creates: [
           "web/package.json",
-          "web/index.html",
-          "web/src/lib/forge.ts",
-          "web/src/main.tsx",
-          "web/src/App.tsx",
+          "web/src/lib/forge.ts or web/composables/forge.ts",
+          "web/src/main.tsx or web/app.vue",
         ],
         modifies: [],
-        examples: ["forge make ui --framework vite --yes"],
+        examples: ["forge make ui --framework vite --yes", "forge make ui --framework nuxt --yes"],
       },
       {
         name: "ai-chat",
@@ -147,7 +146,7 @@ export function buildMakeRegistry(generatorVersion: string): MakeRegistryArtifac
           "tests/make-generated/*",
         ],
         modifies: ["src/forge/schema.ts", "src/policies.ts"],
-        examples: ["forge make resource invoices --fields amount:number,status:enum(draft,paid) --with-ui --yes"],
+        examples: ["forge make resource invoices --fields amount:number,status:enum=draft+paid --with-ui --yes"],
       },
     ],
   };
@@ -166,7 +165,7 @@ export function buildMakeTemplates(): MakeTemplateArtifact {
       { name: "workflow", sourceKind: "runtime", outputPattern: "src/workflows/<name>.ts" },
       { name: "component", sourceKind: "frontend", outputPattern: "web/components/<name>.tsx" },
       { name: "page", sourceKind: "frontend", outputPattern: "web/app/<route>/page.tsx" },
-      { name: "ui", sourceKind: "frontend", outputPattern: "web/src/App.tsx" },
+      { name: "ui", sourceKind: "frontend", outputPattern: "web/src/App.tsx or web/app.vue" },
       { name: "ai-chat", sourceKind: "frontend", outputPattern: "web/components/<name>AiChat.tsx" },
       { name: "placeholder-test", sourceKind: "test", outputPattern: "tests/make-generated/<name>.test.ts" },
     ],

package/src/forge/compiler/orchestrator/fast-check.ts

@@ -8,6 +8,7 @@ import type { GenerateResult } from "../types/cli.ts";
 import type { Diagnostic } from "../types/diagnostic.ts";
 import { discover } from "./discover.ts";
 import { loadManifest } from "./manifest.ts";
+import { ORCHESTRATOR_MANIFEST_VERSION } from "./types.ts";
 
 export type FastGenerateCheckResult =
   | {
@@ -55,6 +56,9 @@ export function runFastGenerateCheck(workspaceRootInput: string): FastGenerateCh
   const manifest = loadManifest(cacheDir);
   const trackedFiles = Object.keys(manifest.fileHashes).sort();
 
+  if (manifest.schemaVersion !== ORCHESTRATOR_MANIFEST_VERSION) {
+    return { kind: "miss", reason: "manifest schema version changed" };
+  }
   if (!manifest.inputFingerprint || trackedFiles.length === 0) {
     return { kind: "miss", reason: "manifest missing input fingerprint or file hashes" };
   }

package/src/forge/compiler/orchestrator/generate-lock.ts

@@ -37,12 +37,22 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function lockTimeoutDiagnostic(lockPath: string, timeoutMs: number): Diagnostic {
+function lockTimeoutDiagnostic(lockPath: string, timeoutMs: number, ownerPid: number | null): Diagnostic {
+  const owner = ownerPid === null ? "unknown owner" : `owner pid ${ownerPid}`;
   return createDiagnostic({
     severity: "error",
     code: "FORGE_GENERATE_LOCKED",
-    message: `forge generate is already running or a stale generate lock exists at ${lockPath} after ${timeoutMs}ms`,
+    message:
+      `forge generate is already running (${owner}) or a stale generate lock exists at ${lockPath} after ${timeoutMs}ms. ` +
+      "Avoid running forge generate, forge dev --once, and forge verify concurrently in the same workspace.",
     file: lockPath,
+    fixHint:
+      "Wait for the active Forge command to finish. If the owner pid is gone, remove .forge/locks/generate.lock and retry.",
+    suggestedCommands: [
+      "forge status --json",
+      "forge generate --check --json",
+      "forge dev --once --json",
+    ],
   });
 }
 
@@ -125,9 +135,10 @@ export async function acquireGenerateLock(
       }
 
       if (Date.now() - startedAt >= timeoutMs) {
+        const ownerPid = readLockOwnerPid(lockPath);
         return {
           ok: false,
-          diagnostic: lockTimeoutDiagnostic(lockPath, timeoutMs),
+          diagnostic: lockTimeoutDiagnostic(lockPath, timeoutMs, ownerPid),
           failureKind: GENERATE_LOCK_FAILURE_KIND,
         };
       }

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

@@ -83,7 +83,7 @@ export function updateManifestAfterWrite(
 ): OrchestratorManifest {
   return {
     ...manifest,
-    fileHashes: { ...manifest.fileHashes, ...fileHashes },
+    fileHashes,
     priorAppGraph,
     inputFingerprint,
     ...(sourceFileIndex !== undefined ? { sourceFileIndex } : {}),

package/src/forge/compiler/orchestrator/plan-profile.ts

@@ -0,0 +1,23 @@
+import type { EmitPlan } from "../types/emit.ts";
+
+export interface PlanPhaseTimings {
+  coreArtifactsMs: number;
+  agentArtifactsMs: number;
+  supportArtifactsMs: number;
+  fileRenderMs: number;
+  finalizeMs: number;
+  totalMs: number;
+}
+
+const planProfiles = new WeakMap<EmitPlan, PlanPhaseTimings>();
+
+export function recordPlanProfile(
+  plan: EmitPlan,
+  timings: PlanPhaseTimings,
+): void {
+  planProfiles.set(plan, timings);
+}
+
+export function getPlanProfile(plan: EmitPlan): PlanPhaseTimings | undefined {
+  return planProfiles.get(plan);
+}

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

@@ -27,9 +27,15 @@ import {
   buildSubscriptionManifest,
 } from "../live-query-registry/build.ts";
 import { buildApiSurface } from "../api-surface/build.ts";
+import {
+  buildExternalServiceGraph,
+  serializeExternalServiceGraphJson,
+  serializeExternalServiceGraphTs,
+} from "../external-manifest/registry.ts";
 import {
   buildClientManifest,
   buildReactManifest,
+  buildVueManifest,
 } from "../client-sdk/build-manifest.ts";
 import {
   buildFrontendGraph,
@@ -43,6 +49,9 @@ import {
   renderReactDts,
   renderReactManifestTs,
   renderReactTs,
+  renderVueDts,
+  renderVueManifestTs,
+  renderVueTs,
 } from "../client-sdk/render-client.ts";
 import { buildSqlPlan } from "../data-graph/sql/ddl.ts";
 import { buildRlsArtifacts } from "../data-graph/rls/build.ts";
@@ -85,6 +94,8 @@ import { detectCapabilities } from "../classifier/capabilities.ts";
 import { detectSecrets } from "../classifier/secrets.ts";
 import { resolveByPackageName } from "../recipes/registry.ts";
 import { RECIPE_SCHEMA_VERSION } from "../recipes/definitions.ts";
+import type { IntegrationRecipe } from "../types/integration.ts";
+import type { RuntimeContext } from "../types/runtime.ts";
 import {
   FORGE_LOCK_SCHEMA_VERSION,
   GENERATED_DIR,
@@ -95,9 +106,16 @@ import { hashStable } from "../primitives/hash.ts";
 import { stableSortEmitFiles } from "../primitives/sort.ts";
 import { detectOrphanedGeneratedFiles } from "./orphans.ts";
 import type { DiscoverContext } from "./types.ts";
+import {
+  createRenderContext,
+  parseAdapterContext,
+  renderAdapterModule,
+  renderIntegrationDoc,
+  renderIntegrationModule,
+  renderTestkitModule,
+} from "../integration/render.ts";
 import {
   serializeAppGraphJson,
-  serializeAppGraphTs,
   serializeDataGraphJson,
   serializeDataGraphTs,
   serializeImportGuardsJson,
@@ -110,6 +128,7 @@ import {
   serializeRuntimeGraphTs,
   serializeRuntimeMatrixJson,
   serializeRuntimeMatrixTs,
+  serializeConstFromJson,
   serializeRuntimeRegistryTs,
   serializeDevManifestJson,
   serializeDevManifestTs,
@@ -201,10 +220,12 @@ import {
   serializeClientApiTsExport,
   serializeClientManifestJson,
   serializeReactManifestJson,
+  serializeVueManifestJson,
   buildMockMapEntries,
 } from "./serialize.ts";
-import { buildDefaultAuthRegistry, AUTH_ENV } from "../../runtime/auth/config.ts";
+import { buildDefaultAuthRegistry, buildWorkOSAuthRegistry, AUTH_ENV } from "../../runtime/auth/config.ts";
 import type { EnvSchema } from "../types/secret-registry.ts";
+import { recordPlanProfile } from "./plan-profile.ts";
 
 export interface PlanInput {
   appGraph: AppGraph;
@@ -222,6 +243,156 @@ function makeEmitFile(path: string, content: string): EmitFile {
   };
 }
 
+function primaryPackageName(recipe: IntegrationRecipe): string {
+  return recipe.packages[0]?.packageName ?? recipe.alias;
+}
+
+function packageNamesForRecipe(recipe: IntegrationRecipe): string[] {
+  return recipe.packages.map((pkg) => pkg.packageName);
+}
+
+function compatibleContextsForRecipe(pkg: ClassifiedPackage): RuntimeContext[] {
+  const recipe = pkg.recipe ?? resolveByPackageName(pkg.api.name);
+  if (!recipe) {
+    return [...pkg.classification.compatible];
+  }
+
+  const contexts = new Set<RuntimeContext>(recipe.contexts.allowed);
+  for (const recipePackage of recipe.packages) {
+    for (const ctx of recipePackage.contexts?.allowed ?? []) {
+      contexts.add(ctx);
+    }
+  }
+  for (const ctx of pkg.classification.compatible) {
+    contexts.add(ctx);
+  }
+  return [...contexts];
+}
+
+function shouldEmitAdapter(
+  adapterFilename: string,
+  compatible: RuntimeContext[],
+): boolean {
+  const context = parseAdapterContext(adapterFilename);
+  return context === null || compatible.includes(context);
+}
+
+function buildRecipeGeneratedFiles(pkg: ClassifiedPackage): string[] {
+  const recipe = pkg.recipe ?? resolveByPackageName(pkg.api.name);
+  if (!recipe) {
+    return [];
+  }
+
+  const compatible = compatibleContextsForRecipe(pkg);
+  const paths: string[] = [];
+
+  for (const adapter of recipe.adapters) {
+    if (shouldEmitAdapter(adapter, compatible)) {
+      paths.push(`${GENERATED_DIR}/packages/${adapter}`);
+    }
+  }
+  for (const integration of recipe.integrations ?? []) {
+    paths.push(`${GENERATED_DIR}/integrations/${integration}`);
+  }
+  for (const testkit of recipe.testkits) {
+    paths.push(`${GENERATED_DIR}/testkits/${testkit}`);
+  }
+  for (const doc of recipe.docs) {
+    paths.push(`${GENERATED_DIR}/docs/${doc}`);
+  }
+
+  paths.push(
+    `${GENERATED_DIR}/runtimeMatrix.ts`,
+    `${GENERATED_DIR}/runtimeMatrix.json`,
+    `${GENERATED_DIR}/importGuards.ts`,
+    `${GENERATED_DIR}/importGuards.json`,
+  );
+
+  return paths.sort();
+}
+
+function buildIntegrationArtifactFiles(pkg: ClassifiedPackage): EmitFile[] {
+  const recipe = pkg.recipe ?? resolveByPackageName(pkg.api.name);
+  if (!recipe) {
+    return [];
+  }
+
+  const compatible = compatibleContextsForRecipe(pkg);
+  const incompatible = [...pkg.classification.incompatible];
+  const secrets = detectSecrets(pkg.api, recipe);
+  const packageNames = packageNamesForRecipe(recipe);
+  const packageName = primaryPackageName(recipe);
+  const templateCtx = createRenderContext({
+    alias: recipe.alias,
+    recipe,
+    context: "server",
+    packageName,
+    packageNames,
+    secrets,
+    compatible,
+    incompatible,
+  });
+  const files: EmitFile[] = [];
+
+  for (const adapter of recipe.adapters) {
+    if (!shouldEmitAdapter(adapter, compatible)) {
+      continue;
+    }
+    const context = parseAdapterContext(adapter) ?? "server";
+    files.push(
+      makeEmitFile(
+        `${GENERATED_DIR}/packages/${adapter}`,
+        renderAdapterModule({
+          alias: recipe.alias,
+          recipe,
+          context,
+          packageName,
+          packageNames,
+          secrets,
+          compatible,
+          incompatible,
+        }),
+      ),
+    );
+  }
+
+  for (const integration of recipe.integrations ?? []) {
+    files.push(
+      makeEmitFile(
+        `${GENERATED_DIR}/integrations/${integration}`,
+        renderIntegrationModule(integration, templateCtx),
+      ),
+    );
+  }
+
+  for (const testkit of recipe.testkits) {
+    files.push(
+      makeEmitFile(
+        `${GENERATED_DIR}/testkits/${testkit}`,
+        renderTestkitModule(recipe.alias, packageName, templateCtx),
+      ),
+    );
+  }
+
+  for (const doc of recipe.docs) {
+    files.push(
+      makeEmitFile(
+        `${GENERATED_DIR}/docs/${doc}`,
+        renderIntegrationDoc({
+          alias: recipe.alias,
+          recipe,
+          packageNames,
+          secrets,
+          compatible,
+          incompatible,
+        }),
+      ),
+    );
+  }
+
+  return files;
+}
+
 function buildLockEntry(pkg: ClassifiedPackage): ForgeLockEntry {
   const recipe = pkg.recipe ?? resolveByPackageName(pkg.api.name);
   const secrets = detectSecrets(pkg.api, recipe ?? undefined);
@@ -239,7 +410,7 @@ function buildLockEntry(pkg: ClassifiedPackage): ForgeLockEntry {
       secrets,
     },
     secrets,
-    generatedFiles: [],
+    generatedFiles: buildRecipeGeneratedFiles(pkg),
     contentChecksum: pkg.api.contentChecksum,
   };
 }
@@ -291,7 +462,15 @@ function augmentEnvSchemaWithAuthVars(schema: EnvSchema): EnvSchema {
   };
 }
 
+function hasWorkOSAuth(classified: PlanInput["classified"]): boolean {
+  return classified.some((item) =>
+    item.recipe?.alias === "workos" || item.api.name === "@workos-inc/node"
+  );
+}
+
 export function plan(input: PlanInput): EmitPlan {
+  const started = performance.now();
+  let checkpoint = started;
   const matrix = buildRuntimeMatrix(input.classified);
   const dataGraph = buildDataGraph(input.appGraph);
   const sqlPlan = buildSqlPlan(dataGraph);
@@ -300,7 +479,8 @@ export function plan(input: PlanInput): EmitPlan {
   const workflowSubscriptions = buildWorkflowSubscriptions(workflowRegistry);
   const telemetryRegistry = buildTelemetryRegistry(input.appGraph);
   const telemetrySinks = buildTelemetrySinks(input.classified);
-  const policyRegistry = buildPolicyRegistry(input.appGraph);
+  const externalServices = buildExternalServiceGraph(input.ctx.workspaceRoot);
+  const policyRegistry = buildPolicyRegistry(input.appGraph, externalServices);
   const permissionMatrix = buildPermissionMatrixFromRegistry(policyRegistry);
   const tenantScope = buildTenantScope(dataGraph);
   const secretRegistry = buildSecretRegistry(input.classified);
@@ -311,7 +491,9 @@ export function plan(input: PlanInput): EmitPlan {
     ),
   );
   const configRegistry = buildConfigRegistry(secretRegistry);
-  const authRegistry = buildDefaultAuthRegistry(tenantScope.tables.length > 0);
+  const authRegistry = hasWorkOSAuth(input.classified)
+    ? buildWorkOSAuthRegistry(tenantScope.tables.length > 0)
+    : buildDefaultAuthRegistry(tenantScope.tables.length > 0);
   const aiRegistry = buildAiRegistry(input.appGraph, input.classified);
   const aiModels = buildAiModels();
   const queryRegistry = buildQueryRegistry(input.appGraph);
@@ -323,15 +505,20 @@ export function plan(input: PlanInput): EmitPlan {
     queryRegistry,
     liveQueryRegistry,
     workflowRegistry,
+    externalServices,
   );
   const clientManifest = buildClientManifest(apiSurface, input.classified);
   const reactManifest = buildReactManifest(clientManifest);
+  const vueManifest = buildVueManifest(clientManifest);
   const frontendGraph = buildFrontendGraph({
     workspaceRoot: input.ctx.workspaceRoot,
     clientManifest,
   });
   const devManifest = buildDevManifest(runtimeGraph, queryRegistry, input.appGraph);
   const mockMapEntries = buildMockMapEntries(input.classified);
+  const coreArtifactsMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
+
   const agentArtifacts = buildAgentContractArtifacts({
     workspaceRoot: input.ctx.workspaceRoot,
     appGraph: input.appGraph,
@@ -352,8 +539,12 @@ export function plan(input: PlanInput): EmitPlan {
     apiSurface,
     clientManifest,
     frontendGraph,
+    externalServices,
   });
   const agentAdapterManifest = buildAgentAdapterManifest(agentArtifacts.contract);
+  const agentArtifactsMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
+
   const rlsArtifacts = buildRlsArtifacts(sqlPlan, tenantScope);
   const packageUpgradeRegistry = {
     schemaVersion: "0.1.0" as const,
@@ -387,8 +578,17 @@ export function plan(input: PlanInput): EmitPlan {
   const uiArtifacts = buildUiGeneratedArtifacts({
     appGraph: input.appGraph,
     apiSurface,
+    frontendGraph,
     sources: input.ctx.sources,
+    workspaceRoot: input.ctx.workspaceRoot,
   });
+  const integrationArtifactFiles = input.classified.flatMap(buildIntegrationArtifactFiles);
+  const supportArtifactsMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
+
+  const appGraphJson = serializeAppGraphJson(input.appGraph);
+  const packageGraphJson = serializePackageGraphJson(input.packageGraph);
+  const runtimeMatrixJson = serializeRuntimeMatrixJson(matrix);
 
   const files: EmitFile[] = [
     makeEmitFile("AGENTS.md", agentArtifacts.agentsMd),
@@ -400,6 +600,14 @@ export function plan(input: PlanInput): EmitPlan {
       `${GENERATED_DIR}/agentContract.json`,
       serializeAgentContractJson(agentArtifacts.contract),
     ),
+    makeEmitFile(
+      `${GENERATED_DIR}/externalServices.ts`,
+      serializeExternalServiceGraphTs(externalServices),
+    ),
+    makeEmitFile(
+      `${GENERATED_DIR}/externalServices.json`,
+      serializeExternalServiceGraphJson(externalServices),
+    ),
     makeEmitFile(`${GENERATED_DIR}/appMap.md`, agentArtifacts.appMapMd),
     makeEmitFile(
       `${GENERATED_DIR}/agentTools.ts`,
@@ -428,6 +636,10 @@ export function plan(input: PlanInput): EmitPlan {
       `${GENERATED_DIR}/agentQuickstart.md`,
       agentArtifacts.agentQuickstartMd,
     ),
+    makeEmitFile(
+      `${GENERATED_DIR}/agentCairGuide.md`,
+      agentArtifacts.agentCairGuideMd,
+    ),
     makeEmitFile(
       `${GENERATED_DIR}/agentAdapterManifest.ts`,
       serializeAgentAdapterManifestTs(agentAdapterManifest),
@@ -446,11 +658,11 @@ export function plan(input: PlanInput): EmitPlan {
     ),
     makeEmitFile(
       `${GENERATED_DIR}/appGraph.ts`,
-      serializeAppGraphTs(input.appGraph),
+      serializeConstFromJson("appGraph", appGraphJson),
     ),
     makeEmitFile(
       `${GENERATED_DIR}/appGraph.json`,
-      serializeAppGraphJson(input.appGraph),
+      appGraphJson,
     ),
     makeEmitFile(
       `${GENERATED_DIR}/packageGraph.ts`,
@@ -458,7 +670,7 @@ export function plan(input: PlanInput): EmitPlan {
     ),
     makeEmitFile(
       `${GENERATED_DIR}/packageGraph.json`,
-      serializePackageGraphJson(input.packageGraph),
+      packageGraphJson,
     ),
     makeEmitFile(
       `${GENERATED_DIR}/runtimeMatrix.ts`,
@@ -466,7 +678,7 @@ export function plan(input: PlanInput): EmitPlan {
     ),
     makeEmitFile(
       `${GENERATED_DIR}/runtimeMatrix.json`,
-      serializeRuntimeMatrixJson(matrix),
+      runtimeMatrixJson,
     ),
     makeEmitFile(
       `${GENERATED_DIR}/importGuards.ts`,
@@ -476,6 +688,7 @@ export function plan(input: PlanInput): EmitPlan {
       `${GENERATED_DIR}/importGuards.json`,
       serializeImportGuardsJson(matrix, input.appGraph.moduleGraph),
     ),
+    ...integrationArtifactFiles,
     makeEmitFile(
       `${GENERATED_DIR}/dataGraph.ts`,
       serializeDataGraphTs(dataGraph),
@@ -855,7 +1068,16 @@ export function plan(input: PlanInput): EmitPlan {
       `${GENERATED_DIR}/reactManifest.json`,
       serializeReactManifestJson(reactManifest),
     ),
+    makeEmitFile(`${GENERATED_DIR}/vue.ts`, renderVueTs()),
+    makeEmitFile(`${GENERATED_DIR}/vue.d.ts`, renderVueDts()),
+    makeEmitFile(`${GENERATED_DIR}/vueManifest.ts`, renderVueManifestTs(vueManifest)),
+    makeEmitFile(
+      `${GENERATED_DIR}/vueManifest.json`,
+      serializeVueManifestJson(vueManifest),
+    ),
   ];
+  const fileRenderMs = performance.now() - checkpoint;
+  checkpoint = performance.now();
 
   const sortedFiles = stableSortEmitFiles(files);
   const plannedPathSet = new Set(sortedFiles.map((file) => file.path));
@@ -866,12 +1088,20 @@ export function plan(input: PlanInput): EmitPlan {
   );
 
   const lock = buildForgeLock(input);
+  const finalizeMs = performance.now() - checkpoint;
 
-  return {
+  const result = {
     files: sortedFiles,
     orphanedFiles,
     lock,
     diagnostics: [
+      ...dataGraph.diagnostics,
+      ...sqlPlan.diagnostics,
+      ...runtimeGraph.diagnostics,
+      ...queryRegistry.diagnostics,
+      ...liveQueryRegistry.diagnostics,
+      ...policyRegistry.diagnostics,
+      ...tenantScope.diagnostics,
       ...agentArtifacts.diagnostics,
       ...rlsArtifacts.diagnostics,
       ...frontendGraph.diagnostics.map((diagnostic) =>
@@ -884,4 +1114,13 @@ export function plan(input: PlanInput): EmitPlan {
       ),
     ],
   };
+  recordPlanProfile(result, {
+    coreArtifactsMs,
+    agentArtifactsMs,
+    supportArtifactsMs,
+    fileRenderMs,
+    finalizeMs,
+    totalMs: performance.now() - started,
+  });
+  return result;
 }

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

@@ -1,15 +1,37 @@
+import type { AppGraphPhaseTimings } from "../app-graph/profile.ts";
+import type { SignalProfile } from "../classifier/signals.ts";
+import type { PlanPhaseTimings } from "./plan-profile.ts";
+
 export interface CompilePhaseTimings {
+  fastCheckMs: number;
+  sessionMs: number;
   discoverMs: number;
+  graphBuildMs: number;
   appGraphMs: number;
+  appGraph?: AppGraphPhaseTimings;
   packageGraphMs: number;
+  classifyMs: number;
+  classifierSignals?: SignalProfile;
   planMs: number;
+  planDetail?: PlanPhaseTimings;
+  runtimeMatrixMs: number;
+  importGuardsMs: number;
+  qualityGateMs: number;
   emitMs: number;
+  postEmitMs: number;
+  unaccountedMs: number;
   totalMs: number;
 }
 
 let lastTimings: CompilePhaseTimings | null = null;
 
 export function isCompileProfileEnabled(): boolean {
+  return process.env.FORGE_PROFILE === "1" ||
+    process.env.FORGE_PROFILE === "true" ||
+    process.env.FORGE_PROFILE === "silent";
+}
+
+export function shouldPrintCompileProfile(): boolean {
   return process.env.FORGE_PROFILE === "1" || process.env.FORGE_PROFILE === "true";
 }
 
@@ -26,11 +48,54 @@ export function getCompileTimings(): CompilePhaseTimings | null {
 export function formatCompileTimings(timings: CompilePhaseTimings): string {
   return [
     "forge compile profile:",
+    `  fast-check: ${timings.fastCheckMs}ms`,
+    `  session: ${timings.sessionMs}ms`,
     `  discover: ${timings.discoverMs}ms`,
+    `  graph-build: ${timings.graphBuildMs}ms`,
     `  app-graph: ${timings.appGraphMs}ms`,
+    ...(timings.appGraph
+      ? [
+          `    normalize: ${timings.appGraph.normalizeMs}ms`,
+          `    parse: ${timings.appGraph.parseMs}ms`,
+          `    symbols: ${timings.appGraph.symbolsMs}ms`,
+          `    duplicates: ${timings.appGraph.duplicatesMs}ms`,
+          `    module-graph: ${timings.appGraph.moduleGraphMs}ms`,
+          `    input-hash: ${timings.appGraph.inputHashMs}ms`,
+        ]
+      : []),
     `  package-graph: ${timings.packageGraphMs}ms`,
+    `  classify: ${timings.classifyMs}ms`,
+    ...(timings.classifierSignals
+      ? [
+          `    gatherSignals: ${timings.classifierSignals.totalMs}ms`,
+          `    gatherSignals calls: ${timings.classifierSignals.calls}`,
+          `    gatherSignals exports scanned: ${timings.classifierSignals.exports}`,
+          `    gatherSignals corpus bytes: ${timings.classifierSignals.corpusBytes}`,
+          `    gatherSignals packages: ${timings.classifierSignals.packageCount}`,
+          ...timings.classifierSignals.topPackages
+            .slice(0, 5)
+            .map(
+              (pkg) =>
+                `      ${pkg.packageName}: ${pkg.totalMs}ms, ${pkg.calls} calls, ${pkg.exports} exports`,
+            ),
+        ]
+      : []),
     `  plan: ${timings.planMs}ms`,
+    ...(timings.planDetail
+      ? [
+          `    core-artifacts: ${timings.planDetail.coreArtifactsMs}ms`,
+          `    agent-artifacts: ${timings.planDetail.agentArtifactsMs}ms`,
+          `    support-artifacts: ${timings.planDetail.supportArtifactsMs}ms`,
+          `    file-render: ${timings.planDetail.fileRenderMs}ms`,
+          `    finalize: ${timings.planDetail.finalizeMs}ms`,
+        ]
+      : []),
+    `  runtime-matrix: ${timings.runtimeMatrixMs}ms`,
+    `  import-guards: ${timings.importGuardsMs}ms`,
+    `  quality-gate: ${timings.qualityGateMs}ms`,
     `  emit: ${timings.emitMs}ms`,
+    `  post-emit: ${timings.postEmitMs}ms`,
+    `  unaccounted: ${timings.unaccountedMs}ms`,
     `  total: ${timings.totalMs}ms`,
   ].join("\n");
 }