forgeos 0.1.0-alpha.0

package/src/forge/compiler/live-production/types.ts

@@ -0,0 +1,122 @@
+import type { LiveQueryRegistry } from "../types/live-query-registry.ts";
+
+export interface LiveProductionManifest {
+  schemaVersion: "0.1.0";
+  mode: "production-hardened";
+  dependencyGranularity: "table-tenant";
+  invalidationSource: "durable-table";
+  wakeupAdapters: ("postgres-notify" | "polling")[];
+  transports: ("sse")[];
+  liveQueries: Array<{
+    name: string;
+    policy?: string;
+    file: string;
+  }>;
+  limits: {
+    maxSubscriptionsPerClient: number;
+    maxSubscriptionsPerTenant: number;
+    maxSnapshotBytes: number;
+    maxPendingMessagesPerSubscription: number;
+    heartbeatIntervalMs: number;
+    rerunDebounceMs: number;
+  };
+}
+
+export interface LiveProtocolManifest {
+  schemaVersion: "0.1.0";
+  protocolVersion: "0.1.0";
+  messages: string[];
+  resume: {
+    sseLastEventId: true;
+    queryParam: "lastRevision";
+  };
+  snapshot: {
+    includesRevision: true;
+    includesReleaseId: true;
+    fullSnapshotOnly: true;
+  };
+}
+
+export interface LiveTransportConfig {
+  schemaVersion: "0.1.0";
+  defaultTransport: "sse";
+  transports: {
+    sse: {
+      endpoint: "/live/:name";
+      multiplexEndpoint: "/live/stream";
+      heartbeat: true;
+      oneConnectionPerClientRecommended: true;
+    };
+  };
+  selfHostEnv: Record<string, string>;
+}
+
+export interface LiveProductionArtifacts {
+  liveProductionManifest: LiveProductionManifest;
+  liveProtocol: LiveProtocolManifest;
+  liveTransportConfig: LiveTransportConfig;
+}
+
+export function buildLiveProductionArtifacts(
+  registry: LiveQueryRegistry,
+): LiveProductionArtifacts {
+  const limits = {
+    maxSubscriptionsPerClient: 50,
+    maxSubscriptionsPerTenant: 500,
+    maxSnapshotBytes: 1_000_000,
+    maxPendingMessagesPerSubscription: 5,
+    heartbeatIntervalMs: 15_000,
+    rerunDebounceMs: 50,
+  };
+
+  return {
+    liveProductionManifest: {
+      schemaVersion: "0.1.0",
+      mode: "production-hardened",
+      dependencyGranularity: "table-tenant",
+      invalidationSource: "durable-table",
+      wakeupAdapters: ["postgres-notify", "polling"],
+      transports: ["sse"],
+      liveQueries: registry.liveQueries
+        .map((liveQuery) => ({
+          name: liveQuery.name,
+          ...(liveQuery.policy ? { policy: liveQuery.policy } : {}),
+          file: liveQuery.file,
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name)),
+      limits,
+    },
+    liveProtocol: {
+      schemaVersion: "0.1.0",
+      protocolVersion: "0.1.0",
+      messages: ["hello", "snapshot", "error", "heartbeat", "reset"],
+      resume: {
+        sseLastEventId: true,
+        queryParam: "lastRevision",
+      },
+      snapshot: {
+        includesRevision: true,
+        includesReleaseId: true,
+        fullSnapshotOnly: true,
+      },
+    },
+    liveTransportConfig: {
+      schemaVersion: "0.1.0",
+      defaultTransport: "sse",
+      transports: {
+        sse: {
+          endpoint: "/live/:name",
+          multiplexEndpoint: "/live/stream",
+          heartbeat: true,
+          oneConnectionPerClientRecommended: true,
+        },
+      },
+      selfHostEnv: {
+        FORGE_LIVE_TRANSPORT: "sse",
+        FORGE_LIVE_INVALIDATION: "polling,postgres-notify",
+        FORGE_LIVE_POLL_INTERVAL_MS: "1000",
+        FORGE_LIVE_HEARTBEAT_MS: "15000",
+      },
+    },
+  };
+}

package/src/forge/compiler/live-query-registry/build.ts

@@ -0,0 +1,150 @@
+import { createDiagnostic } from "../diagnostics/create.ts";
+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 {
+  LiveQueryDefinition,
+  LiveQueryRegistry,
+  SubscriptionManifest,
+} from "../types/live-query-registry.ts";
+import {
+  LIVE_QUERY_REGISTRY_ANALYZER_VERSION,
+  LIVE_QUERY_REGISTRY_SCHEMA_VERSION,
+} from "./constants.ts";
+
+function moduleIdForFile(
+  moduleGraph: AppGraph["moduleGraph"],
+  file: string,
+): string | null {
+  const node = moduleGraph.nodes.find((candidate) => candidate.file === file);
+  return node?.id ?? null;
+}
+
+function stableSortLiveQueries(
+  liveQueries: LiveQueryDefinition[],
+): LiveQueryDefinition[] {
+  return [...liveQueries].sort((a, b) => {
+    if (a.name !== b.name) {
+      return a.name < b.name ? -1 : 1;
+    }
+    return a.file < b.file ? -1 : a.file > b.file ? 1 : 0;
+  });
+}
+
+function detectDuplicateLiveQueryNames(
+  liveQueries: LiveQueryDefinition[],
+): LiveQueryRegistry["diagnostics"] {
+  const byName = new Map<string, LiveQueryDefinition[]>();
+
+  for (const liveQuery of liveQueries) {
+    const list = byName.get(liveQuery.name) ?? [];
+    list.push(liveQuery);
+    byName.set(liveQuery.name, list);
+  }
+
+  const diagnostics: LiveQueryRegistry["diagnostics"] = [];
+
+  for (const [name, group] of byName) {
+    if (group.length <= 1) {
+      continue;
+    }
+
+    for (const liveQuery of group) {
+      diagnostics.push(
+        createDiagnostic({
+          severity: "warning",
+          code: "FORGE_DUP_QUERY",
+          message: `duplicate liveQuery name '${name}'`,
+          file: liveQuery.file,
+        }),
+      );
+    }
+  }
+
+  return diagnostics.sort((a, b) => {
+    const fileA = a.file ?? "";
+    const fileB = b.file ?? "";
+    if (fileA !== fileB) {
+      return fileA < fileB ? -1 : 1;
+    }
+    return a.message < b.message ? -1 : a.message > b.message ? 1 : 0;
+  });
+}
+
+function parsePolicyFromSourceSlice(sourceSlice: string): string | undefined {
+  const match = sourceSlice.match(/auth\s*:\s*can\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/);
+  return match?.[1];
+}
+
+export function buildLiveQueryRegistry(appGraph: AppGraph): LiveQueryRegistry {
+  const liveQueries: LiveQueryDefinition[] = [];
+  const diagnostics: LiveQueryRegistry["diagnostics"] = [];
+
+  for (const symbol of appGraph.symbols) {
+    if (symbol.kind !== "liveQuery") {
+      continue;
+    }
+
+    const moduleId = moduleIdForFile(appGraph.moduleGraph, symbol.file);
+    if (moduleId === null) {
+      diagnostics.push(
+        createDiagnostic({
+          severity: "warning",
+          code: "FORGE_QUERY_UNRESOLVABLE",
+          message: `cannot resolve module for liveQuery '${symbol.qualifiedName}'`,
+          file: symbol.file,
+          span: symbol.span,
+        }),
+      );
+      continue;
+    }
+
+    const sourceSlice =
+      typeof symbol.meta.sourceSlice === "string" ? symbol.meta.sourceSlice : "";
+
+    liveQueries.push({
+      name: symbol.name,
+      qualifiedName: symbol.qualifiedName,
+      file: symbol.file,
+      exportName: symbol.name,
+      symbolId: symbol.id,
+      moduleId,
+      ...(sourceSlice.length > 0
+        ? { policy: parsePolicyFromSourceSlice(sourceSlice) }
+        : {}),
+    });
+  }
+
+  const dupDiagnostics = detectDuplicateLiveQueryNames(liveQueries);
+
+  return {
+    schemaVersion: LIVE_QUERY_REGISTRY_SCHEMA_VERSION,
+    generatorVersion: GENERATOR_VERSION,
+    analyzerVersion: LIVE_QUERY_REGISTRY_ANALYZER_VERSION,
+    inputHash: hashStable(
+      canonicalJson({
+        appInputHash: appGraph.inputHash,
+        analyzerVersion: LIVE_QUERY_REGISTRY_ANALYZER_VERSION,
+      }),
+    ),
+    liveQueries: stableSortLiveQueries(liveQueries),
+    diagnostics: [...diagnostics, ...dupDiagnostics],
+  };
+}
+
+export function buildSubscriptionManifest(
+  registry: LiveQueryRegistry,
+): SubscriptionManifest {
+  return {
+    schemaVersion: registry.schemaVersion,
+    generatorVersion: registry.generatorVersion,
+    inputHash: registry.inputHash,
+    liveQueries: registry.liveQueries.map((liveQuery) => ({
+      name: liveQuery.name,
+      file: liveQuery.file,
+      exportName: liveQuery.exportName,
+      ...(liveQuery.policy ? { policy: liveQuery.policy } : {}),
+    })),
+  };
+}

package/src/forge/compiler/live-query-registry/constants.ts

@@ -0,0 +1,2 @@
+export const LIVE_QUERY_REGISTRY_SCHEMA_VERSION = "0.1.0";
+export const LIVE_QUERY_REGISTRY_ANALYZER_VERSION = "0.1.0";

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

@@ -0,0 +1,179 @@
+import { serializeCanonical } from "../primitives/serialize.ts";
+
+export interface MakePrimitiveInfo {
+  name: string;
+  summary: string;
+  creates: string[];
+  modifies: string[];
+  examples: string[];
+}
+
+export interface MakeRegistryArtifact {
+  schemaVersion: "0.1.0";
+  generatorVersion: string;
+  primitives: MakePrimitiveInfo[];
+  planDirectory: ".forge/make-plans";
+  commands: string[];
+}
+
+export interface MakeTemplateArtifact {
+  schemaVersion: "0.1.0";
+  templates: Array<{
+    name: string;
+    sourceKind: "schema" | "policy" | "runtime" | "frontend" | "test";
+    outputPattern: string;
+  }>;
+}
+
+export function buildMakeRegistry(generatorVersion: string): MakeRegistryArtifact {
+  return {
+    schemaVersion: "0.1.0",
+    generatorVersion,
+    planDirectory: ".forge/make-plans",
+    commands: [
+      "forge make list --json",
+      "forge make explain <primitive> --json",
+      "forge make ui --framework vite --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>",
+    ],
+    primitives: [
+      {
+        name: "table",
+        summary: "Add a schema table declaration.",
+        creates: [],
+        modifies: ["src/forge/schema.ts"],
+        examples: ["forge make table invoices --fields amount:number,status:text"],
+      },
+      {
+        name: "field",
+        summary: "Add a field to an existing table declaration.",
+        creates: [],
+        modifies: ["src/forge/schema.ts"],
+        examples: ["forge make field invoices.status --type enum --values draft,paid"],
+      },
+      {
+        name: "policy",
+        summary: "Add a named policy with allowed roles.",
+        creates: ["src/policies.ts when missing"],
+        modifies: ["src/policies.ts"],
+        examples: ["forge make policy invoices.read --roles owner,admin,member"],
+      },
+      {
+        name: "command",
+        summary: "Add a transactional command with policy and optional event emission.",
+        creates: ["src/commands/<name>.ts"],
+        modifies: [],
+        examples: ["forge make command invoices.create --table invoices --policy invoices.create --emit invoice.created"],
+      },
+      {
+        name: "query",
+        summary: "Add a read-only query.",
+        creates: ["src/queries/<name>.ts"],
+        modifies: [],
+        examples: ["forge make query invoices.list --table invoices --policy invoices.read"],
+      },
+      {
+        name: "livequery",
+        summary: "Add a read-only liveQuery for reactive clients.",
+        creates: ["src/queries/live<Name>.ts"],
+        modifies: [],
+        examples: ["forge make livequery invoices.live --table invoices --policy invoices.read"],
+      },
+      {
+        name: "action",
+        summary: "Add an after-commit action subscribed to an event.",
+        creates: ["src/actions/<name>.ts"],
+        modifies: [],
+        examples: ["forge make action captureInvoiceCreated --event invoice.created"],
+      },
+      {
+        name: "workflow",
+        summary: "Add a durable workflow triggered by an event.",
+        creates: ["src/workflows/<name>.ts"],
+        modifies: [],
+        examples: ["forge make workflow invoiceWorkflow --table invoices --trigger invoice.created"],
+      },
+      {
+        name: "component",
+        summary: "Add a React component that uses generated Forge client hooks.",
+        creates: ["web/components/<Component>.tsx"],
+        modifies: [],
+        examples: ["forge make component InvoiceList --table invoices"],
+      },
+      {
+        name: "page",
+        summary: "Add a minimal app page wired to generated components.",
+        creates: ["web/app/<route>/page.tsx"],
+        modifies: [],
+        examples: ["forge make page invoices --table invoices --with-create-form"],
+      },
+      {
+        name: "ui",
+        summary: "Add a Vite React frontend shell with ForgeProvider devAuth and a generated client bridge.",
+        creates: [
+          "web/package.json",
+          "web/index.html",
+          "web/src/lib/forge.ts",
+          "web/src/main.tsx",
+          "web/src/App.tsx",
+        ],
+        modifies: [],
+        examples: ["forge make ui --framework vite --yes"],
+      },
+      {
+        name: "resource",
+        summary: "Add schema, policies, CRUD, queries, liveQuery, optional UI, and tests.",
+        creates: [
+          "src/commands/*",
+          "src/queries/*",
+          "src/actions/*",
+          "web/components/*",
+          "web/app/*",
+          "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"],
+      },
+    ],
+  };
+}
+
+export function buildMakeTemplates(): MakeTemplateArtifact {
+  return {
+    schemaVersion: "0.1.0",
+    templates: [
+      { name: "schema-table", sourceKind: "schema", outputPattern: "src/forge/schema.ts" },
+      { name: "policy", sourceKind: "policy", outputPattern: "src/policies.ts" },
+      { name: "command", sourceKind: "runtime", outputPattern: "src/commands/<name>.ts" },
+      { name: "query", sourceKind: "runtime", outputPattern: "src/queries/<name>.ts" },
+      { name: "livequery", sourceKind: "runtime", outputPattern: "src/queries/live<Name>.ts" },
+      { name: "action", sourceKind: "runtime", outputPattern: "src/actions/<name>.ts" },
+      { 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: "placeholder-test", sourceKind: "test", outputPattern: "tests/make-generated/<name>.test.ts" },
+    ],
+  };
+}
+
+export function serializeMakeRegistryJson(registry: MakeRegistryArtifact): string {
+  return serializeCanonical(registry);
+}
+
+export function serializeMakeRegistryTs(registry: MakeRegistryArtifact): string {
+  const parsed: unknown = JSON.parse(serializeMakeRegistryJson(registry).trimEnd());
+  return `export const makeRegistry = ${JSON.stringify(parsed, null, 2)} as const;\n`;
+}
+
+export function serializeMakeTemplatesJson(templates: MakeTemplateArtifact): string {
+  return serializeCanonical(templates);
+}
+
+export function serializeMakeTemplatesTs(templates: MakeTemplateArtifact): string {
+  const parsed: unknown = JSON.parse(serializeMakeTemplatesJson(templates).trimEnd());
+  return `export const makeTemplates = ${JSON.stringify(parsed, null, 2)} as const;\n`;
+}

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

@@ -0,0 +1,214 @@
+import { join } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import type { Dependency } from "../types/package-graph.ts";
+import { hashTsconfigForWorkspace } from "../app-graph/tsconfig-hash.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+import { detectPackageManager } from "../package-manager/detect.ts";
+import {
+  getLockfileCandidates,
+  getLockfileForPm,
+} from "../package-manager/detect.ts";
+import { GENERATED_DIR } from "../emitter/constants.ts";
+import type { DiscoverContext } from "./types.ts";
+import {
+  type SourceFileIndex,
+  walkWorkspaceSources,
+} from "./workspace-index.ts";
+
+const DEFAULT_SOURCE_ROOTS = ["src", "tests"];
+
+function readTextHash(absolutePath: string): string {
+  return hashStable((nodeFileSystem.readText(absolutePath) ?? ""));
+}
+
+function hashFileIfExists(absolutePath: string): string {
+  if (!nodeFileSystem.exists(absolutePath)) {
+    return "";
+  }
+  return readTextHash(absolutePath);
+}
+
+function resolveLockfilePath(workspaceRoot: string): string | null {
+  const pm = detectPackageManager(workspaceRoot);
+  const candidates = getLockfileCandidates(pm);
+  for (const file of candidates) {
+    const absolute = join(workspaceRoot, file);
+    if (nodeFileSystem.exists(absolute)) {
+      return absolute;
+    }
+  }
+
+  const fallback = join(workspaceRoot, getLockfileForPm(pm));
+  return nodeFileSystem.exists(fallback) ? fallback : null;
+}
+
+interface WorkspacePackageJson {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  forge?: {
+    sourceRoots?: string[];
+  };
+}
+
+function readPackageJson(workspaceRoot: string): WorkspacePackageJson {
+  const raw = (nodeFileSystem.readText(join(workspaceRoot, "package.json")) ?? "");
+  return JSON.parse(raw) as WorkspacePackageJson;
+}
+
+function resolveSourceRoots(
+  workspaceRoot: string,
+  override?: string[],
+): string[] {
+  if (override) {
+    return override;
+  }
+
+  try {
+    const configured = readPackageJson(workspaceRoot).forge?.sourceRoots;
+    if (configured && configured.length > 0) {
+      return configured;
+    }
+  } catch {
+    // fall back to defaults
+  }
+
+  return DEFAULT_SOURCE_ROOTS;
+}
+
+function resolveDependency(
+  workspaceRoot: string,
+  name: string,
+  specifier: string,
+  packageManager: ReturnType<typeof detectPackageManager>,
+): Dependency | null {
+  const installPath = join(workspaceRoot, "node_modules", name);
+  if (!nodeFileSystem.exists(installPath)) {
+    return null;
+  }
+
+  let version = specifier.replace(/^[\^~>=<]*/, "").trim();
+  const pkgJsonPath = join(installPath, "package.json");
+  if (nodeFileSystem.exists(pkgJsonPath)) {
+    try {
+      const installed = JSON.parse((nodeFileSystem.readText(pkgJsonPath) ?? "")) as {
+        version?: string;
+      };
+      if (installed.version) {
+        version = installed.version;
+      }
+    } catch {
+      // keep specifier-derived version
+    }
+  }
+
+  return {
+    name,
+    version,
+    packageManager,
+    installPath: installPath.replace(/\\/g, "/"),
+  };
+}
+
+function collectDependencies(workspaceRoot: string): Dependency[] {
+  const packageManager = detectPackageManager(workspaceRoot);
+  const pkg = readPackageJson(workspaceRoot);
+  const specs = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+  };
+
+  const deps: Dependency[] = [];
+  for (const [name, specifier] of Object.entries(specs)) {
+    const dep = resolveDependency(
+      workspaceRoot,
+      name,
+      specifier,
+      packageManager,
+    );
+    if (dep) {
+      deps.push(dep);
+    }
+  }
+
+  deps.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+  return deps;
+}
+
+function computeSourceFingerprint(sources: import("../types/app-graph.ts").SourceFile[]): string {
+  const payload = sources.map((source) => ({
+    path: source.path,
+    contentHash: source.contentHash,
+  }));
+  return hashStable(canonicalJson(payload));
+}
+
+function computeInputFingerprint(parts: {
+  sourceFingerprint: string;
+  packageJsonHash: string;
+  lockfileHash: string;
+  tsconfigHash: string;
+  dependencyVersions: Array<{ name: string; version: string }>;
+}): string {
+  return hashStable(canonicalJson(parts));
+}
+
+export function getSourceRoots(workspaceRoot: string, override?: string[]): string[] {
+  return resolveSourceRoots(workspaceRoot, override);
+}
+
+export interface DiscoverOptions {
+  workspaceRoot: string;
+  sourceRoots?: string[];
+  priorSourceIndex?: SourceFileIndex;
+  priorSourcesByPath?: Map<string, import("../types/app-graph.ts").SourceFile>;
+}
+
+export function discover(options: DiscoverOptions): DiscoverContext {
+  const workspaceRoot = options.workspaceRoot.replace(/\\/g, "/");
+  const packageManager = detectPackageManager(workspaceRoot);
+  const walked = walkWorkspaceSources({
+    workspaceRoot,
+    roots: resolveSourceRoots(workspaceRoot, options.sourceRoots),
+    priorIndex: options.priorSourceIndex,
+    priorSourcesByPath: options.priorSourcesByPath,
+  });
+
+  const dependencies = collectDependencies(workspaceRoot);
+
+  const packageJsonHash = hashFileIfExists(join(workspaceRoot, "package.json"));
+  const lockfilePath = resolveLockfilePath(workspaceRoot);
+  const lockfileHash = lockfilePath ? readTextHash(lockfilePath) : "";
+  const tsconfigPath = nodeFileSystem.exists(join(workspaceRoot, "tsconfig.json"))
+    ? "tsconfig.json"
+    : null;
+  const tsconfigHash = hashTsconfigForWorkspace(workspaceRoot, tsconfigPath ?? undefined);
+  const sourceFingerprint = computeSourceFingerprint(walked.sources);
+
+  const inputFingerprint = computeInputFingerprint({
+    sourceFingerprint,
+    packageJsonHash,
+    lockfileHash,
+    tsconfigHash,
+    dependencyVersions: dependencies.map((dep) => ({
+      name: dep.name,
+      version: dep.version,
+    })),
+  });
+
+  return {
+    workspaceRoot,
+    cacheDir: join(workspaceRoot, ".forge", "cache"),
+    generatedDir: GENERATED_DIR,
+    packageManager,
+    sources: walked.sources,
+    dependencies,
+    tsconfigPath,
+    packageJsonHash,
+    lockfileHash,
+    tsconfigHash,
+    sourceFingerprint,
+    inputFingerprint,
+    sourceFileIndex: walked.index,
+  };
+}