forgeos 0.1.0-alpha.0

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

@@ -0,0 +1,326 @@
+import type { Diagnostic } from "../types/diagnostic.ts";
+import type { RuntimeContext } from "../types/runtime.ts";
+
+export interface AgentProjectInfo {
+  name: string;
+  type: "forgeos-app";
+  template?: string;
+}
+
+export interface AgentEntryInfo {
+  name: string;
+  file: string;
+  policy?: string;
+  allowedPackages: string[];
+  forbiddenCapabilities: string[];
+  http: AgentHttpEndpointInfo;
+  frontend: AgentFrontendUsageInfo;
+}
+
+export interface AgentHttpEndpointInfo {
+  method: "GET" | "POST";
+  path: string;
+  exampleUrl?: string;
+  exampleBody?: unknown;
+}
+
+export interface AgentFrontendUsageInfo {
+  hook: string;
+  routes: string[];
+  components: string[];
+}
+
+export interface AgentFrontendRuntimeBindingInfo {
+  kind: "command" | "query" | "liveQuery";
+  name: string;
+  file: string;
+  route?: string;
+  component?: string;
+  hook: string;
+  http: AgentHttpEndpointInfo;
+  policy?: string;
+  tablesRead: string[];
+  tablesWritten: string[];
+  emits: string[];
+  dependencies: Array<{ table: string; scope: "tenant" | "global" }>;
+}
+
+export interface AgentCommandInfo extends AgentEntryInfo {
+  tablesRead: string[];
+  tablesWritten: string[];
+  emits: string[];
+}
+
+export interface AgentQueryInfo extends AgentEntryInfo {
+  readOnly: true;
+  tenantScoped: boolean;
+  tablesRead: string[];
+}
+
+export interface AgentLiveQueryInfo extends AgentEntryInfo {
+  tablesRead: string[];
+  dependencies: Array<{ table: string; scope: "tenant" | "global" }>;
+}
+
+export interface AgentActionInfo extends AgentEntryInfo {
+  event?: string;
+  allowedCapabilities: string[];
+}
+
+export interface AgentWorkflowInfo {
+  name: string;
+  file: string;
+  trigger?: string;
+  steps: string[];
+}
+
+export interface AgentTableInfo {
+  name: string;
+  file: string;
+  tenantScoped: boolean;
+  tenantField?: string;
+  fields: string[];
+}
+
+export interface AgentDataInfo {
+  tables: AgentTableInfo[];
+}
+
+export interface AgentPolicyInfo {
+  name: string;
+  kind: "roles" | "public" | "system";
+  roles: string[];
+  file: string;
+}
+
+export interface AgentPackageInfo {
+  name: string;
+  version: string;
+  allowedContexts: RuntimeContext[];
+  deniedContexts: RuntimeContext[];
+}
+
+export interface AgentIntegrationInfo {
+  alias: string;
+  packages: string[];
+  secrets: string[];
+  allowedContexts: RuntimeContext[];
+  deniedContexts: RuntimeContext[];
+}
+
+export interface AgentSecretInfo {
+  name: string;
+  integration?: string;
+  required: boolean;
+  public?: boolean;
+  allowedContexts: RuntimeContext[];
+}
+
+export interface AgentTelemetryInfo {
+  events: string[];
+  sinks: string[];
+}
+
+export interface AgentAiInfo {
+  providers: string[];
+  generations: Array<{
+    provider: string;
+    model: string;
+    method: string;
+    file: string;
+    purpose?: string;
+  }>;
+}
+
+export interface AgentClientInfo {
+  queries: string[];
+  commands: string[];
+  liveQueries: string[];
+  reactHooks: string[];
+  transport: Record<string, string>;
+}
+
+export interface AgentFrontendInfo {
+  present: boolean;
+  framework: string;
+  root?: string;
+  dev?: {
+    command: string;
+    url: string;
+    apiUrlEnv: string;
+    defaultApiUrl: string;
+  };
+  routes: Array<{
+    path: string;
+    file: string;
+    components: string[];
+    usesCommands: string[];
+    usesQueries: string[];
+    usesLiveQueries: string[];
+    rawForgeFetches: string[];
+  }>;
+  components: Array<{
+    name: string;
+    file: string;
+    usesCommands: string[];
+    usesQueries: string[];
+    usesLiveQueries: string[];
+    rawForgeFetches: string[];
+  }>;
+  providers: Array<{
+    name: string;
+    file: string;
+    apiUrlEnv?: string;
+    devAuth: boolean;
+    devAuthUserId?: string;
+    devAuthTenantId?: string;
+    devAuthRole?: string;
+  }>;
+  bridgeFiles: string[];
+  webManifest: {
+    present: boolean;
+    framework: string;
+    root?: string;
+    packageManager?: string;
+    scripts: {
+      dev?: string;
+      build?: string;
+      typecheck?: string;
+    };
+    urls: {
+      dev?: string;
+      api: string;
+    };
+    env: {
+      apiUrl: string;
+    };
+    bridge: {
+      files: string[];
+      valid: boolean;
+    };
+  };
+  clientBindings: Array<{
+    kind: "command" | "query" | "liveQuery" | "rawFetch";
+    name: string;
+    file: string;
+    route?: string;
+    component?: string;
+  }>;
+  runtimeEndpoints: Array<{
+    kind: "command" | "query" | "liveQuery";
+    name: string;
+    http: AgentHttpEndpointInfo;
+    frontend: AgentFrontendUsageInfo;
+  }>;
+  routeBindings: AgentFrontendRuntimeBindingInfo[];
+  componentBindings: AgentFrontendRuntimeBindingInfo[];
+  diagnostics: Diagnostic[];
+}
+
+export interface AgentAuthInfo {
+  modes: Array<"dev-headers" | "jwt" | "oidc" | "disabled">;
+  defaultMode: "dev-headers";
+  productionDefaultAllowed: false;
+  bearerTokenHeader: "Authorization";
+  env: {
+    mode: string;
+    issuer: string;
+    audience: string;
+    jwksUri: string;
+    algorithms: string;
+  };
+  claims: {
+    userId: string;
+    tenantId?: string;
+    role?: string;
+    roles?: string;
+    permissions?: string;
+    email?: string;
+    name?: string;
+  };
+  requiresTenant: boolean;
+}
+
+export interface AgentDeployInfo {
+  selfHost: boolean;
+  files: string[];
+}
+
+export interface AgentRuntimeRule {
+  context: "command" | "query" | "liveQuery" | "action" | "workflow";
+  allowed: string[];
+  forbidden: string[];
+}
+
+export type AgentCapabilityStatus = "covered" | "backend-only" | "frontend-only" | "warning";
+
+export interface AgentCapabilityMapEntry {
+  id: string;
+  status: AgentCapabilityStatus;
+  userAction: string;
+  ui?: {
+    route?: string;
+    component?: string;
+    file: string;
+  };
+  runtime?: {
+    kind: "command" | "query" | "liveQuery";
+    name: string;
+    hook: string;
+    http: AgentHttpEndpointInfo;
+    policy?: string;
+    tablesRead: string[];
+    tablesWritten: string[];
+    emits: string[];
+    dependencies: Array<{ table: string; scope: "tenant" | "global" }>;
+  };
+  notes: string[];
+}
+
+export interface AgentCapabilityMap {
+  schemaVersion: "0.1.0";
+  generatorVersion: string;
+  project: AgentProjectInfo;
+  summary: {
+    covered: number;
+    backendOnly: number;
+    frontendOnly: number;
+    warnings: number;
+  };
+  entries: AgentCapabilityMapEntry[];
+  diagnostics: Diagnostic[];
+}
+
+export interface AgentPlaybook {
+  title: string;
+  steps: string[];
+}
+
+export interface AgentContract {
+  schemaVersion: string;
+  generatorVersion: string;
+  project: AgentProjectInfo;
+  commands: AgentCommandInfo[];
+  queries: AgentQueryInfo[];
+  liveQueries: AgentLiveQueryInfo[];
+  actions: AgentActionInfo[];
+  workflows: AgentWorkflowInfo[];
+  data: AgentDataInfo;
+  policies: AgentPolicyInfo[];
+  packages: AgentPackageInfo[];
+  integrations: AgentIntegrationInfo[];
+  secrets: AgentSecretInfo[];
+  telemetry: AgentTelemetryInfo;
+  ai: AgentAiInfo;
+  client: AgentClientInfo;
+  frontend: AgentFrontendInfo;
+  auth: AgentAuthInfo;
+  deploy?: AgentDeployInfo;
+  rules: AgentRuntimeRule[];
+  playbooks: AgentPlaybook[];
+  commandsToRun: {
+    beforeEditing: string[];
+    afterEditing: string[];
+    dev: string[];
+  };
+}

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

@@ -0,0 +1,165 @@
+import { GENERATOR_VERSION } from "../emitter/constants.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+import type { AppGraph } from "../types/app-graph.ts";
+import type {
+  AiGenerationCall,
+  AiModelDefinition,
+  AiProviderDefinition,
+  AiRegistry,
+  ForgeAiProvider,
+} from "../types/ai-registry.ts";
+import type { ClassifiedPackage } from "../classifier/runtime-matrix.ts";
+import { resolveByPackageName } from "../recipes/registry.ts";
+import {
+  AI_REGISTRY_ANALYZER_VERSION,
+  AI_REGISTRY_SCHEMA_VERSION,
+} from "./constants.ts";
+import { parseAiCallsFromSlice } from "./parse.ts";
+
+const KNOWN_MODELS: AiModelDefinition[] = [
+  {
+    provider: "openai",
+    model: "gpt-4o",
+    inputCostPer1kTokensUsd: 0.0025,
+    outputCostPer1kTokensUsd: 0.01,
+  },
+  {
+    provider: "openai",
+    model: "gpt-4o-mini",
+    inputCostPer1kTokensUsd: 0.00015,
+    outputCostPer1kTokensUsd: 0.0006,
+  },
+  {
+    provider: "anthropic",
+    model: "claude-3-5-sonnet-20241022",
+    inputCostPer1kTokensUsd: 0.003,
+    outputCostPer1kTokensUsd: 0.015,
+  },
+  {
+    provider: "anthropic",
+    model: "claude-3-5-haiku-20241022",
+    inputCostPer1kTokensUsd: 0.0008,
+    outputCostPer1kTokensUsd: 0.004,
+  },
+  {
+    provider: "gateway",
+    model: "openai/gpt-4o",
+    inputCostPer1kTokensUsd: 0.0025,
+    outputCostPer1kTokensUsd: 0.01,
+  },
+];
+
+function buildProviders(classified: ClassifiedPackage[]): AiProviderDefinition[] {
+  const providers = new Map<ForgeAiProvider, AiProviderDefinition>();
+
+  for (const pkg of classified) {
+    const recipe = pkg.recipe ?? resolveByPackageName(pkg.api.name);
+    if (!recipe) continue;
+
+    const alias = recipe.alias;
+    if (alias === "ai-provider-openai" || alias === "@ai-sdk/openai") {
+      providers.set("openai", {
+        id: "openai",
+        packageName: "@ai-sdk/openai",
+        secretName: "OPENAI_API_KEY",
+        integration: "ai-provider-openai",
+      });
+    }
+    if (alias === "ai-provider-anthropic" || alias === "@ai-sdk/anthropic") {
+      providers.set("anthropic", {
+        id: "anthropic",
+        packageName: "@ai-sdk/anthropic",
+        secretName: "ANTHROPIC_API_KEY",
+        integration: "ai-provider-anthropic",
+      });
+    }
+    if (alias === "ai-gateway" || alias === "ai") {
+      providers.set("gateway", {
+        id: "gateway",
+        packageName: "ai",
+        secretName: "AI_GATEWAY_API_KEY",
+        integration: "ai-gateway",
+      });
+    }
+  }
+
+  if (providers.size === 0) {
+    return [
+      {
+        id: "openai",
+        packageName: "@ai-sdk/openai",
+        secretName: "OPENAI_API_KEY",
+        integration: "ai-provider-openai",
+      },
+      {
+        id: "anthropic",
+        packageName: "@ai-sdk/anthropic",
+        secretName: "ANTHROPIC_API_KEY",
+        integration: "ai-provider-anthropic",
+      },
+      {
+        id: "gateway",
+        packageName: "ai",
+        secretName: "AI_GATEWAY_API_KEY",
+        integration: "ai-gateway",
+      },
+    ];
+  }
+
+  return [...providers.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export function buildAiModels(): AiModelDefinition[] {
+  return [...KNOWN_MODELS].sort((a, b) =>
+    a.provider === b.provider
+      ? a.model.localeCompare(b.model)
+      : a.provider.localeCompare(b.provider),
+  );
+}
+
+export function buildAiRegistry(
+  appGraph: AppGraph,
+  classified: ClassifiedPackage[],
+): AiRegistry {
+  const generations: AiGenerationCall[] = [];
+
+  for (const symbol of appGraph.symbols) {
+    const sourceSlice =
+      typeof symbol.meta.sourceSlice === "string" ? symbol.meta.sourceSlice : "";
+    if (sourceSlice.length === 0) continue;
+
+    for (const call of parseAiCallsFromSlice(sourceSlice)) {
+      generations.push({
+        provider: call.provider ?? "openai",
+        model: call.model ?? "unknown",
+        purpose: call.purpose,
+        method: call.method,
+        file: symbol.file,
+      });
+    }
+  }
+
+  generations.sort((a, b) => {
+    const fileCmp = a.file.localeCompare(b.file);
+    if (fileCmp !== 0) return fileCmp;
+    return a.method.localeCompare(b.method);
+  });
+
+  return {
+    schemaVersion: AI_REGISTRY_SCHEMA_VERSION,
+    generatorVersion: GENERATOR_VERSION,
+    analyzerVersion: AI_REGISTRY_ANALYZER_VERSION,
+    inputHash: hashStable(
+      canonicalJson({
+        appInputHash: appGraph.inputHash,
+        analyzerVersion: AI_REGISTRY_ANALYZER_VERSION,
+      }),
+    ),
+    providers: buildProviders(classified),
+    generations,
+    diagnostics: [],
+  };
+}
+
+export { KNOWN_MODELS };

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

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

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

@@ -0,0 +1,56 @@
+import type { ForgeAiProvider } from "../types/ai-registry.ts";
+
+const AI_METHOD_PATTERN =
+  /(?:ctx\.ai|ai)\.(generateText|streamText|generateStructured)\s*\(/g;
+
+const PROVIDER_PATTERN =
+  /provider\s*:\s*["'](openai|anthropic|gateway)["']/;
+
+const MODEL_PATTERN = /model\s*:\s*["']([^"']+)["']/;
+
+const PURPOSE_PATTERN = /purpose\s*:\s*["']([^"']+)["']/;
+
+export interface ParsedAiCall {
+  method: "generateText" | "streamText" | "generateStructured";
+  provider?: ForgeAiProvider;
+  model?: string;
+  purpose?: string;
+}
+
+export function parseAiCallsFromSlice(sourceSlice: string): ParsedAiCall[] {
+  const calls: ParsedAiCall[] = [];
+
+  for (const match of sourceSlice.matchAll(AI_METHOD_PATTERN)) {
+    const method = match[1] as ParsedAiCall["method"];
+    const start = match.index ?? 0;
+    const window = sourceSlice.slice(start, start + 600);
+
+    let provider: ForgeAiProvider | undefined;
+    const providerMatch = PROVIDER_PATTERN.exec(window);
+    if (providerMatch?.[1]) {
+      provider = providerMatch[1] as ForgeAiProvider;
+    }
+
+    let model: string | undefined;
+    const modelMatch = MODEL_PATTERN.exec(window);
+    if (modelMatch?.[1]) {
+      model = modelMatch[1];
+    }
+
+    let purpose: string | undefined;
+    const purposeMatch = PURPOSE_PATTERN.exec(window);
+    if (purposeMatch?.[1]) {
+      purpose = purposeMatch[1];
+    }
+
+    calls.push({ method, provider, model, purpose });
+  }
+
+  return calls;
+}
+
+const FORBIDDEN_AI_CONTEXT_PATTERN = /ctx\.ai\./;
+
+export function detectCtxAiUsage(sourceSlice: string): boolean {
+  return FORBIDDEN_AI_CONTEXT_PATTERN.test(sourceSlice);
+}

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

@@ -0,0 +1,107 @@
+import { hashStable } from "../primitives/hash.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+import { GENERATOR_VERSION } from "../emitter/constants.ts";
+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";
+
+export interface ApiSurface {
+  schemaVersion: string;
+  generatorVersion: string;
+  inputHash: string;
+  queries: Record<string, string>;
+  commands: Record<string, string>;
+  liveQueries: Record<string, string>;
+  actions: Record<string, string>;
+  workflows: Record<string, string>;
+}
+
+export function buildApiSurface(
+  runtimeGraph: RuntimeGraph,
+  queryRegistry: QueryRegistry,
+  liveQueryRegistry: LiveQueryRegistry,
+  workflowRegistry: WorkflowRegistry,
+): ApiSurface {
+  const queries: Record<string, string> = {};
+  for (const query of queryRegistry.queries) {
+    queries[query.name] = query.name;
+  }
+
+  const liveQueries: Record<string, string> = {};
+  for (const liveQuery of liveQueryRegistry.liveQueries) {
+    liveQueries[liveQuery.name] = liveQuery.name;
+  }
+
+  const commands: Record<string, string> = {};
+  const actions: Record<string, string> = {};
+  for (const entry of runtimeGraph.entries) {
+    if (entry.kind === "command") {
+      commands[entry.name] = entry.name;
+    } else {
+      actions[entry.name] = entry.name;
+    }
+  }
+
+  const workflows: Record<string, string> = {};
+  for (const workflow of workflowRegistry.workflows) {
+    workflows[workflow.name] = workflow.name;
+  }
+
+  return {
+    schemaVersion: "1.0.0",
+    generatorVersion: GENERATOR_VERSION,
+    inputHash: hashStable(
+      canonicalJson({
+        runtimeInputHash: runtimeGraph.inputHash,
+        queryInputHash: queryRegistry.inputHash,
+        liveQueryInputHash: liveQueryRegistry.inputHash,
+        workflowInputHash: workflowRegistry.inputHash,
+      }),
+    ),
+    queries,
+    commands,
+    liveQueries,
+    actions,
+    workflows,
+  };
+}
+
+export function serializeApiTs(surface: ApiSurface): string {
+  return `export const api = ${JSON.stringify(
+    {
+      queries: surface.queries,
+      commands: surface.commands,
+      liveQueries: surface.liveQueries,
+      actions: surface.actions,
+      workflows: surface.workflows,
+    },
+    null,
+    2,
+  )} as const;\n`;
+}
+
+export function serializeServerApiTs(_surface: ApiSurface): string {
+  return `import { api } from "./api.ts";
+
+export const serverApi = {
+  queries: api.queries,
+  commands: api.commands,
+  liveQueries: api.liveQueries,
+  actions: api.actions,
+  workflows: api.workflows,
+} as const;
+`;
+}
+
+export function serializeClientApiTs(_surface: ApiSurface): string {
+  return `import { api } from "./api.ts";
+
+/** Client-side typed API surface (queries, commands; no server adapters). */
+export const clientApi = {
+  queries: api.queries,
+  commands: api.commands,
+  liveQueries: api.liveQueries,
+} as const;
+`;
+}