forgeos 0.1.0-alpha.0

package/src/forge/compiler/recipes/definitions.ts

@@ -0,0 +1,289 @@
+import type { CapabilitySet } from "../types/capability.ts";
+import type { IntegrationRecipe } from "../types/integration.ts";
+import type { RuntimeContext } from "../types/runtime.ts";
+import { capability, emptyCapabilitySet, secret } from "./helpers.ts";
+
+export const RECIPE_SCHEMA_VERSION = "1";
+
+const SERVER_CONTEXTS: RuntimeContext[] = [
+  "server",
+  "action",
+  "workflow",
+  "endpoint",
+];
+
+const AI_CONTEXTS: RuntimeContext[] = [
+  "server",
+  "action",
+  "workflow",
+  "endpoint",
+  "test",
+  "build",
+];
+
+const AI_DENIED_CONTEXTS: RuntimeContext[] = [
+  "shared",
+  "client",
+  "query",
+  "liveQuery",
+  "command",
+  "edge",
+];
+
+const CLIENT_CONTEXTS: RuntimeContext[] = ["client"];
+
+const ALL_CONTEXTS: RuntimeContext[] = [
+  "shared",
+  "client",
+  "server",
+  "query",
+  "liveQuery",
+  "command",
+  "action",
+  "workflow",
+  "endpoint",
+  "edge",
+  "test",
+  "build",
+];
+
+function networkCapability(
+  egress: string[],
+  evidence: string[],
+): CapabilitySet {
+  const base = emptyCapabilitySet();
+  return {
+    ...base,
+    network: capability("required", "manual", evidence, { egress }),
+  };
+}
+
+export const STRIPE_RECIPE: IntegrationRecipe = {
+  alias: "stripe",
+  packages: [{ packageName: "stripe" }],
+  supportedVersionRange: ">=17.0.0",
+  recipeVersion: "2.0.0",
+  contexts: {
+    allowed: SERVER_CONTEXTS,
+    denied: ["client", "shared", "query", "liveQuery", "command"],
+  },
+  capabilities: networkCapability(["api.stripe.com"], ["recipe:stripe"]),
+  secrets: [
+    secret("STRIPE_SECRET_KEY"),
+    secret("STRIPE_WEBHOOK_SECRET"),
+  ],
+  adapters: ["stripe.server.ts", "stripe.workflow.ts"],
+  integrations: ["stripe/webhook.ts"],
+  testkits: ["stripe.mock.ts"],
+  docs: ["stripe.md"],
+};
+
+export const POSTHOG_RECIPE: IntegrationRecipe = {
+  alias: "posthog",
+  packages: [
+    {
+      packageName: "posthog-js",
+      role: "client",
+      contexts: {
+        allowed: [...CLIENT_CONTEXTS, "shared", "test", "build"],
+        denied: ["server", "query", "liveQuery", "command", "action", "workflow", "endpoint", "edge"],
+      },
+    },
+    {
+      packageName: "posthog-node",
+      role: "server",
+      contexts: {
+        allowed: SERVER_CONTEXTS,
+        denied: ["client", "shared", "query", "liveQuery", "command"],
+      },
+    },
+  ],
+  supportedVersionRange: ">=3.0.0",
+  recipeVersion: "2.0.0",
+  contexts: {
+    allowed: [...CLIENT_CONTEXTS, ...SERVER_CONTEXTS],
+    denied: ["query", "liveQuery", "command"],
+  },
+  capabilities: networkCapability(
+    ["*.posthog.com", "us.i.posthog.com", "eu.i.posthog.com"],
+    ["recipe:posthog"],
+  ),
+  secrets: [
+    secret("NEXT_PUBLIC_POSTHOG_KEY"),
+    secret("POSTHOG_KEY"),
+    secret("POSTHOG_HOST", false),
+  ],
+  adapters: ["posthog.client.ts", "posthog.server.ts"],
+  integrations: ["posthog/events.ts", "posthog/flags.ts"],
+  testkits: ["posthog.mock.ts"],
+  docs: ["posthog.md"],
+};
+
+export const SENTRY_RECIPE: IntegrationRecipe = {
+  alias: "sentry",
+  packages: [
+    {
+      packageName: "@sentry/nextjs",
+      role: "framework",
+      contexts: {
+        allowed: [...CLIENT_CONTEXTS, ...SERVER_CONTEXTS, "edge"],
+        denied: ["query", "liveQuery", "command"],
+      },
+    },
+    {
+      packageName: "@sentry/node",
+      role: "server",
+      contexts: {
+        allowed: SERVER_CONTEXTS,
+        denied: ["client", "shared", "query", "liveQuery", "command"],
+      },
+    },
+    {
+      packageName: "@sentry/browser",
+      role: "client",
+      contexts: {
+        allowed: [...CLIENT_CONTEXTS, "shared", "test", "build"],
+        denied: ["server", "query", "liveQuery", "command", "action", "workflow", "endpoint", "edge"],
+      },
+    },
+  ],
+  supportedVersionRange: ">=8.0.0",
+  recipeVersion: "2.0.0",
+  frameworkTarget: "nextjs",
+  contexts: {
+    allowed: [...CLIENT_CONTEXTS, ...SERVER_CONTEXTS, "edge"],
+    denied: ["query", "liveQuery", "command"],
+  },
+  capabilities: networkCapability(
+    ["*.sentry.io", "sentry.io"],
+    ["recipe:sentry", "source-map upload flow"],
+  ),
+  secrets: [
+    secret("SENTRY_DSN"),
+    secret("SENTRY_AUTH_TOKEN", false),
+    secret("SENTRY_ORG", false),
+    secret("SENTRY_PROJECT", false),
+  ],
+  adapters: ["sentry.client.ts", "sentry.server.ts"],
+  integrations: [
+    "sentry/errors.ts",
+    "sentry/releases.ts",
+    "sentry/sourcemaps.ts",
+  ],
+  testkits: ["sentry.mock.ts"],
+  docs: ["sentry.md"],
+};
+
+export const ZOD_RECIPE: IntegrationRecipe = {
+  alias: "zod",
+  packages: [{ packageName: "zod" }],
+  supportedVersionRange: ">=3.0.0",
+  recipeVersion: "2.0.0",
+  contexts: {
+    allowed: ALL_CONTEXTS,
+    denied: [],
+  },
+  capabilities: emptyCapabilitySet(),
+  secrets: [],
+  adapters: ["zod.shared.ts"],
+  testkits: ["zod.mock.ts"],
+  docs: ["zod.md"],
+};
+
+export const FORGE_RECIPE: IntegrationRecipe = {
+  alias: "forge",
+  packages: [{ packageName: "forge" }],
+  supportedVersionRange: ">=0.0.0",
+  recipeVersion: "1.0.0",
+  contexts: {
+    allowed: ALL_CONTEXTS,
+    denied: [],
+  },
+  capabilities: emptyCapabilitySet(),
+  secrets: [],
+  adapters: [],
+  testkits: [],
+  docs: ["AGENTS.md"],
+};
+
+export const AI_RECIPE: IntegrationRecipe = {
+  alias: "ai",
+  packages: [{ packageName: "ai" }],
+  supportedVersionRange: ">=5.0.0",
+  recipeVersion: "2.0.0",
+  contexts: {
+    allowed: AI_CONTEXTS,
+    denied: AI_DENIED_CONTEXTS,
+  },
+  capabilities: networkCapability(
+    ["provider-dependent"],
+    ["recipe:ai", "provider packages classified separately"],
+  ),
+  secrets: [
+    secret("OPENAI_API_KEY"),
+    secret("ANTHROPIC_API_KEY"),
+    secret("AI_GATEWAY_API_KEY", false),
+  ],
+  adapters: ["ai.server.ts"],
+  integrations: ["ai/generations.ts", "ai/testkit.ts"],
+  testkits: ["ai.mock.ts"],
+  docs: ["ai.md"],
+};
+
+export const AI_PROVIDER_RECIPES: IntegrationRecipe[] = [
+  {
+    alias: "ai-provider-openai",
+    packages: [{ packageName: "@ai-sdk/openai", role: "provider" }],
+    supportedVersionRange: ">=1.0.0",
+    recipeVersion: "1.0.0",
+    contexts: {
+      allowed: AI_CONTEXTS,
+      denied: AI_DENIED_CONTEXTS,
+    },
+    capabilities: networkCapability(["api.openai.com"], ["recipe:ai-provider-openai"]),
+    secrets: [secret("OPENAI_API_KEY")],
+    adapters: ["ai.openai.server.ts"],
+    testkits: ["ai.openai.mock.ts"],
+    docs: ["ai-openai.md"],
+  },
+  {
+    alias: "ai-provider-anthropic",
+    packages: [{ packageName: "@ai-sdk/anthropic", role: "provider" }],
+    supportedVersionRange: ">=1.0.0",
+    recipeVersion: "1.0.0",
+    contexts: {
+      allowed: AI_CONTEXTS,
+      denied: AI_DENIED_CONTEXTS,
+    },
+    capabilities: networkCapability(["api.anthropic.com"], ["recipe:ai-provider-anthropic"]),
+    secrets: [secret("ANTHROPIC_API_KEY")],
+    adapters: ["ai.anthropic.server.ts"],
+    testkits: ["ai.anthropic.mock.ts"],
+    docs: ["ai-anthropic.md"],
+  },
+  {
+    alias: "ai-gateway",
+    packages: [{ packageName: "ai", role: "gateway" }],
+    supportedVersionRange: ">=5.0.0",
+    recipeVersion: "1.0.0",
+    contexts: {
+      allowed: AI_CONTEXTS,
+      denied: AI_DENIED_CONTEXTS,
+    },
+    capabilities: networkCapability(["gateway.ai.vercel.dev"], ["recipe:ai-gateway"]),
+    secrets: [secret("AI_GATEWAY_API_KEY")],
+    adapters: ["ai.gateway.server.ts"],
+    testkits: ["ai.gateway.mock.ts"],
+    docs: ["ai-gateway.md"],
+  },
+];
+
+export const REFERENCE_ALIASES = [
+  "stripe",
+  "posthog",
+  "sentry",
+  "zod",
+  "ai",
+] as const;
+
+export type ReferenceAlias = (typeof REFERENCE_ALIASES)[number];

package/src/forge/compiler/recipes/helpers.ts

@@ -0,0 +1,37 @@
+import type {
+  Capability,
+  CapabilitySet,
+  SecretRequirement,
+} from "../types/capability.ts";
+
+export function capability<T = unknown>(
+  status: Capability["status"],
+  confidence: Capability["confidence"],
+  evidence: string[],
+  value?: T,
+): Capability<T> {
+  const cap: Capability<T> = { status, confidence, evidence };
+  if (value !== undefined) {
+    cap.value = value;
+  }
+  return cap;
+}
+
+export function emptyCapabilitySet(): CapabilitySet {
+  return {
+    network: capability("not-detected", "rule", ["default: no network signals"]),
+    filesystem: capability("not-detected", "rule", ["default: no filesystem signals"]),
+    process: capability("not-detected", "rule", ["default: no process signals"]),
+    nativeAddon: capability("not-detected", "rule", ["default: no native addon signals"]),
+    lifecycleScripts: capability("not-detected", "rule", ["default: scripts disabled by forge add"]),
+    secrets: [],
+  };
+}
+
+export function secret(
+  envVar: string,
+  required = true,
+  detectedFrom: SecretRequirement["detectedFrom"] = "recipe",
+): SecretRequirement {
+  return { envVar, required, detectedFrom };
+}

package/src/forge/compiler/recipes/index.ts

@@ -0,0 +1,21 @@
+export type { IntegrationRecipeRegistry } from "./registry.ts";
+export {
+  resolveRecipe,
+  resolveByPackageName,
+  supports,
+  list,
+  isReferenceAlias,
+  packageRecipeFor,
+  createRecipeRegistry,
+} from "./registry.ts";
+export {
+  RECIPE_SCHEMA_VERSION,
+  REFERENCE_ALIASES,
+  STRIPE_RECIPE,
+  POSTHOG_RECIPE,
+  SENTRY_RECIPE,
+  ZOD_RECIPE,
+  AI_RECIPE,
+  AI_PROVIDER_RECIPES,
+} from "./definitions.ts";
+export type { ReferenceAlias } from "./definitions.ts";

package/src/forge/compiler/recipes/registry.ts

@@ -0,0 +1,102 @@
+import type { IntegrationRecipe } from "../types/integration.ts";
+import type { PackageRecipe } from "../types/integration.ts";
+import {
+  AI_PROVIDER_RECIPES,
+  AI_RECIPE,
+  FORGE_RECIPE,
+  POSTHOG_RECIPE,
+  REFERENCE_ALIASES,
+  SENTRY_RECIPE,
+  STRIPE_RECIPE,
+  ZOD_RECIPE,
+} from "./definitions.ts";
+
+export interface IntegrationRecipeRegistry {
+  resolveRecipe(alias: string): IntegrationRecipe | null;
+  resolveByPackageName(packageName: string): IntegrationRecipe | null;
+  supports(alias: string): boolean;
+  list(): IntegrationRecipe[];
+}
+
+const REFERENCE_RECIPES: Record<string, IntegrationRecipe> = {
+  stripe: STRIPE_RECIPE,
+  posthog: POSTHOG_RECIPE,
+  sentry: SENTRY_RECIPE,
+  zod: ZOD_RECIPE,
+  forge: FORGE_RECIPE,
+  ai: AI_RECIPE,
+};
+
+const ALL_RECIPES: IntegrationRecipe[] = [
+  STRIPE_RECIPE,
+  POSTHOG_RECIPE,
+  SENTRY_RECIPE,
+  ZOD_RECIPE,
+  FORGE_RECIPE,
+  AI_RECIPE,
+  ...AI_PROVIDER_RECIPES,
+];
+
+function indexByPackageName(
+  recipes: IntegrationRecipe[],
+): Map<string, IntegrationRecipe> {
+  const map = new Map<string, IntegrationRecipe>();
+  for (const recipe of recipes) {
+    for (const pkg of recipe.packages) {
+      map.set(pkg.packageName, recipe);
+    }
+  }
+  return map;
+}
+
+const PACKAGE_INDEX = indexByPackageName(ALL_RECIPES);
+
+export function resolveRecipe(alias: string): IntegrationRecipe | null {
+  const normalized = alias.trim().toLowerCase();
+  const direct = REFERENCE_RECIPES[normalized];
+  if (direct) return direct;
+
+  const provider = AI_PROVIDER_RECIPES.find(
+    (r) =>
+      r.alias.toLowerCase() === normalized ||
+      r.alias === alias ||
+      r.packages.some((pkg) => pkg.packageName.toLowerCase() === normalized),
+  );
+  if (provider) return provider;
+
+  return null;
+}
+
+export function resolveByPackageName(
+  packageName: string,
+): IntegrationRecipe | null {
+  return PACKAGE_INDEX.get(packageName) ?? null;
+}
+
+export function supports(alias: string): boolean {
+  return resolveRecipe(alias) !== null;
+}
+
+export function list(): IntegrationRecipe[] {
+  return [...ALL_RECIPES];
+}
+
+export function isReferenceAlias(alias: string): boolean {
+  return (REFERENCE_ALIASES as readonly string[]).includes(alias.trim().toLowerCase());
+}
+
+export function packageRecipeFor(
+  recipe: IntegrationRecipe,
+  packageName: string,
+): PackageRecipe | undefined {
+  return recipe.packages.find((p) => p.packageName === packageName);
+}
+
+export function createRecipeRegistry(): IntegrationRecipeRegistry {
+  return {
+    resolveRecipe,
+    resolveByPackageName,
+    supports,
+    list,
+  };
+}

package/src/forge/compiler/release/build.ts

@@ -0,0 +1,100 @@
+import { join } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import { GENERATOR_VERSION } from "../emitter/constants.ts";
+import type { GeneratedReleaseArtifacts, ReleaseExportProvider } from "./types.ts";
+
+function readPackageInfo(workspaceRoot: string): { name: string; version: string } {
+  const path = join(workspaceRoot, "package.json");
+  if (!nodeFileSystem.exists(path)) {
+    return { name: "forge-app", version: "0.0.0" };
+  }
+  const pkg = JSON.parse((nodeFileSystem.readText(path) ?? "")) as {
+    name?: string;
+    version?: string;
+  };
+  return {
+    name: pkg.name ?? "forge-app",
+    version: pkg.version ?? "0.0.0",
+  };
+}
+
+export function buildGeneratedReleaseArtifacts(input: {
+  workspaceRoot: string;
+  generatedHash: string;
+}): GeneratedReleaseArtifacts {
+  const project = readPackageInfo(input.workspaceRoot);
+  const gitSha = "unknown";
+  const releaseId = `${project.name}@${project.version}+${gitSha}`;
+  const deployId = `local-${releaseId}`;
+  const optionalProviders: ReleaseExportProvider[] = [
+    "local",
+    "sentry-compatible",
+    "sentry",
+    "glitchtip",
+    "bugsink",
+    "otel",
+    "custom",
+  ];
+
+  const releaseManifest = {
+    schemaVersion: "0.1.0" as const,
+    releaseId,
+    packageName: project.name,
+    packageVersion: project.version,
+    gitSha,
+    defaultProvider: "local" as const,
+    optionalProviders,
+    env: {
+      releaseId: "FORGE_RELEASE_ID" as const,
+      deployId: "FORGE_DEPLOY_ID" as const,
+      deployEnv: "FORGE_DEPLOY_ENV" as const,
+      publicReleaseId: "NEXT_PUBLIC_FORGE_RELEASE_ID" as const,
+    },
+    diagnostics: [],
+  };
+
+  return {
+    releaseManifest,
+    deployManifest: {
+      schemaVersion: "0.1.0",
+      deployId,
+      releaseId,
+      environment: "local",
+      attributes: {
+        "service.version": releaseId,
+        "deployment.environment": "local",
+        "forge.release_id": releaseId,
+        "forge.deploy_id": deployId,
+        "forge.generated_hash": input.generatedHash,
+      },
+    },
+    artifactManifest: {
+      schemaVersion: "0.1.0",
+      releaseId,
+      artifacts: [],
+      diagnostics: [],
+    },
+    sourceMapManifest: {
+      schemaVersion: "0.1.0",
+      releaseId,
+      sourceMaps: [],
+      diagnostics: [],
+    },
+    symbolicationManifest: {
+      schemaVersion: "0.1.0",
+      releaseId,
+      localSymbolication: true,
+      sourceMapCount: 0,
+      providers: releaseManifest.optionalProviders,
+      diagnostics: [],
+    },
+    buildInfo: {
+      schemaVersion: "0.1.0",
+      packageName: project.name,
+      packageVersion: project.version,
+      gitSha,
+      releaseId,
+      generatedHash: input.generatedHash || GENERATOR_VERSION,
+    },
+  };
+}

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

@@ -0,0 +1,119 @@
+import type { Diagnostic } from "../types/diagnostic.ts";
+
+export type ReleaseExportProvider =
+  | "local"
+  | "sentry-compatible"
+  | "sentry"
+  | "glitchtip"
+  | "bugsink"
+  | "otel"
+  | "custom";
+
+export interface BuildInfo {
+  schemaVersion: "0.1.0";
+  packageName: string;
+  packageVersion: string;
+  gitSha: string;
+  releaseId: string;
+  generatedHash: string;
+}
+
+export interface ReleaseManifest {
+  schemaVersion: "0.1.0";
+  releaseId: string;
+  packageName: string;
+  packageVersion: string;
+  gitSha: string;
+  defaultProvider: "local";
+  optionalProviders: ReleaseExportProvider[];
+  env: {
+    releaseId: "FORGE_RELEASE_ID";
+    deployId: "FORGE_DEPLOY_ID";
+    deployEnv: "FORGE_DEPLOY_ENV";
+    publicReleaseId: "NEXT_PUBLIC_FORGE_RELEASE_ID";
+  };
+  diagnostics: Diagnostic[];
+}
+
+export interface DeployManifest {
+  schemaVersion: "0.1.0";
+  deployId: string;
+  releaseId: string;
+  environment: string;
+  attributes: Record<string, string>;
+}
+
+export interface ReleaseArtifact {
+  path: string;
+  kind: "javascript" | "sourcemap" | "asset" | "manifest";
+  public: boolean;
+  sizeBytes?: number;
+  sha256?: string;
+  sourceMap?: string;
+}
+
+export interface ArtifactManifest {
+  schemaVersion: "0.1.0";
+  releaseId: string;
+  artifacts: ReleaseArtifact[];
+  diagnostics: Diagnostic[];
+}
+
+export interface SourceMapEntry {
+  generatedFile: string;
+  sourceMapFile: string;
+  sources: string[];
+  debugId?: string;
+  public: boolean;
+}
+
+export interface SourceMapManifest {
+  schemaVersion: "0.1.0";
+  releaseId: string;
+  sourceMaps: SourceMapEntry[];
+  diagnostics: Diagnostic[];
+}
+
+export interface SymbolicationManifest {
+  schemaVersion: "0.1.0";
+  releaseId: string;
+  localSymbolication: true;
+  sourceMapCount: number;
+  providers: ReleaseExportProvider[];
+  diagnostics: Diagnostic[];
+}
+
+export interface GeneratedReleaseArtifacts {
+  releaseManifest: ReleaseManifest;
+  deployManifest: DeployManifest;
+  artifactManifest: ArtifactManifest;
+  sourceMapManifest: SourceMapManifest;
+  symbolicationManifest: SymbolicationManifest;
+  buildInfo: BuildInfo;
+}
+
+export interface StacktraceFrame {
+  file: string;
+  line: number;
+  column: number;
+  function?: string;
+}
+
+export interface StacktraceInput {
+  frames: StacktraceFrame[];
+}
+
+export interface SymbolicatedFrame {
+  generated: StacktraceFrame;
+  original?: {
+    source: string;
+    line: number;
+    column: number;
+    name?: string;
+  };
+}
+
+export interface SymbolicationResult {
+  frames: SymbolicatedFrame[];
+  diagnostics: Diagnostic[];
+}