forgeos 0.1.0-alpha.0

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

@@ -0,0 +1,25 @@
+import type { ForgeLock } from "./lock.ts";
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface EmitFile {
+  path: string;
+  content: string;
+  contentHash: string;
+  /** Skip JSON canonicalization round-trip when content is already canonical. */
+  canonical?: boolean;
+}
+
+export interface EmitPlan {
+  files: EmitFile[];
+  orphanedFiles: string[];
+  lock: ForgeLock;
+  diagnostics?: Diagnostic[];
+}
+
+export type EmitMode = "write" | "check" | "dry-run";
+
+export interface EmitOutcome {
+  changed: string[];
+  unchanged: string[];
+  removed: string[];
+}

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

@@ -0,0 +1,81 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface FrontendRouteInfo {
+  path: string;
+  file: string;
+  components: string[];
+  usesCommands: string[];
+  usesQueries: string[];
+  usesLiveQueries: string[];
+  rawForgeFetches: string[];
+}
+
+export interface FrontendComponentInfo {
+  name: string;
+  file: string;
+  usesCommands: string[];
+  usesQueries: string[];
+  usesLiveQueries: string[];
+  rawForgeFetches: string[];
+}
+
+export interface FrontendProviderInfo {
+  name: string;
+  file: string;
+  apiUrlEnv?: string;
+  devAuth: boolean;
+  devAuthUserId?: string;
+  devAuthTenantId?: string;
+  devAuthRole?: string;
+}
+
+export interface FrontendWebManifest {
+  present: boolean;
+  framework: "next" | "vite" | "static" | "unknown" | "none";
+  root?: string;
+  packageManager?: "bun" | "npm" | "pnpm" | "yarn" | "unknown";
+  scripts: {
+    dev?: string;
+    build?: string;
+    typecheck?: string;
+  };
+  urls: {
+    dev?: string;
+    api: string;
+  };
+  env: {
+    apiUrl: string;
+  };
+  bridge: {
+    files: string[];
+    valid: boolean;
+  };
+}
+
+export interface FrontendClientBindingInfo {
+  kind: "command" | "query" | "liveQuery" | "rawFetch";
+  name: string;
+  file: string;
+  route?: string;
+  component?: string;
+}
+
+export interface FrontendGraph {
+  schemaVersion: "0.1.0";
+  present: boolean;
+  framework: "next" | "vite" | "static" | "unknown" | "none";
+  root?: string;
+  dev?: {
+    command: string;
+    url: string;
+    apiUrlEnv: string;
+    defaultApiUrl: string;
+  };
+  routes: FrontendRouteInfo[];
+  components: FrontendComponentInfo[];
+  providers: FrontendProviderInfo[];
+  bridgeFiles: string[];
+  webManifest: FrontendWebManifest;
+  clientBindings: FrontendClientBindingInfo[];
+  diagnostics: Diagnostic[];
+}

package/src/forge/compiler/types/import-guards.ts

@@ -0,0 +1,19 @@
+import type { RuntimeContext } from "./runtime.ts";
+import type { RuntimeMatrixEntry } from "./runtime-matrix.ts";
+
+export interface ImportGuardModuleContext {
+  file: string;
+  effectiveContexts: RuntimeContext[];
+}
+
+export interface ImportGuardsArtifact {
+  schemaVersion: string;
+  entries: Array<{
+    packageName: string;
+    alias: string;
+    compatible: RuntimeMatrixEntry["compatible"];
+    incompatible: RuntimeMatrixEntry["incompatible"];
+    rationale: RuntimeMatrixEntry["rationale"];
+  }>;
+  moduleContexts: ImportGuardModuleContext[];
+}

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

@@ -0,0 +1,98 @@
+export type { JsonPrimitive, JsonValue } from "./json.ts";
+export type {
+  RuntimeContext,
+  DeterministicContext,
+  PackageManager,
+  ResolutionMode,
+  SandboxBackend,
+} from "./runtime.ts";
+export {
+  RUNTIME_CONTEXTS,
+  DETERMINISTIC_CONTEXTS,
+} from "./runtime.ts";
+export type {
+  CapabilityStatus,
+  CapabilityConfidence,
+  Capability,
+  SecretRequirement,
+  CapabilitySet,
+} from "./capability.ts";
+export type { Diagnostic, DiagnosticSeverity } from "./diagnostic.ts";
+export type {
+  ForgeKind,
+  ForgeSymbol,
+  ForgeEdge,
+  ForgeEdgeKind,
+  ImportKind,
+  PackageImport,
+  LocalImport,
+  ModuleNode,
+  ModuleGraph,
+  AppGraph,
+  SourceFile,
+} from "./app-graph.ts";
+export type { DataField, DataTable, DataGraph } from "./data-graph.ts";
+export type {
+  DevManifest,
+  DevManifestEntry,
+  DevManifestWorkflow,
+  DevRoute,
+} from "./dev-manifest.ts";
+export type {
+  RuntimeEntry,
+  RuntimeGraph,
+  MockMapEntry,
+  MockMap,
+} from "./runtime-graph.ts";
+export type {
+  JsDoc,
+  ExportClassification,
+  ExportKind,
+  ExportSignature,
+  Entrypoint,
+  PackageApi,
+  PackageGraph,
+  Dependency,
+  AnalyzeOptions,
+} from "./package-graph.ts";
+export type { RuntimeClassification } from "./classification.ts";
+export type {
+  RuntimeMatrix,
+  RuntimeMatrixEntry,
+} from "./runtime-matrix.ts";
+export type {
+  ImportGuardsArtifact,
+  ImportGuardModuleContext,
+} from "./import-guards.ts";
+export type {
+  PackageRecipe,
+  IntegrationRecipe,
+} from "./integration.ts";
+export type {
+  PackageCacheKey,
+  ForgeLockEntry,
+  ForgeLock,
+} from "./lock.ts";
+export type {
+  EmitFile,
+  EmitPlan,
+  EmitMode,
+  EmitOutcome,
+} from "./emit.ts";
+export type {
+  GenerateOptions,
+  GenerateResult,
+  CliCommonOptions,
+  AddOptions,
+  InspectTarget,
+  PmAddOptions,
+  PmAddResult,
+  SandboxLimits,
+} from "./cli.ts";
+export type {
+  RuntimeExportKind,
+  RuntimeExportEntry,
+  RuntimeEntrypointShape,
+  RuntimeExportShape,
+} from "./sandbox.ts";
+export { emptyRuntimeExportShape } from "./sandbox.ts";

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

@@ -0,0 +1,25 @@
+import type { CapabilitySet, SecretRequirement } from "./capability.ts";
+import type { RuntimeContext } from "./runtime.ts";
+
+export interface PackageRecipe {
+  packageName: string;
+  role?: string;
+  supportedVersionRange?: string;
+  contexts?: { allowed: RuntimeContext[]; denied: RuntimeContext[] };
+}
+
+export interface IntegrationRecipe {
+  alias: string;
+  packages: PackageRecipe[];
+  supportedVersionRange: string;
+  recipeVersion: string;
+  contexts: { allowed: RuntimeContext[]; denied: RuntimeContext[] };
+  capabilities: CapabilitySet;
+  secrets: SecretRequirement[];
+  adapters: string[];
+  integrations?: string[];
+  testkits: string[];
+  docs: string[];
+  frameworkTarget?: string;
+  importRewrites?: { from: string; to: string }[];
+}

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

@@ -0,0 +1,3 @@
+export type JsonPrimitive = string | number | boolean | null;
+
+export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };

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

@@ -0,0 +1,32 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface LiveQueryDefinition {
+  name: string;
+  qualifiedName: string;
+  file: string;
+  exportName: string;
+  symbolId: string;
+  moduleId: string;
+  policy?: string;
+}
+
+export interface LiveQueryRegistry {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  liveQueries: LiveQueryDefinition[];
+  diagnostics: Diagnostic[];
+}
+
+export interface SubscriptionManifest {
+  schemaVersion: string;
+  generatorVersion: string;
+  inputHash: string;
+  liveQueries: Array<{
+    name: string;
+    file: string;
+    exportName: string;
+    policy?: string;
+  }>;
+}

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

@@ -0,0 +1,37 @@
+import type { CapabilitySet, SecretRequirement } from "./capability.ts";
+import type { PackageManager, RuntimeContext } from "./runtime.ts";
+
+export interface PackageCacheKey {
+  name: string;
+  version: string;
+  packageManager: PackageManager;
+  packageIntegrity?: string;
+  packageJsonHash: string;
+  dtsFilesHash: string;
+  analyzerVersion: string;
+  typescriptVersion: string;
+  resolutionMode: "nodenext" | "bundler";
+  recipeVersion?: string;
+}
+
+export interface ForgeLockEntry {
+  name: string;
+  version: string;
+  recipeVersion?: string;
+  runtimeContexts: RuntimeContext[];
+  capabilities: CapabilitySet;
+  secrets: SecretRequirement[];
+  generatedFiles: string[];
+  contentChecksum: string;
+}
+
+export interface ForgeLock {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  lockfileHash: string;
+  packageManager: PackageManager;
+  recipeVersion?: string;
+  packages: ForgeLockEntry[];
+}

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

@@ -0,0 +1,84 @@
+import type { CapabilitySet } from "./capability.ts";
+import type { RuntimeExportShape } from "./sandbox.ts";
+import type {
+  PackageManager,
+  ResolutionMode,
+  RuntimeContext,
+  SandboxBackend,
+} from "./runtime.ts";
+
+export interface JsDoc {
+  summary: string;
+  tags: { tag: string; text: string }[];
+}
+
+export interface ExportClassification {
+  alias: string;
+  packageName: string;
+  entrypoint: string;
+  exportName: string;
+  compatible: RuntimeContext[];
+  incompatible: RuntimeContext[];
+  capabilities: CapabilitySet;
+}
+
+export type ExportKind =
+  | "function"
+  | "class"
+  | "const"
+  | "type"
+  | "interface"
+  | "namespace";
+
+export interface ExportSignature {
+  name: string;
+  kind: ExportKind;
+  signature: string;
+  overloads?: string[];
+  declarations?: string[];
+  classification: ExportClassification;
+  jsdoc: JsDoc | null;
+  examples: string[];
+}
+
+export interface Entrypoint {
+  subpath: string;
+  conditions: string[];
+  patternBacked: boolean;
+  dtsPath: string | null;
+  exports: ExportSignature[];
+}
+
+export interface PackageApi {
+  name: string;
+  version: string;
+  packageManager: PackageManager;
+  resolutionMode: ResolutionMode;
+  entrypoints: Entrypoint[];
+  source: "static" | "static+runtime";
+  runtimeShape?: RuntimeExportShape;
+  contentChecksum: string;
+}
+
+export interface PackageGraph {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  packages: PackageApi[];
+}
+
+export interface Dependency {
+  name: string;
+  version: string;
+  packageManager: PackageManager;
+  packageIntegrity?: string;
+  installPath: string;
+}
+
+export interface AnalyzeOptions {
+  runtimeInspect: boolean;
+  sandboxBackend?: SandboxBackend;
+  resolutionMode: ResolutionMode;
+  cacheDir: string;
+  recipeVersion?: string;
+}

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

@@ -0,0 +1,69 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface PolicyRule {
+  name: string;
+  kind: "roles" | "public" | "system";
+  roles: string[];
+  file: string;
+  symbolId: string;
+}
+
+export interface CommandAuthBinding {
+  commandName: string;
+  file: string;
+  symbolId: string;
+  auth:
+    | { kind: "policy"; policy: string }
+    | { kind: "public" }
+    | { kind: "system" }
+    | { kind: "user" };
+}
+
+export interface QueryAuthBinding {
+  queryName: string;
+  file: string;
+  symbolId: string;
+  auth:
+    | { kind: "policy"; policy: string }
+    | { kind: "public" }
+    | { kind: "system" }
+    | { kind: "user" };
+}
+
+export interface PermissionMatrixEntry {
+  policy: string;
+  roles: string[];
+}
+
+export interface TenantScopeEntry {
+  table: string;
+  exportName: string;
+  tenantIdColumn: string;
+  file: string;
+}
+
+export interface PolicyRegistry {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  policies: PolicyRule[];
+  commandAuth: CommandAuthBinding[];
+  queryAuth: QueryAuthBinding[];
+  diagnostics: Diagnostic[];
+}
+
+export interface PermissionMatrix {
+  schemaVersion: string;
+  generatorVersion: string;
+  inputHash: string;
+  entries: PermissionMatrixEntry[];
+}
+
+export interface TenantScope {
+  schemaVersion: string;
+  generatorVersion: string;
+  inputHash: string;
+  tables: TenantScopeEntry[];
+  diagnostics: Diagnostic[];
+}

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

@@ -0,0 +1,18 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface QueryDefinition {
+  name: string;
+  qualifiedName: string;
+  file: string;
+  symbolId: string;
+  moduleId: string;
+}
+
+export interface QueryRegistry {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  queries: QueryDefinition[];
+  diagnostics: Diagnostic[];
+}

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

@@ -0,0 +1,30 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface RuntimeEntry {
+  id: string;
+  kind: "command" | "action";
+  name: string;
+  qualifiedName: string;
+  file: string;
+  moduleId: string;
+  runtimeContext: "command" | "action";
+  dependencies: string[];
+}
+
+export interface RuntimeGraph {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  entries: RuntimeEntry[];
+  diagnostics: Diagnostic[];
+}
+
+export interface MockMapEntry {
+  packageName: string;
+  mockFile: string;
+}
+
+export interface MockMap {
+  entries: MockMapEntry[];
+}

package/src/forge/compiler/types/runtime-matrix.ts

@@ -0,0 +1,16 @@
+import type { ExportClassification } from "./package-graph.ts";
+import type { RuntimeContext } from "./runtime.ts";
+
+export interface RuntimeMatrixEntry {
+  alias: string;
+  packageName: string;
+  compatible: RuntimeContext[];
+  incompatible: RuntimeContext[];
+  rationale: Record<RuntimeContext, string>;
+  perEntrypoint: ExportClassification[];
+}
+
+export interface RuntimeMatrix {
+  schemaVersion: string;
+  entries: RuntimeMatrixEntry[];
+}

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

@@ -0,0 +1,30 @@
+export const RUNTIME_CONTEXTS = [
+  "shared",
+  "client",
+  "server",
+  "query",
+  "liveQuery",
+  "command",
+  "action",
+  "workflow",
+  "endpoint",
+  "edge",
+  "test",
+  "build",
+] as const;
+
+export type RuntimeContext = (typeof RUNTIME_CONTEXTS)[number];
+
+export const DETERMINISTIC_CONTEXTS = [
+  "command",
+  "query",
+  "liveQuery",
+] as const satisfies readonly RuntimeContext[];
+
+export type DeterministicContext = (typeof DETERMINISTIC_CONTEXTS)[number];
+
+export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+
+export type ResolutionMode = "nodenext" | "bundler";
+
+export type SandboxBackend = "none" | "child" | "docker";

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

@@ -0,0 +1,24 @@
+export type RuntimeExportKind =
+  | "function"
+  | "class"
+  | "const"
+  | "object"
+  | "unknown";
+
+export interface RuntimeExportEntry {
+  name: string;
+  kind: RuntimeExportKind;
+}
+
+export interface RuntimeEntrypointShape {
+  subpath: string;
+  exports: RuntimeExportEntry[];
+}
+
+export interface RuntimeExportShape {
+  entrypoints: RuntimeEntrypointShape[];
+}
+
+export function emptyRuntimeExportShape(): RuntimeExportShape {
+  return { entrypoints: [] };
+}

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

@@ -0,0 +1,38 @@
+import type { RuntimeContext } from "./runtime.ts";
+
+export interface SecretRegistryEntry {
+  name: string;
+  required: boolean;
+  source: "recipe" | "signature" | "jsdoc" | "rule" | "readme";
+  integration?: string;
+  allowedContexts: RuntimeContext[];
+  public?: boolean;
+}
+
+export interface SecretRegistry {
+  secrets: SecretRegistryEntry[];
+}
+
+export interface EnvVariable {
+  name: string;
+  kind: "secret" | "config";
+  required: boolean;
+  source: string;
+  integration?: string;
+  public?: boolean;
+}
+
+export interface EnvSchema {
+  variables: EnvVariable[];
+}
+
+export interface ConfigRegistryEntry {
+  name: string;
+  required: boolean;
+  source: string;
+  integration?: string;
+}
+
+export interface ConfigRegistry {
+  configs: ConfigRegistryEntry[];
+}

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

@@ -0,0 +1,26 @@
+import type { Diagnostic } from "../types/diagnostic.ts";
+
+export interface TelemetryEventDefinition {
+  name: string;
+  files: string[];
+}
+
+export interface TelemetrySinkDefinition {
+  id: string;
+  kind: "local" | "posthog" | "sentry";
+}
+
+export interface TelemetryRegistry {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  events: TelemetryEventDefinition[];
+  diagnostics: Diagnostic[];
+}
+
+export interface TelemetrySinks {
+  schemaVersion: string;
+  generatorVersion: string;
+  sinks: TelemetrySinkDefinition[];
+}