forgeos 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/forge/compiler/agent-contract/types.ts

@@ -11,6 +11,8 @@ export interface AgentProjectInfo {
 export interface AgentEntryInfo {
   name: string;
   file: string;
+  source?: "local" | "external";
+  external?: AgentExternalEntryInfo;
   policy?: string;
   allowedPackages: string[];
   forbiddenCapabilities: string[];
@@ -145,6 +147,47 @@ export interface AgentAiInfo {
     file: string;
     purpose?: string;
   }>;
+  tools: Array<{
+    name: string;
+    file: string;
+    description?: string;
+    risk: string;
+    strict: boolean;
+    needsApproval: boolean | "dynamic";
+  }>;
+  agents: Array<{
+    name: string;
+    file: string;
+    provider: string;
+    model: string;
+    instructions?: string;
+    tools: string[];
+    stopWhen: unknown;
+  }>;
+}
+
+export interface AgentExternalEntryInfo {
+  service: string;
+  language: string;
+  framework?: string;
+  transport: string;
+  transaction?: string;
+  risk?: "read" | "write" | "destructive" | "external";
+  needsApproval?: boolean;
+  effects: string[];
+  description?: string;
+}
+
+export interface AgentExternalServiceInfo {
+  name: string;
+  language: string;
+  framework?: string;
+  transport: string;
+  baseUrl?: string;
+  command?: string;
+  health?: string;
+  commands: string[];
+  queries: string[];
 }
 
 export interface AgentClientInfo {
@@ -306,11 +349,51 @@ export interface AgentCapabilityMap {
   diagnostics: Diagnostic[];
 }
 
+export interface AgentToolRegistry {
+  schemaVersion: "0.1.0";
+  generatorVersion: string;
+  project: AgentProjectInfo;
+  explicitTools: AgentAiInfo["tools"];
+  autoTools: Array<{
+    name: string;
+    sourceKind: "command" | "query" | "liveQuery";
+    sourceName: string;
+    policy?: string;
+    file: string;
+    http: AgentHttpEndpointInfo;
+    frontend: AgentFrontendUsageInfo;
+    tablesRead: string[];
+    tablesWritten: string[];
+    emits: string[];
+    dependencies: Array<{ table: string; scope: "tenant" | "global" }>;
+    readOnly: boolean;
+    risk: "read" | "write";
+    needsApproval: boolean;
+    requiresAuth: boolean;
+    source?: "local" | "external";
+    external?: AgentExternalEntryInfo;
+    execution: "forge-runtime-endpoint" | "external-runtime-endpoint";
+  }>;
+  agents: AgentAiInfo["agents"];
+}
+
 export interface AgentPlaybook {
   title: string;
   steps: string[];
 }
 
+export interface AgentProtocolInfo {
+  id: string;
+  kind: "agent-protocol";
+  version: string;
+  guide: string;
+  commands: string[];
+  preferredFor: string[];
+  readQueries: string[];
+  mutationActions: string[];
+  compactAliases: string[];
+}
+
 export interface AgentContract {
   schemaVersion: string;
   generatorVersion: string;
@@ -325,6 +408,7 @@ export interface AgentContract {
   packages: AgentPackageInfo[];
   dependencyApis: AgentDependencyApiInfo[];
   integrations: AgentIntegrationInfo[];
+  externalServices?: AgentExternalServiceInfo[];
   secrets: AgentSecretInfo[];
   telemetry: AgentTelemetryInfo;
   ai: AgentAiInfo;
@@ -334,6 +418,7 @@ export interface AgentContract {
   deploy?: AgentDeployInfo;
   rules: AgentRuntimeRule[];
   playbooks: AgentPlaybook[];
+  agentProtocols: AgentProtocolInfo[];
   commandsToRun: {
     beforeEditing: string[];
     afterEditing: string[];

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

@@ -4,9 +4,11 @@ import { canonicalJson } from "../primitives/serialize.ts";
 import type { AppGraph } from "../types/app-graph.ts";
 import type {
   AiGenerationCall,
+  AiAgentDefinition,
   AiModelDefinition,
   AiProviderDefinition,
   AiRegistry,
+  AiToolDefinition,
   ForgeAiProvider,
 } from "../types/ai-registry.ts";
 import type { ClassifiedPackage } from "../classifier/runtime-matrix.ts";
@@ -15,9 +17,17 @@ import {
   AI_REGISTRY_ANALYZER_VERSION,
   AI_REGISTRY_SCHEMA_VERSION,
 } from "./constants.ts";
-import { parseAiCallsFromSlice } from "./parse.ts";
+import {
+  parseAiAgentMeta,
+  parseAiCallsFromSlice,
+  parseAiToolMeta,
+} from "./parse.ts";
 
 const KNOWN_MODELS: AiModelDefinition[] = [
+  {
+    provider: "openai",
+    model: "gpt-5.4",
+  },
   {
     provider: "openai",
     model: "gpt-4o",
@@ -30,6 +40,10 @@ const KNOWN_MODELS: AiModelDefinition[] = [
     inputCostPer1kTokensUsd: 0.00015,
     outputCostPer1kTokensUsd: 0.0006,
   },
+  {
+    provider: "anthropic",
+    model: "claude-sonnet-4.5",
+  },
   {
     provider: "anthropic",
     model: "claude-3-5-sonnet-20241022",
@@ -42,6 +56,14 @@ const KNOWN_MODELS: AiModelDefinition[] = [
     inputCostPer1kTokensUsd: 0.0008,
     outputCostPer1kTokensUsd: 0.004,
   },
+  {
+    provider: "gateway",
+    model: "openai/gpt-5.4",
+  },
+  {
+    provider: "gateway",
+    model: "anthropic/claude-sonnet-4.5",
+  },
   {
     provider: "gateway",
     model: "openai/gpt-4o",
@@ -123,12 +145,39 @@ export function buildAiRegistry(
   classified: ClassifiedPackage[],
 ): AiRegistry {
   const generations: AiGenerationCall[] = [];
+  const tools: AiToolDefinition[] = [];
+  const agents: AiAgentDefinition[] = [];
 
   for (const symbol of appGraph.symbols) {
     const sourceSlice =
       typeof symbol.meta.sourceSlice === "string" ? symbol.meta.sourceSlice : "";
     if (sourceSlice.length === 0) continue;
 
+    if (symbol.kind === "aiTool") {
+      const meta = parseAiToolMeta(sourceSlice);
+      tools.push({
+        name: symbol.name,
+        file: symbol.file,
+        ...(meta.description ? { description: meta.description } : {}),
+        risk: meta.risk,
+        strict: meta.strict,
+        needsApproval: meta.needsApproval,
+      });
+    }
+
+    if (symbol.kind === "agent") {
+      const meta = parseAiAgentMeta(sourceSlice);
+      agents.push({
+        name: symbol.name,
+        file: symbol.file,
+        provider: meta.provider ?? "gateway",
+        model: meta.model ?? "unknown",
+        ...(meta.instructions ? { instructions: meta.instructions } : {}),
+        tools: meta.tools,
+        stopWhen: meta.stopWhen,
+      });
+    }
+
     for (const call of parseAiCallsFromSlice(sourceSlice)) {
       generations.push({
         provider: call.provider ?? "openai",
@@ -145,6 +194,16 @@ export function buildAiRegistry(
     if (fileCmp !== 0) return fileCmp;
     return a.method.localeCompare(b.method);
   });
+  tools.sort((a, b) => {
+    const nameCmp = a.name.localeCompare(b.name);
+    if (nameCmp !== 0) return nameCmp;
+    return a.file.localeCompare(b.file);
+  });
+  agents.sort((a, b) => {
+    const nameCmp = a.name.localeCompare(b.name);
+    if (nameCmp !== 0) return nameCmp;
+    return a.file.localeCompare(b.file);
+  });
 
   return {
     schemaVersion: AI_REGISTRY_SCHEMA_VERSION,
@@ -158,6 +217,8 @@ export function buildAiRegistry(
     ),
     providers: buildProviders(classified),
     generations,
+    tools,
+    agents,
     diagnostics: [],
   };
 }

package/src/forge/compiler/ai-registry/constants.ts

@@ -1,2 +1,2 @@
 export const AI_REGISTRY_SCHEMA_VERSION = "1";
-export const AI_REGISTRY_ANALYZER_VERSION = "1.0.0";
+export const AI_REGISTRY_ANALYZER_VERSION = "1.1.0";

package/src/forge/compiler/ai-registry/parse.ts

@@ -1,7 +1,7 @@
 import type { ForgeAiProvider } from "../types/ai-registry.ts";
 
 const AI_METHOD_PATTERN =
-  /(?:ctx\.ai|ai)\.(generateText|streamText|generateStructured)\s*\(/g;
+  /(?:(?:ctx\.ai|ai)\.(generateText|streamText|generateStructured|runAgent)|ctx\.agent\.(run))\s*\(/g;
 
 const PROVIDER_PATTERN =
   /provider\s*:\s*["'](openai|anthropic|gateway)["']/;
@@ -11,18 +11,81 @@ const MODEL_PATTERN = /model\s*:\s*["']([^"']+)["']/;
 const PURPOSE_PATTERN = /purpose\s*:\s*["']([^"']+)["']/;
 
 export interface ParsedAiCall {
-  method: "generateText" | "streamText" | "generateStructured";
+  method: "generateText" | "streamText" | "generateStructured" | "runAgent";
   provider?: ForgeAiProvider;
   model?: string;
   purpose?: string;
 }
 
+function quotedOrCommentRanges(source: string): Array<{ start: number; end: number }> {
+  const ranges: Array<{ start: number; end: number }> = [];
+  let i = 0;
+
+  while (i < source.length) {
+    const char = source[i];
+    const next = source[i + 1];
+
+    if (char === "/" && next === "/") {
+      const start = i;
+      i += 2;
+      while (i < source.length && source[i] !== "\n") {
+        i += 1;
+      }
+      ranges.push({ start, end: i });
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      const start = i;
+      i += 2;
+      while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) {
+        i += 1;
+      }
+      i = Math.min(source.length, i + 2);
+      ranges.push({ start, end: i });
+      continue;
+    }
+
+    if (char === "\"" || char === "'" || char === "`") {
+      const quote = char;
+      const start = i;
+      i += 1;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === quote) {
+          i += 1;
+          break;
+        }
+        i += 1;
+      }
+      ranges.push({ start, end: i });
+      continue;
+    }
+
+    i += 1;
+  }
+
+  return ranges;
+}
+
+function indexInsideRange(index: number, ranges: Array<{ start: number; end: number }>): boolean {
+  return ranges.some((range) => index >= range.start && index < range.end);
+}
+
 export function parseAiCallsFromSlice(sourceSlice: string): ParsedAiCall[] {
   const calls: ParsedAiCall[] = [];
+  const ignoredRanges = quotedOrCommentRanges(sourceSlice);
 
   for (const match of sourceSlice.matchAll(AI_METHOD_PATTERN)) {
-    const method = match[1] as ParsedAiCall["method"];
     const start = match.index ?? 0;
+    if (indexInsideRange(start, ignoredRanges)) {
+      continue;
+    }
+
+    const method = (match[1] ?? (match[2] ? "runAgent" : "")) as ParsedAiCall["method"];
     const window = sourceSlice.slice(start, start + 600);
 
     let provider: ForgeAiProvider | undefined;
@@ -49,8 +112,108 @@ export function parseAiCallsFromSlice(sourceSlice: string): ParsedAiCall[] {
   return calls;
 }
 
-const FORBIDDEN_AI_CONTEXT_PATTERN = /ctx\.ai\./;
+const FORBIDDEN_AI_CONTEXT_PATTERN = /ctx\.(?:ai\.|agent\.run\s*\()/;
 
 export function detectCtxAiUsage(sourceSlice: string): boolean {
-  return FORBIDDEN_AI_CONTEXT_PATTERN.test(sourceSlice);
+  const ignoredRanges = quotedOrCommentRanges(sourceSlice);
+  for (const match of sourceSlice.matchAll(new RegExp(FORBIDDEN_AI_CONTEXT_PATTERN, "g"))) {
+    if (!indexInsideRange(match.index ?? 0, ignoredRanges)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const DESCRIPTION_PATTERN = /description\s*:\s*["'`]([^"'`]+)["'`]/;
+const RISK_PATTERN = /risk\s*:\s*["'](read|write|external|destructive)["']/;
+const STRICT_PATTERN = /strict\s*:\s*(true|false)/;
+const NEEDS_APPROVAL_PATTERN = /needsApproval\s*:\s*(true|false|async\s*\(|\([^)]*\)\s*=>|[A-Za-z_$][A-Za-z0-9_$]*)/;
+const INSTRUCTIONS_PATTERN = /instructions\s*:\s*["'`]([^"'`]+)["'`]/;
+const TOOL_ARRAY_PATTERN = /tools\s*:\s*\[([^\]]*)\]/s;
+const TOOL_OBJECT_PATTERN = /tools\s*:\s*\{([^}]*)\}/s;
+const STOP_TOOL_PATTERN = /stopWhen\s*:\s*\{[^}]*kind\s*:\s*["']toolCall["'][^}]*toolName\s*:\s*["']([^"']+)["'][^}]*\}/s;
+const STOP_STEP_PATTERN = /stopWhen\s*:\s*\{[^}]*kind\s*:\s*["']stepCount["'][^}]*maxSteps\s*:\s*(\d+)[^}]*\}/s;
+const MAX_STEPS_PATTERN = /maxSteps\s*:\s*(\d+)/;
+
+export interface ParsedAiToolMeta {
+  description?: string;
+  risk: "read" | "write" | "external" | "destructive" | "unknown";
+  strict: boolean;
+  needsApproval: boolean | "dynamic";
+}
+
+export interface ParsedAiAgentMeta {
+  provider?: ForgeAiProvider;
+  model?: string;
+  instructions?: string;
+  tools: string[];
+  stopWhen:
+    | { kind: "stepCount"; maxSteps: number }
+    | { kind: "toolCall"; toolName: string }
+    | { kind: "default" };
+}
+
+function parseBooleanOrDynamic(value: string | undefined): boolean | "dynamic" {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return "dynamic";
+}
+
+function parseStringList(raw: string | undefined): string[] {
+  if (!raw) return [];
+  return [...raw.matchAll(/["'`]([^"'`]+)["'`]/g)]
+    .map((match) => match[1] ?? "")
+    .filter(Boolean)
+    .sort();
+}
+
+function parseObjectToolKeys(raw: string | undefined): string[] {
+  if (!raw) return [];
+  const explicit = [...raw.matchAll(/([A-Za-z_$][A-Za-z0-9_$]*)\s*:/g)]
+    .map((match) => match[1] ?? "")
+    .filter(Boolean);
+  const shorthand = raw
+    .split(",")
+    .map((part) => part.trim())
+    .filter((part) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(part));
+  return [...new Set([...explicit, ...shorthand])].sort();
+}
+
+export function parseAiToolMeta(sourceSlice: string): ParsedAiToolMeta {
+  const description = DESCRIPTION_PATTERN.exec(sourceSlice)?.[1];
+  const risk = RISK_PATTERN.exec(sourceSlice)?.[1] as ParsedAiToolMeta["risk"] | undefined;
+  const strict = STRICT_PATTERN.exec(sourceSlice)?.[1] === "true";
+  const needsApprovalMatch = NEEDS_APPROVAL_PATTERN.exec(sourceSlice)?.[1];
+
+  return {
+    ...(description ? { description } : {}),
+    risk: risk ?? "unknown",
+    strict,
+    needsApproval: needsApprovalMatch
+      ? parseBooleanOrDynamic(needsApprovalMatch)
+      : false,
+  };
+}
+
+export function parseAiAgentMeta(sourceSlice: string): ParsedAiAgentMeta {
+  const provider = PROVIDER_PATTERN.exec(sourceSlice)?.[1] as ForgeAiProvider | undefined;
+  const model = MODEL_PATTERN.exec(sourceSlice)?.[1];
+  const instructions = INSTRUCTIONS_PATTERN.exec(sourceSlice)?.[1];
+  const arrayTools = parseStringList(TOOL_ARRAY_PATTERN.exec(sourceSlice)?.[1]);
+  const objectTools = parseObjectToolKeys(TOOL_OBJECT_PATTERN.exec(sourceSlice)?.[1]);
+  const stopTool = STOP_TOOL_PATTERN.exec(sourceSlice)?.[1];
+  const stopStepsRaw =
+    STOP_STEP_PATTERN.exec(sourceSlice)?.[1] ?? MAX_STEPS_PATTERN.exec(sourceSlice)?.[1];
+
+  return {
+    ...(provider ? { provider } : {}),
+    ...(model ? { model } : {}),
+    ...(instructions ? { instructions } : {}),
+    tools: [...new Set([...arrayTools, ...objectTools])].sort(),
+    stopWhen: stopTool
+      ? { kind: "toolCall", toolName: stopTool }
+      : stopStepsRaw
+        ? { kind: "stepCount", maxSteps: Number(stopStepsRaw) }
+        : { kind: "default" },
+  };
 }

package/src/forge/compiler/api-surface/build.ts

@@ -5,6 +5,16 @@ import type { QueryRegistry } from "../types/query-registry.ts";
 import type { LiveQueryRegistry } from "../types/live-query-registry.ts";
 import type { RuntimeGraph } from "../types/runtime-graph.ts";
 import type { WorkflowRegistry } from "../types/workflow-registry.ts";
+import type { ForgeExternalServiceGraph } from "../external-manifest/types.ts";
+
+export interface ApiExternalEntry {
+  service: string;
+  name: string;
+  kind: "command" | "query";
+  language: string;
+  framework?: string;
+  transport: string;
+}
 
 export interface ApiSurface {
   schemaVersion: string;
@@ -15,6 +25,11 @@ export interface ApiSurface {
   liveQueries: Record<string, string>;
   actions: Record<string, string>;
   workflows: Record<string, string>;
+  external?: {
+    services: Record<string, string>;
+    commands: Record<string, ApiExternalEntry>;
+    queries: Record<string, ApiExternalEntry>;
+  };
 }
 
 export function buildApiSurface(
@@ -22,6 +37,7 @@ export function buildApiSurface(
   queryRegistry: QueryRegistry,
   liveQueryRegistry: LiveQueryRegistry,
   workflowRegistry: WorkflowRegistry,
+  externalServices?: ForgeExternalServiceGraph,
 ): ApiSurface {
   const queries: Record<string, string> = {};
   for (const query of queryRegistry.queries) {
@@ -48,6 +64,31 @@ export function buildApiSurface(
     workflows[workflow.name] = workflow.name;
   }
 
+  const external = {
+    services: {} as Record<string, string>,
+    commands: {} as Record<string, ApiExternalEntry>,
+    queries: {} as Record<string, ApiExternalEntry>,
+  };
+  for (const service of externalServices?.services ?? []) {
+    external.services[service.name] = service.name;
+    for (const entry of service.entries) {
+      const qualifiedName = `${service.name}.${entry.name}`;
+      const surfaceEntry = {
+        service: service.name,
+        name: entry.name,
+        kind: entry.kind,
+        language: service.language,
+        ...(service.framework ? { framework: service.framework } : {}),
+        transport: service.transport,
+      };
+      if (entry.kind === "command") {
+        external.commands[qualifiedName] = surfaceEntry;
+      } else {
+        external.queries[qualifiedName] = surfaceEntry;
+      }
+    }
+  }
+
   return {
     schemaVersion: "1.0.0",
     generatorVersion: GENERATOR_VERSION,
@@ -57,6 +98,7 @@ export function buildApiSurface(
         queryInputHash: queryRegistry.inputHash,
         liveQueryInputHash: liveQueryRegistry.inputHash,
         workflowInputHash: workflowRegistry.inputHash,
+        externalInputHash: externalServices?.inputHash ?? "",
       }),
     ),
     queries,
@@ -64,10 +106,12 @@ export function buildApiSurface(
     liveQueries,
     actions,
     workflows,
+    external,
   };
 }
 
 export function serializeApiTs(surface: ApiSurface): string {
+  const external = surface.external ?? { services: {}, commands: {}, queries: {} };
   return `export const api = ${JSON.stringify(
     {
       queries: surface.queries,
@@ -75,6 +119,7 @@ export function serializeApiTs(surface: ApiSurface): string {
       liveQueries: surface.liveQueries,
       actions: surface.actions,
       workflows: surface.workflows,
+      external,
     },
     null,
     2,
@@ -90,6 +135,7 @@ export const serverApi = {
   liveQueries: api.liveQueries,
   actions: api.actions,
   workflows: api.workflows,
+  external: api.external,
 } as const;
 `;
 }
@@ -102,6 +148,7 @@ export const clientApi = {
   queries: api.queries,
   commands: api.commands,
   liveQueries: api.liveQueries,
+  external: api.external,
 } as const;
 `;
 }

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

@@ -2,14 +2,15 @@ import { canonicalJson } from "../primitives/serialize.ts";
 import { hashStable } from "../primitives/hash.ts";
 import { normalizePath } from "../primitives/paths.ts";
 import { stableSortEdges, stableSortSymbols } from "../primitives/sort.ts";
-import type { AppGraph, SourceFile } from "../types/app-graph.ts";
+import type { AppGraph, ForgeEdge, ForgeSymbol, SourceFile } from "../types/app-graph.ts";
 import { detectDuplicateSymbols } from "./dup-symbol.ts";
 import { buildModuleGraph } from "./module-graph.ts";
 import { incrementalParse } from "./parser.ts";
+import { recordAppGraphProfile } from "./profile.ts";
 import { buildForgeSymbols } from "./symbols.ts";
 import { hashTsconfigForWorkspace } from "./tsconfig-hash.ts";
 import type { ParseInvalidationKey } from "./types.ts";
-import { buildAnalyzerVersion } from "./types.ts";
+import { buildAnalyzerVersion, parseInvalidationKeyEquals } from "./types.ts";
 import {
   APP_GRAPH_SCHEMA_VERSION,
   FORGE_CLASSIFIER_VERSION,
@@ -65,10 +66,45 @@ function parseInvalidationFromPrior(prior: AppGraph): ParseInvalidationKey | und
   };
 }
 
+function moduleIdByFile(moduleGraph: AppGraph["moduleGraph"]): Map<string, string> {
+  return new Map(moduleGraph.nodes.map((node) => [node.file, node.id]));
+}
+
+function buildAppGraphEdges(
+  symbols: ForgeSymbol[],
+  moduleGraph: AppGraph["moduleGraph"],
+): ForgeEdge[] {
+  const edges: ForgeEdge[] = [];
+  const modules = moduleIdByFile(moduleGraph);
+
+  for (const symbol of symbols) {
+    const moduleId = modules.get(symbol.file);
+    if (moduleId) {
+      edges.push({ from: symbol.id, to: moduleId, kind: "registers" });
+    }
+  }
+
+  for (const module of moduleGraph.nodes) {
+    for (const localImport of module.localImports) {
+      edges.push({
+        from: module.id,
+        to: localImport.toModuleId,
+        kind: "imports",
+      });
+    }
+  }
+
+  return edges;
+}
+
 export async function buildAppGraph(
   options: AppGraphBuildOptions,
 ): Promise<AppGraph> {
+  const started = Date.now();
+  let checkpoint = started;
   const sources = normalizeSources(options.sources);
+  const normalizeMs = Date.now() - checkpoint;
+  checkpoint = Date.now();
   const tsconfigHash =
     options.tsconfigHash ??
     hashTsconfigForWorkspace(
@@ -86,36 +122,60 @@ export async function buildAppGraph(
   const priorInvalidation = options.prior
     ? parseInvalidationFromPrior(options.prior)
     : undefined;
+  const canReusePrior =
+    priorInvalidation !== undefined &&
+    parseInvalidationKeyEquals(priorInvalidation, invalidation);
 
   const { symbols: rawSymbols, diagnostics: parseDiagnostics } =
     incrementalParse(
       sources,
       options.prior?.symbols,
+      options.prior?.sourceHashes,
       priorInvalidation,
       invalidation,
     );
+  const parseMs = Date.now() - checkpoint;
+  checkpoint = Date.now();
 
   const forgeSymbols = buildForgeSymbols(rawSymbols, sources);
+  const symbolsMs = Date.now() - checkpoint;
+  checkpoint = Date.now();
   const dupDiagnostics = detectDuplicateSymbols(forgeSymbols);
+  const duplicatesMs = Date.now() - checkpoint;
+  checkpoint = Date.now();
   const moduleGraph = buildModuleGraph(
     sources,
     rawSymbols,
-    options.workspaceRoot,
-    options.tsconfigPath,
     options.prior,
+    canReusePrior,
   );
+  const moduleGraphMs = Date.now() - checkpoint;
+  checkpoint = Date.now();
+  const inputHash = computeInputHash(sources, invalidation);
+  const inputHashMs = Date.now() - checkpoint;
+  const sortedSymbols = stableSortSymbols(forgeSymbols);
 
-  return {
+  const graph = {
     schemaVersion: APP_GRAPH_SCHEMA_VERSION,
     generatorVersion: GENERATOR_VERSION,
     analyzerVersion: buildAnalyzerVersion(invalidation),
-    inputHash: computeInputHash(sources, invalidation),
+    inputHash,
     sourceHashes: Object.fromEntries(
       sources.map((source) => [source.path, source.contentHash]),
     ),
-    symbols: stableSortSymbols(forgeSymbols),
-    edges: stableSortEdges([]),
+    symbols: sortedSymbols,
+    edges: stableSortEdges(buildAppGraphEdges(sortedSymbols, moduleGraph)),
     moduleGraph,
     diagnostics: [...parseDiagnostics, ...dupDiagnostics],
   };
+  recordAppGraphProfile(graph, {
+    normalizeMs,
+    parseMs,
+    symbolsMs,
+    duplicatesMs,
+    moduleGraphMs,
+    inputHashMs,
+    totalMs: Date.now() - started,
+  });
+  return graph;
 }