forgeos 0.1.0-alpha.0

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

@@ -0,0 +1,277 @@
+import { basename } from "node:path";
+import { GENERATOR_VERSION } from "../emitter/constants.ts";
+import { walkWorkspaceSources } from "../orchestrator/workspace-index.ts";
+import { stableSortStrings } from "../primitives/sort.ts";
+import type { AppGraph, ForgeKind, SourceFile } from "../types/app-graph.ts";
+import type { PackageGraph } from "../types/package-graph.ts";
+import type {
+  TestConfidence,
+  TestCost,
+  TestCoverage,
+  TestGraph,
+  TestGraphEntry,
+  TestKind,
+  TestPlanRegistry,
+} from "../types/test-graph.ts";
+
+const TEST_RE = /\.(test|spec)\.(ts|tsx)$/;
+
+function emptyCoverage(): TestCoverage {
+  return {
+    commands: [],
+    queries: [],
+    liveQueries: [],
+    actions: [],
+    workflows: [],
+    tables: [],
+    policies: [],
+    components: [],
+    packages: [],
+  };
+}
+
+function pushUnique(values: string[], value: string): void {
+  if (value && !values.includes(value)) {
+    values.push(value);
+  }
+}
+
+function collectTestsFromDisk(workspaceRoot: string): SourceFile[] {
+  const { sources } = walkWorkspaceSources({
+    workspaceRoot,
+    roots: ["tests", "web"],
+    excludeRelativePath: (path) => !TEST_RE.test(path),
+  });
+  return sources.sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function symbolsByKind(appGraph: AppGraph, kind: ForgeKind): string[] {
+  return stableSortStrings(
+    appGraph.symbols
+      .filter((symbol) => symbol.kind === kind)
+      .map((symbol) => symbol.name),
+  );
+}
+
+function componentNames(sources: SourceFile[]): string[] {
+  const names = new Set<string>();
+  for (const source of sources) {
+    if (!source.path.endsWith(".tsx")) {
+      continue;
+    }
+    if (!source.path.includes("/components/") && !source.path.includes("\\components\\")) {
+      if (!/\b(react|components)\b/.test(source.path) || !TEST_RE.test(source.path)) {
+        continue;
+      }
+    }
+    names.add(basename(source.path).replace(/\.(test|spec)?\.?tsx$/, ""));
+  }
+  return stableSortStrings([...names]);
+}
+
+function hasBrowserAutomationSignal(path: string, text: string): boolean {
+  const loweredPath = path.toLowerCase();
+  const loweredText = text.toLowerCase();
+  return (
+    loweredPath.includes("playwright") ||
+    /^\s*import\s+["'](?:@playwright\/test|playwright)["'];?/m.test(loweredText) ||
+    /^\s*import\s+.*\s+from\s+["'](?:@playwright\/test|playwright)["'];?/m.test(loweredText) ||
+    /^\s*const\s+\w+\s*=\s*require\(["'](?:@playwright\/test|playwright)["']\)/m.test(loweredText) ||
+    /\b(chromium|firefox|webkit)\s*\./.test(loweredText) ||
+    /\bpage\.(goto|locator|click|fill|screenshot)\b/.test(loweredText)
+  );
+}
+
+function hasDockerOrExternalPostgresSignal(path: string, text: string): boolean {
+  const loweredPath = path.toLowerCase();
+  const loweredText = text.toLowerCase();
+  return (
+    loweredPath.includes("/docker/") ||
+    loweredPath.includes("\\docker\\") ||
+    loweredPath.includes("docker-compose") ||
+    loweredPath.includes("/postgres/") ||
+    loweredPath.includes("\\postgres\\") ||
+    loweredText.includes("testcontainers") ||
+    loweredText.includes("docker-compose") ||
+    loweredText.includes("postgres://") ||
+    loweredText.includes("postgresql://") ||
+    /\bnew\s+postgres(?:ql)?container\b/.test(loweredText)
+  );
+}
+
+function inferKind(path: string, text: string): TestKind {
+  const lowered = path.toLowerCase();
+  if (lowered.includes("/e2e/") || hasBrowserAutomationSignal(path, text)) {
+    return "e2e";
+  }
+  if (lowered.includes("/react/") || lowered.includes("/components/") || path.endsWith(".tsx")) {
+    return "frontend";
+  }
+  if (lowered.includes("/integration/") || lowered.includes("/live/") || lowered.includes("/workflow")) {
+    return "integration";
+  }
+  if (lowered.includes("/tests/")) {
+    return "unit";
+  }
+  return "unknown";
+}
+
+function inferCost(path: string, text: string, kind: TestKind): TestCost {
+  const lowered = `${path}\n${text}`.toLowerCase();
+  if (hasBrowserAutomationSignal(path, text)) {
+    return "browser";
+  }
+  if (hasDockerOrExternalPostgresSignal(path, text)) {
+    return "docker";
+  }
+  if (lowered.includes("e2e") || lowered.includes("timeout 120000")) {
+    return "slow";
+  }
+  if (kind === "integration" || kind === "frontend") {
+    return "standard";
+  }
+  return "fast";
+}
+
+function mentionConfidence(path: string, text: string, group: string, name: string): TestConfidence | null {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pathHit = path.toLowerCase().includes(name.toLowerCase());
+  const apiHit = new RegExp(`api\\.${group}\\.${escaped}\\b`).test(text);
+  const helperHit = new RegExp(`forge\\.test\\.[a-zA-Z]+\\([^)]*${escaped}`).test(text);
+  const importHit = new RegExp(`from\\s+["'][^"']*${escaped}["']`).test(text);
+  const stringHit = new RegExp(`["'\`]${escaped}["'\`]`).test(text);
+  const wordHit = new RegExp(`\\b${escaped}\\b`).test(text);
+
+  if (pathHit || apiHit || helperHit || importHit) {
+    return "confirmed";
+  }
+  if (stringHit || wordHit) {
+    return "probable";
+  }
+  return null;
+}
+
+function stronger(a: TestConfidence, b: TestConfidence): TestConfidence {
+  const rank = { weak: 0, probable: 1, confirmed: 2 };
+  return rank[b] > rank[a] ? b : a;
+}
+
+function inferCoverage(args: {
+  path: string;
+  text: string;
+  appGraph: AppGraph;
+  packageGraph: PackageGraph;
+  allSources: SourceFile[];
+}): { covers: TestCoverage; confidence: TestConfidence; reasons: string[] } {
+  const { path, text, appGraph, packageGraph, allSources } = args;
+  const covers = emptyCoverage();
+  const reasons: string[] = [];
+  let confidence: TestConfidence = "weak";
+  const groups: Array<[keyof TestCoverage, string, string[]]> = [
+    ["commands", "commands", symbolsByKind(appGraph, "command")],
+    ["queries", "queries", symbolsByKind(appGraph, "query")],
+    ["liveQueries", "liveQueries", symbolsByKind(appGraph, "liveQuery")],
+    ["actions", "actions", symbolsByKind(appGraph, "action")],
+    ["workflows", "workflows", symbolsByKind(appGraph, "workflow")],
+    ["tables", "tables", symbolsByKind(appGraph, "schema.table")],
+    ["policies", "policies", symbolsByKind(appGraph, "policy")],
+    ["components", "components", componentNames(allSources)],
+    ["packages", "packages", packageGraph.packages.map((pkg) => pkg.name).sort()],
+  ];
+
+  for (const [coverageKey, apiGroup, names] of groups) {
+    for (const name of names) {
+      const hit = mentionConfidence(path, text, apiGroup, name);
+      if (!hit) {
+        continue;
+      }
+      pushUnique(covers[coverageKey], name);
+      confidence = stronger(confidence, hit);
+      reasons.push(`${hit}: ${coverageKey} ${name}`);
+    }
+  }
+
+  for (const values of Object.values(covers)) {
+    values.sort();
+  }
+  reasons.sort();
+  return { covers, confidence, reasons };
+}
+
+export function buildTestGraph(input: {
+  workspaceRoot: string;
+  inputHash: string;
+  appGraph: AppGraph;
+  packageGraph: PackageGraph;
+  sources: SourceFile[];
+}): TestGraph {
+  const diskTests = collectTestsFromDisk(input.workspaceRoot);
+  const byPath = new Map<string, SourceFile>();
+  for (const source of input.sources) {
+    if (TEST_RE.test(source.path)) {
+      byPath.set(source.path, source);
+    }
+  }
+  for (const source of diskTests) {
+    byPath.set(source.path, source);
+  }
+
+  const allSources = [...input.sources.filter((s) => TEST_RE.test(s.path)), ...diskTests];
+  const tests: TestGraphEntry[] = [...byPath.values()]
+    .sort((a, b) => a.path.localeCompare(b.path))
+    .map((source) => {
+      const kind = inferKind(source.path, source.text);
+      const inferred = inferCoverage({
+        path: source.path,
+        text: source.text,
+        appGraph: input.appGraph,
+        packageGraph: input.packageGraph,
+        allSources,
+      });
+      return {
+        file: source.path,
+        kind,
+        cost: inferCost(source.path, source.text, kind),
+        confidence: inferred.confidence,
+        covers: inferred.covers,
+        reasons: inferred.reasons,
+      };
+    });
+
+  return {
+    schemaVersion: "0.1.0",
+    generatorVersion: GENERATOR_VERSION,
+    analyzerVersion: "test-graph-0.1.0",
+    inputHash: input.inputHash,
+    tests,
+    diagnostics: [],
+  };
+}
+
+export function buildTestPlanRegistry(): TestPlanRegistry {
+  return {
+    schemaVersion: "0.1.0",
+    generatorVersion: GENERATOR_VERSION,
+    commands: [
+      "forge impact --changed --json",
+      "forge test plan --changed --json",
+      "forge test run --changed --json",
+      "forge test run --changed --timeout-ms <ms> --json",
+      "forge test explain <testFile> --json",
+      "forge verify --changed",
+      "forge verify --fast",
+      "forge verify --smoke",
+      "forge verify --standard",
+      "forge verify --strict",
+    ],
+    generatedArtifacts: [
+      "src/forge/_generated/testGraph.json",
+      "src/forge/_generated/testGraph.ts",
+      "src/forge/_generated/testPlanRegistry.json",
+      "src/forge/_generated/testPlanRegistry.ts",
+    ],
+    planDirectory: ".forge/test-plans",
+    runDirectory: ".forge/test-runs",
+    costs: ["instant", "fast", "standard", "slow", "docker", "browser"],
+  };
+}

package/src/forge/compiler/types/action-subscriptions.ts

@@ -0,0 +1,19 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface ActionSubscription {
+  eventType: string;
+  actionName: string;
+  exportName: string;
+  file: string;
+  symbolId: string;
+}
+
+export interface ActionSubscriptions {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  subscriptions: ActionSubscription[];
+  byEvent: Record<string, ActionSubscription[]>;
+  diagnostics: Diagnostic[];
+}

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

@@ -0,0 +1,33 @@
+export type ForgeAiProvider = "openai" | "anthropic" | "gateway";
+
+export interface AiProviderDefinition {
+  id: ForgeAiProvider;
+  packageName: string;
+  secretName: string;
+  integration: string;
+}
+
+export interface AiModelDefinition {
+  provider: ForgeAiProvider;
+  model: string;
+  inputCostPer1kTokensUsd?: number;
+  outputCostPer1kTokensUsd?: number;
+}
+
+export interface AiGenerationCall {
+  provider: ForgeAiProvider;
+  model: string;
+  purpose?: string;
+  method: "generateText" | "streamText" | "generateStructured";
+  file: string;
+}
+
+export interface AiRegistry {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  providers: AiProviderDefinition[];
+  generations: AiGenerationCall[];
+  diagnostics: unknown[];
+}

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

@@ -0,0 +1,80 @@
+import type { Diagnostic } from "./diagnostic.ts";
+import type { JsonValue } from "./json.ts";
+import type { RuntimeContext } from "./runtime.ts";
+
+export type ForgeKind =
+  | "schema.table"
+  | "query"
+  | "liveQuery"
+  | "command"
+  | "action"
+  | "endpoint"
+  | "policy"
+  | "workflow"
+  | "agent"
+  | "telemetryEvent";
+
+export interface ForgeSymbol {
+  id: string;
+  kind: ForgeKind;
+  name: string;
+  qualifiedName: string;
+  file: string;
+  span: { start: number; end: number };
+  contentHash: string;
+  meta: Record<string, JsonValue>;
+}
+
+export type ForgeEdgeKind = "references" | "registers" | "guards" | "emits";
+
+export interface ForgeEdge {
+  from: string;
+  to: string;
+  kind: ForgeEdgeKind;
+}
+
+export type ImportKind = "static" | "dynamic" | "require";
+
+export interface PackageImport {
+  specifier: string;
+  packageName: string;
+  subpath: string;
+  span: { start: number; end: number };
+  importKind: ImportKind;
+}
+
+export interface LocalImport {
+  toModuleId: string;
+  span: { start: number; end: number };
+}
+
+export interface ModuleNode {
+  id: string;
+  file: string;
+  directPackageImports: PackageImport[];
+  localImports: LocalImport[];
+  declaredContexts: RuntimeContext[];
+  effectiveContexts: RuntimeContext[];
+}
+
+export interface ModuleGraph {
+  nodes: ModuleNode[];
+}
+
+export interface AppGraph {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  sourceHashes?: Record<string, string>;
+  symbols: ForgeSymbol[];
+  edges: ForgeEdge[];
+  moduleGraph: ModuleGraph;
+  diagnostics: Diagnostic[];
+}
+
+export interface SourceFile {
+  path: string;
+  contentHash: string;
+  text: string;
+}

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

@@ -0,0 +1,29 @@
+export type CapabilityStatus =
+  | "required"
+  | "not-detected"
+  | "unknown"
+  | "forbidden";
+
+export type CapabilityConfidence = "manual" | "rule" | "static" | "runtime";
+
+export interface Capability<T = unknown> {
+  status: CapabilityStatus;
+  confidence: CapabilityConfidence;
+  evidence: string[];
+  value?: T;
+}
+
+export interface SecretRequirement {
+  envVar: string;
+  required: boolean;
+  detectedFrom: "jsdoc" | "signature" | "rule" | "readme" | "recipe";
+}
+
+export interface CapabilitySet {
+  network: Capability<{ egress?: string[] }>;
+  filesystem: Capability<{ read?: boolean; write?: boolean }>;
+  process: Capability;
+  nativeAddon: Capability;
+  lifecycleScripts: Capability;
+  secrets: SecretRequirement[];
+}

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

@@ -0,0 +1,9 @@
+import type { ExportClassification } from "./package-graph.ts";
+import type { RuntimeContext } from "./runtime.ts";
+
+export interface RuntimeClassification {
+  compatible: RuntimeContext[];
+  incompatible: RuntimeContext[];
+  rationale: Record<RuntimeContext, string>;
+  perEntrypoint: ExportClassification[];
+}

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

@@ -0,0 +1,159 @@
+import type { Diagnostic } from "./diagnostic.ts";
+import type { SandboxBackend } from "./runtime.ts";
+
+export interface GenerateOptions {
+  workspaceRoot: string;
+  check: boolean;
+  dryRun: boolean;
+  json: boolean;
+  concurrency: number;
+}
+
+export interface GenerateResult {
+  changed: string[];
+  unchanged: string[];
+  warnings: Diagnostic[];
+  errors: Diagnostic[];
+  cache?: {
+    strategy: "generated-check";
+    result: "hit" | "miss" | "skipped";
+    reason?: string;
+  };
+  exitCode: 0 | 1;
+  failureKind?: string;
+}
+
+export interface ForgeAddResult extends GenerateResult {
+  alias?: string;
+}
+
+export interface InspectResult {
+  target: InspectTarget;
+  data: unknown;
+  warnings: Diagnostic[];
+  errors: Diagnostic[];
+  exitCode: 0 | 1;
+  failureKind?: string;
+}
+
+export interface CliCommonOptions {
+  json: boolean;
+  dryRun: boolean;
+}
+
+export interface AddOptions extends CliCommonOptions {
+  runtimeInspect: boolean;
+  sandboxBackend: SandboxBackend;
+  allowScripts: boolean;
+}
+
+export type InspectTarget =
+  | "app"
+  | "packages"
+  | "capabilities"
+  | "runtime-matrix"
+  | "data"
+  | "runtime"
+  | "dev"
+  | "subscriptions"
+  | "workflows"
+  | "telemetry"
+  | "policies"
+  | "secrets"
+  | "env"
+  | "ai"
+  | "queries"
+  | "api"
+  | "client"
+  | "frontend"
+  | "auth"
+  | "rls"
+  | "db-security"
+  | "release"
+  | "artifacts"
+  | "sourcemaps"
+  | "live-production"
+  | "live-protocol"
+  | "live-transport"
+  | "make"
+  | "test-graph"
+  | "test-plans"
+  | "agent-contract"
+  | "agent-adapters"
+  | "capability-map"
+  | "framework"
+  | "ui"
+  | "ui-scenarios"
+  | "ui-routes"
+  | "all"
+  | "rules"
+  | "map";
+
+export interface RunOptions extends CliCommonOptions {
+  name?: string;
+  list: boolean;
+  mock: boolean;
+  workspaceRoot: string;
+}
+
+export interface RunResult {
+  exitCode: 0 | 1;
+  failureKind?: string;
+}
+
+export interface PmAddOptions {
+  ignoreScripts: boolean;
+  cwd: string;
+}
+
+export interface PmAddResult {
+  resolvedVersion: string;
+  integrity?: string;
+  lockfileChanged: boolean;
+}
+
+export interface SandboxLimits {
+  backend: SandboxBackend;
+  timeoutMs: number;
+  memoryMb: number;
+  network: false;
+  filesystem: "read-only";
+  allowPostinstall: false;
+}
+
+export interface VerifyStep {
+  name: string;
+  ok: boolean;
+  skipped?: boolean;
+  skipReason?: string;
+  exitCode?: number;
+  command?: string;
+  durationMs?: number;
+  timedOut?: boolean;
+  failureKind?: string;
+}
+
+export interface VerifyOptions {
+  workspaceRoot: string;
+  json: boolean;
+  skipTests: boolean;
+  skipTypecheck: boolean;
+  skipEslint: boolean;
+  strict: boolean;
+  changed?: boolean;
+  fast?: boolean;
+  smoke?: boolean;
+  standard?: boolean;
+  scriptTimeoutMs?: number;
+}
+
+export type VerifyProfile = "default" | "smoke" | "standard" | "strict" | "changed";
+
+export interface VerifyResult {
+  ok: boolean;
+  profile?: VerifyProfile;
+  steps: VerifyStep[];
+  diagnostics: Diagnostic[];
+  durationMs?: number;
+  exitCode: 0 | 1;
+}

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

@@ -0,0 +1,24 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface DataField {
+  name: string;
+  type: string;
+}
+
+export interface DataTable {
+  id: string;
+  name: string;
+  symbolId: string;
+  exportName: string;
+  file: string;
+  fields: DataField[];
+}
+
+export interface DataGraph {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  tables: DataTable[];
+  diagnostics: Diagnostic[];
+}

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

@@ -0,0 +1,41 @@
+import type { Diagnostic } from "./diagnostic.ts";
+
+export interface DevRoute {
+  method: "GET" | "POST";
+  path: string;
+  purpose:
+    | "home"
+    | "health"
+    | "entries"
+    | "invoke"
+    | "workflows"
+    | "workflow-runs"
+    | "workflow-process"
+    | "queries"
+    | "query";
+  entryName?: string;
+  entryKind?: "command" | "action" | "query";
+}
+
+export interface DevManifestEntry {
+  name: string;
+  kind: "command" | "action" | "query";
+  invokePath: string;
+  semanticPath: string;
+}
+
+export interface DevManifestWorkflow {
+  name: string;
+  file: string;
+}
+
+export interface DevManifest {
+  schemaVersion: string;
+  generatorVersion: string;
+  analyzerVersion: string;
+  inputHash: string;
+  routes: DevRoute[];
+  entries: DevManifestEntry[];
+  workflows: DevManifestWorkflow[];
+  diagnostics: Diagnostic[];
+}

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

@@ -0,0 +1,12 @@
+export type DiagnosticSeverity = "error" | "warning" | "info";
+
+export interface Diagnostic {
+  severity: DiagnosticSeverity;
+  code: string;
+  message: string;
+  file?: string;
+  span?: { start: number; end: number };
+  fixHint?: string;
+  suggestedCommands?: string[];
+  docs?: string[];
+}