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

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(
@@ -680,6 +697,8 @@ export function serializeAiRegistryJson(registry: import("../types/ai-registry.t
     inputHash: registry.inputHash,
     providers: registry.providers,
     generations: registry.generations,
+    tools: registry.tools,
+    agents: registry.agents,
     diagnostics: registry.diagnostics,
   };
   return serializeCanonical(payload);
@@ -762,10 +781,76 @@ export interface ForgeGenerateStructuredInput<T> {
   schema: ForgeFlexibleSchema<T>;
 }
 
+export type ForgeAiToolRisk = "read" | "write" | "external" | "destructive";
+
+export interface ForgeAiToolRuntimeContext {
+  secrets: {
+    get(name: string): string;
+    optional(name: string): string | undefined;
+    has(name: string): boolean;
+  };
+  env: Record<string, string | undefined>;
+  telemetry?: {
+    traceId?: string;
+    capture(name: string, properties?: Record<string, unknown>): Promise<void>;
+  };
+  auth?: unknown;
+}
+
+export interface ForgeAiToolDefinition<TArgs = unknown, TResult = unknown> {
+  description: string;
+  inputSchema: unknown;
+  outputSchema?: unknown;
+  strict?: boolean;
+  needsApproval?: boolean | ((args: TArgs) => boolean | Promise<boolean>);
+  risk?: ForgeAiToolRisk;
+  handler: (
+    ctx: ForgeAiToolRuntimeContext,
+    args: TArgs,
+  ) => TResult | Promise<TResult>;
+}
+
+export type ForgeAgentStopWhen =
+  | { kind: "stepCount"; maxSteps: number }
+  | { kind: "toolCall"; toolName: string };
+
+export interface ForgeRunAgentInput {
+  provider?: ForgeAiProvider;
+  model: string;
+  prompt: string;
+  instructions: string;
+  purpose?: string;
+  tools?: Record<string, ForgeAiToolDefinition>;
+  stopWhen?: ForgeAgentStopWhen;
+  maxSteps?: number;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export interface ForgeRunAgentResult {
+  text: string;
+  provider: ForgeAiProvider;
+  model: string;
+  purpose?: string;
+  usage: ForgeAiUsage;
+  latencyMs: number;
+  toolCalls: Array<{
+    toolName: string;
+    input: unknown;
+  }>;
+  toolResults: Array<{
+    toolName: string;
+    output: unknown;
+  }>;
+  steps: number;
+  estimatedCostUsd?: number;
+}
+
 export interface AiContext {
   generateText(input: ForgeGenerateTextInput): Promise<ForgeGenerateTextResult>;
   streamText(input: ForgeStreamTextInput): Promise<ForgeStreamTextResult>;
   generateStructured<T>(input: ForgeGenerateStructuredInput<T>): Promise<T>;
+  runAgent(input: ForgeRunAgentInput): Promise<ForgeRunAgentResult>;
 }
 `;
 }
@@ -822,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,
@@ -831,6 +917,7 @@ export function serializeApiJson(surface: ApiSurface): string {
     liveQueries: surface.liveQueries,
     actions: surface.actions,
     workflows: surface.workflows,
+    external,
   });
 }
 
@@ -865,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/package-graph/compiler.ts

@@ -73,6 +73,10 @@ export interface BuildResult {
   diagnostics: Diagnostic[];
 }
 
+function shouldWarnNoTypes(packageName: string): boolean {
+  return !packageName.startsWith("@types/");
+}
+
 export class PackageGraphCompiler {
   async build(
     deps: Dependency[],
@@ -363,7 +367,9 @@ export class PackageGraphCompiler {
     }
 
     if (resolved.dtsPath == null) {
-      diagnostics.push(forgePkgNoTypes(dep.name, subpath));
+      if (shouldWarnNoTypes(dep.name)) {
+        diagnostics.push(forgePkgNoTypes(dep.name, subpath));
+      }
       return {
         subpath,
         conditions: resolved.conditions,
@@ -382,7 +388,9 @@ export class PackageGraphCompiler {
         subpath,
       );
     } catch {
-      diagnostics.push(forgePkgNoTypes(dep.name, subpath));
+      if (shouldWarnNoTypes(dep.name)) {
+        diagnostics.push(forgePkgNoTypes(dep.name, subpath));
+      }
       return {
         subpath,
         conditions: resolved.conditions,
@@ -401,7 +409,9 @@ export class PackageGraphCompiler {
     }
 
     if (exports.length === 0) {
-      diagnostics.push(forgePkgNoTypes(dep.name, subpath));
+      if (shouldWarnNoTypes(dep.name)) {
+        diagnostics.push(forgePkgNoTypes(dep.name, subpath));
+      }
     }
 
     return {

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/policy-registry/build.ts

@@ -11,6 +11,7 @@ import { hashStable } from "../primitives/hash.ts";
 import { canonicalJson } from "../primitives/serialize.ts";
 import type { AppGraph } from "../types/app-graph.ts";
 import type { DataGraph } from "../types/data-graph.ts";
+import type { ForgeExternalServiceGraph } from "../external-manifest/types.ts";
 import type {
   CommandAuthBinding,
   PermissionMatrix,
@@ -64,7 +65,20 @@ function buildPermissionMatrix(policies: PolicyRule[]): PermissionMatrixEntry[]
     .sort((a, b) => (a.policy < b.policy ? -1 : a.policy > b.policy ? 1 : 0));
 }
 
-export function buildPolicyRegistry(appGraph: AppGraph): PolicyRegistry {
+function authFromExternalPolicy(policy: string | undefined): CommandAuthBinding["auth"] {
+  if (!policy) {
+    return { kind: "public" };
+  }
+  if (policy === "public" || policy === "system" || policy === "user") {
+    return { kind: policy };
+  }
+  return { kind: "policy", policy };
+}
+
+export function buildPolicyRegistry(
+  appGraph: AppGraph,
+  externalServices?: ForgeExternalServiceGraph,
+): PolicyRegistry {
   const policies: PolicyRule[] = [];
   const commandAuth: CommandAuthBinding[] = [];
   const queryAuth: QueryAuthBinding[] = [];
@@ -152,6 +166,28 @@ export function buildPolicyRegistry(appGraph: AppGraph): PolicyRegistry {
     }
   }
 
+  for (const service of externalServices?.services ?? []) {
+    for (const entry of service.entries) {
+      const qualifiedName = `${service.name}.${entry.name}`;
+      const binding = {
+        file: `external:${service.name}`,
+        symbolId: `external:${service.name}:${entry.kind}:${entry.name}`,
+        auth: authFromExternalPolicy(entry.policy),
+      };
+      if (entry.kind === "command") {
+        commandAuth.push({
+          commandName: qualifiedName,
+          ...binding,
+        });
+      } else {
+        queryAuth.push({
+          queryName: qualifiedName,
+          ...binding,
+        });
+      }
+    }
+  }
+
   const sortedPolicies = stableSortPolicies(policies);
   const sortedCommandAuth = stableSortCommandAuth(commandAuth);
   const sortedQueryAuth = stableSortQueryAuth(queryAuth);
@@ -167,6 +203,9 @@ export function buildPolicyRegistry(appGraph: AppGraph): PolicyRegistry {
           code: FORGE_POLICY_UNKNOWN,
           message: `command '${binding.commandName}' references unknown policy '${binding.auth.policy}'`,
           file: binding.file,
+          fixHint: binding.file.startsWith("external:")
+            ? "Define this policy in the Forge app or change the external manifest policy to public, user, or system."
+            : undefined,
         }),
       );
     }
@@ -183,6 +222,9 @@ export function buildPolicyRegistry(appGraph: AppGraph): PolicyRegistry {
           code: FORGE_POLICY_UNKNOWN,
           message: `query '${binding.queryName}' references unknown policy '${binding.auth.policy}'`,
           file: binding.file,
+          fixHint: binding.file.startsWith("external:")
+            ? "Define this policy in the Forge app or change the external manifest policy to public, user, or system."
+            : undefined,
         }),
       );
     }
@@ -195,6 +237,7 @@ export function buildPolicyRegistry(appGraph: AppGraph): PolicyRegistry {
     inputHash: hashStable(
       canonicalJson({
         appInputHash: appGraph.inputHash,
+        externalInputHash: externalServices?.inputHash ?? "",
         analyzerVersion: POLICY_REGISTRY_ANALYZER_VERSION,
       }),
     ),

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

@@ -16,6 +16,14 @@ import type {
 
 const TEST_RE = /\.(test|spec)\.(ts|tsx)$/;
 
+function isTemporaryTestPath(path: string): boolean {
+  return path.split("/").some((segment) => segment === ".tmp" || segment === "__tmp__");
+}
+
+function isTestGraphCandidate(path: string): boolean {
+  return TEST_RE.test(path) && !isTemporaryTestPath(path);
+}
+
 function emptyCoverage(): TestCoverage {
   return {
     commands: [],
@@ -40,7 +48,7 @@ function collectTestsFromDisk(workspaceRoot: string): SourceFile[] {
   const { sources } = walkWorkspaceSources({
     workspaceRoot,
     roots: ["tests", "web"],
-    excludeRelativePath: (path) => !TEST_RE.test(path),
+    excludeRelativePath: (path) => !isTestGraphCandidate(path),
   });
   return sources.sort((a, b) => a.path.localeCompare(b.path));
 }
@@ -208,7 +216,7 @@ export function buildTestGraph(input: {
   const diskTests = collectTestsFromDisk(input.workspaceRoot);
   const byPath = new Map<string, SourceFile>();
   for (const source of input.sources) {
-    if (TEST_RE.test(source.path)) {
+    if (isTestGraphCandidate(source.path)) {
       byPath.set(source.path, source);
     }
   }
@@ -216,7 +224,7 @@ export function buildTestGraph(input: {
     byPath.set(source.path, source);
   }
 
-  const allSources = [...input.sources.filter((s) => TEST_RE.test(s.path)), ...diskTests];
+  const allSources = [...input.sources.filter((s) => isTestGraphCandidate(s.path)), ...diskTests];
   const tests: TestGraphEntry[] = [...byPath.values()]
     .sort((a, b) => a.path.localeCompare(b.path))
     .map((source) => {

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

@@ -18,10 +18,32 @@ export interface AiGenerationCall {
   provider: ForgeAiProvider;
   model: string;
   purpose?: string;
-  method: "generateText" | "streamText" | "generateStructured";
+  method: "generateText" | "streamText" | "generateStructured" | "runAgent";
   file: string;
 }
 
+export interface AiToolDefinition {
+  name: string;
+  file: string;
+  description?: string;
+  risk: "read" | "write" | "external" | "destructive" | "unknown";
+  strict: boolean;
+  needsApproval: boolean | "dynamic";
+}
+
+export interface AiAgentDefinition {
+  name: string;
+  file: string;
+  provider: ForgeAiProvider;
+  model: string;
+  instructions?: string;
+  tools: string[];
+  stopWhen:
+    | { kind: "stepCount"; maxSteps: number }
+    | { kind: "toolCall"; toolName: string }
+    | { kind: "default" };
+}
+
 export interface AiRegistry {
   schemaVersion: string;
   generatorVersion: string;
@@ -29,5 +51,7 @@ export interface AiRegistry {
   inputHash: string;
   providers: AiProviderDefinition[];
   generations: AiGenerationCall[];
+  tools: AiToolDefinition[];
+  agents: AiAgentDefinition[];
   diagnostics: unknown[];
 }

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

@@ -12,7 +12,14 @@ export type ForgeKind =
   | "policy"
   | "workflow"
   | "agent"
-  | "telemetryEvent";
+  | "aiTool"
+  | "telemetryEvent"
+  | "code.function"
+  | "code.class"
+  | "code.interface"
+  | "code.type"
+  | "code.const"
+  | "code.enum";
 
 export interface ForgeSymbol {
   id: string;
@@ -25,7 +32,7 @@ export interface ForgeSymbol {
   meta: Record<string, JsonValue>;
 }
 
-export type ForgeEdgeKind = "references" | "registers" | "guards" | "emits";
+export type ForgeEdgeKind = "references" | "registers" | "guards" | "emits" | "imports";
 
 export interface ForgeEdge {
   from: string;

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

@@ -25,6 +25,24 @@ export interface GenerateResult {
 
 export interface ForgeAddResult extends GenerateResult {
   alias?: string;
+  mode?: "integration" | "package";
+  targetKind?: "forge-integration" | "npm-package";
+  target?: string;
+  packageTarget?: "root" | "frontend" | "backend" | "workspace";
+  packageTargetReason?: string;
+  explanation?: string;
+  recipeVersion?: string;
+  recipePackages?: string[];
+  requiredSecrets?: string[];
+  optionalSecrets?: string[];
+  packageSpec?: string;
+  packageName?: string;
+  packageManager?: string;
+  installCommand?: string[];
+  nativeInstallCommand?: string[];
+  avoidedManualCommand?: string;
+  installCwd?: string;
+  installWorkspace?: string;
 }
 
 export interface InspectResult {
@@ -45,6 +63,9 @@ export interface AddOptions extends CliCommonOptions {
   runtimeInspect: boolean;
   sandboxBackend: SandboxBackend;
   allowScripts: boolean;
+  mode?: "auto" | "integration" | "package";
+  installWorkspace?: string;
+  packageTarget?: "frontend" | "backend";
 }
 
 export type InspectTarget =
@@ -64,6 +85,7 @@ export type InspectTarget =
   | "ai"
   | "queries"
   | "api"
+  | "external"
   | "client"
   | "frontend"
   | "auth"
@@ -79,9 +101,15 @@ export type InspectTarget =
   | "test-graph"
   | "test-plans"
   | "agent-contract"
+  | "agent-tools"
   | "agent-adapters"
   | "capability-map"
+  | "summary"
+  | "schema"
+  | "drift"
+  | "handoff"
   | "framework"
+  | "imported"
   | "ui"
   | "ui-scenarios"
   | "ui-routes"
@@ -104,6 +132,7 @@ export interface RunResult {
 export interface PmAddOptions {
   ignoreScripts: boolean;
   cwd: string;
+  workspace?: string;
 }
 
 export interface PmAddResult {
@@ -145,15 +174,61 @@ export interface VerifyOptions {
   smoke?: boolean;
   standard?: boolean;
   scriptTimeoutMs?: number;
+  testJobs?: number;
+  typechecker?: "tsc" | "native" | "ts7" | "tsgo" | "auto";
+  fullTests?: boolean;
+  testPlan?: boolean;
+  internal?: boolean;
 }
 
-export type VerifyProfile = "default" | "smoke" | "standard" | "strict" | "changed";
+export type VerifyProfile = "default" | "smoke" | "standard" | "strict" | "changed" | "internal";
+
+export type VerifyTestGraphLane = "parallel" | "isolated" | "serial";
+export type VerifyTestGraphLaneMode = "overlap" | "sequential";
+
+export type VerifyTestGraphDurationSource = "profile" | "fallback";
+
+export interface VerifyTestGraphPlanChunk {
+  index: number;
+  lane: VerifyTestGraphLane;
+  files: string[];
+  estimatedMs: number;
+  durationSource: VerifyTestGraphDurationSource;
+}
+
+export interface VerifyTestGraphPlan {
+  schemaVersion: "0.1.0";
+  fileCount: number;
+  chunkCount: number;
+  totalJobs: number;
+  laneMode: VerifyTestGraphLaneMode;
+  jobs: number;
+  isolatedJobs: number;
+  lanes: Record<VerifyTestGraphLane, {
+    fileCount: number;
+    chunkCount: number;
+    estimatedMs: number;
+  }>;
+  chunks: VerifyTestGraphPlanChunk[];
+  criticalPathEstimateMs: number;
+  profilePath: string;
+  profileFound: boolean;
+  slowestFiles: Array<{
+    file: string;
+    lane: VerifyTestGraphLane;
+    estimatedMs: number;
+    source: VerifyTestGraphDurationSource;
+  }>;
+  recommendations: string[];
+}
 
 export interface VerifyResult {
   ok: boolean;
   profile?: VerifyProfile;
   steps: VerifyStep[];
   diagnostics: Diagnostic[];
+  testGraphPlan?: VerifyTestGraphPlan;
+  testCoverageReason?: string;
   durationMs?: number;
   exitCode: 0 | 1;
 }

package/src/forge/compiler/types/dev-manifest.ts

@@ -11,6 +11,9 @@ export interface DevRoute {
     | "workflows"
     | "workflow-runs"
     | "workflow-process"
+    | "ai-agent-chat"
+    | "ai-agent-run"
+    | "ai-providers"
     | "queries"
     | "query";
   entryName?: string;

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

@@ -31,7 +31,7 @@ export interface FrontendProviderInfo {
 
 export interface FrontendWebManifest {
   present: boolean;
-  framework: "next" | "vite" | "static" | "unknown" | "none";
+  framework: "next" | "nuxt" | "vite" | "static" | "unknown" | "none";
   root?: string;
   packageManager?: "bun" | "npm" | "pnpm" | "yarn" | "unknown";
   scripts: {
@@ -63,7 +63,7 @@ export interface FrontendClientBindingInfo {
 export interface FrontendGraph {
   schemaVersion: "0.1.0";
   present: boolean;
-  framework: "next" | "vite" | "static" | "unknown" | "none";
+  framework: "next" | "nuxt" | "vite" | "static" | "unknown" | "none";
   root?: string;
   dev?: {
     command: string;