forgeos 0.1.0-alpha.0

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

@@ -0,0 +1,96 @@
+import { buildAppGraph } from "../app-graph/build.ts";
+import type { AppGraph } from "../types/app-graph.ts";
+import { discover, type DiscoverOptions } from "./discover.ts";
+import { loadManifest } from "./manifest.ts";
+import type { DiscoverContext, OrchestratorManifest } from "./types.ts";
+
+export interface CompileSession {
+  workspaceRoot: string;
+  discoverContext?: DiscoverContext;
+  manifest?: OrchestratorManifest;
+  appGraph?: AppGraph;
+  appGraphPromise?: Promise<AppGraph>;
+}
+
+const sessions = new Map<string, CompileSession>();
+
+function normalizeWorkspaceRoot(workspaceRoot: string): string {
+  return workspaceRoot.replace(/\\/g, "/");
+}
+
+export function getCompileSession(workspaceRoot: string): CompileSession {
+  const key = normalizeWorkspaceRoot(workspaceRoot);
+  const existing = sessions.get(key);
+  if (existing) {
+    return existing;
+  }
+  const session: CompileSession = { workspaceRoot: key };
+  sessions.set(key, session);
+  return session;
+}
+
+export function resetCompileSessions(): void {
+  sessions.clear();
+}
+
+export function discoverForSession(
+  session: CompileSession,
+  options?: Omit<DiscoverOptions, "workspaceRoot">,
+): DiscoverContext {
+  if (session.discoverContext) {
+    return session.discoverContext;
+  }
+
+  const manifest = loadManifestForSession(session);
+  const priorSourcesByPath = new Map(
+    (manifest.sourceSnapshot ?? []).map((source) => [source.path, source]),
+  );
+  const ctx = discover({
+    workspaceRoot: session.workspaceRoot,
+    ...options,
+    priorSourceIndex: manifest.sourceFileIndex,
+    priorSourcesByPath,
+  });
+  session.discoverContext = ctx;
+  return ctx;
+}
+
+export function loadManifestForSession(
+  session: CompileSession,
+): OrchestratorManifest {
+  if (session.manifest) {
+    return session.manifest;
+  }
+  const ctx = session.discoverContext;
+  const cacheDir =
+    ctx?.cacheDir ?? `${session.workspaceRoot}/.forge/cache`;
+  session.manifest = loadManifest(cacheDir);
+  return session.manifest;
+}
+
+export async function buildAppGraphForSession(
+  session: CompileSession,
+): Promise<AppGraph> {
+  if (session.appGraph) {
+    return session.appGraph;
+  }
+  if (session.appGraphPromise) {
+    return session.appGraphPromise;
+  }
+
+  session.appGraphPromise = (async () => {
+    const ctx = discoverForSession(session);
+    const manifest = loadManifestForSession(session);
+    const appGraph = await buildAppGraph({
+      workspaceRoot: ctx.workspaceRoot,
+      sources: ctx.sources,
+      prior: manifest.priorAppGraph,
+      tsconfigPath: ctx.tsconfigPath ?? undefined,
+      tsconfigHash: ctx.tsconfigHash,
+    });
+    session.appGraph = appGraph;
+    return appGraph;
+  })();
+
+  return session.appGraphPromise;
+}

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

@@ -0,0 +1,31 @@
+import type { AppGraph, SourceFile } from "../types/app-graph.ts";
+import type { Dependency } from "../types/package-graph.ts";
+import type { PackageManager } from "../types/runtime.ts";
+import type { SourceFileIndex } from "./workspace-index.ts";
+
+export const ORCHESTRATOR_MANIFEST_VERSION = "1";
+
+export interface DiscoverContext {
+  workspaceRoot: string;
+  cacheDir: string;
+  generatedDir: string;
+  packageManager: PackageManager;
+  sources: SourceFile[];
+  dependencies: Dependency[];
+  tsconfigPath: string | null;
+  packageJsonHash: string;
+  lockfileHash: string;
+  tsconfigHash: string;
+  sourceFingerprint: string;
+  inputFingerprint: string;
+  sourceFileIndex: SourceFileIndex;
+}
+
+export interface OrchestratorManifest {
+  schemaVersion: string;
+  fileHashes: Record<string, string>;
+  priorAppGraph?: AppGraph;
+  inputFingerprint?: string;
+  sourceFileIndex?: SourceFileIndex;
+  sourceSnapshot?: SourceFile[];
+}

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

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import type { Diagnostic } from "../types/diagnostic.ts";
+import type { ForgeLock } from "../types/lock.ts";
+import { createDiagnostic } from "../diagnostics/create.ts";
+import { normalizePath } from "../primitives/paths.ts";
+
+export function verifyLockIntegrity(
+  workspaceRoot: string,
+  lock: ForgeLock,
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+  const seen = new Set<string>();
+
+  for (const entry of lock.packages) {
+    for (const file of entry.generatedFiles) {
+      const normalized = normalizePath(file);
+      if (seen.has(normalized)) {
+        continue;
+      }
+      seen.add(normalized);
+
+      const absolute = join(workspaceRoot, normalized);
+      if (!nodeFileSystem.exists(absolute)) {
+        diagnostics.push(
+          createDiagnostic({
+            severity: "error",
+            code: "FORGE_LOCK_INTEGRITY",
+            message: `forge.lock references missing generated file: ${normalized}`,
+            file: normalized,
+          }),
+        );
+      }
+    }
+  }
+
+  return diagnostics;
+}

package/src/forge/compiler/orchestrator/workspace-index.ts

@@ -0,0 +1,154 @@
+import { join, relative } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import type { SourceFile } from "../types/app-graph.ts";
+import { GENERATED_DIR } from "../emitter/constants.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { normalizePath } from "../primitives/paths.ts";
+
+export interface SourceFileIndexEntry {
+  contentHash: string;
+  size: number;
+  mtimeMs: number;
+}
+
+export type SourceFileIndex = Record<string, SourceFileIndexEntry>;
+
+const DEFAULT_SKIP_DIRS = new Set([
+  "node_modules",
+  "_generated",
+  ".forge",
+  "dist",
+  "build",
+  ".git",
+]);
+
+export interface WalkWorkspaceSourcesOptions {
+  workspaceRoot: string;
+  roots: string[];
+  extensions?: Set<string>;
+  skipDirNames?: Set<string>;
+  excludeRelativePath?: (relativePath: string) => boolean;
+  priorIndex?: SourceFileIndex;
+  priorSourcesByPath?: Map<string, SourceFile>;
+}
+
+export interface WalkWorkspaceSourcesResult {
+  sources: SourceFile[];
+  index: SourceFileIndex;
+}
+
+function resolveSourceContent(
+  absolutePath: string,
+  priorEntry?: SourceFileIndexEntry,
+  priorSource?: SourceFile,
+): { text: string; contentHash: string; size: number; mtimeMs: number } {
+  const stat = nodeFileSystem.stat(absolutePath);
+  if (stat === null || !stat.isFile) {
+    return { text: "", contentHash: hashStable(""), size: 0, mtimeMs: 0 };
+  }
+
+  if (
+    priorEntry !== undefined &&
+    priorSource !== undefined &&
+    priorEntry.size === stat.size &&
+    priorEntry.mtimeMs === stat.mtimeMs &&
+    priorEntry.contentHash === priorSource.contentHash
+  ) {
+    return {
+      text: priorSource.text,
+      contentHash: priorSource.contentHash,
+      size: stat.size,
+      mtimeMs: stat.mtimeMs,
+    };
+  }
+
+  const text = nodeFileSystem.readText(absolutePath) ?? "";
+  return {
+    text,
+    contentHash: hashStable(text),
+    size: stat.size,
+    mtimeMs: stat.mtimeMs,
+  };
+}
+
+export function walkWorkspaceSources(
+  options: WalkWorkspaceSourcesOptions,
+): WalkWorkspaceSourcesResult {
+  const workspaceRoot = options.workspaceRoot.replace(/\\/g, "/");
+  const extensions = options.extensions ?? new Set([".ts", ".tsx"]);
+  const skipDirNames = options.skipDirNames ?? DEFAULT_SKIP_DIRS;
+  const sources: SourceFile[] = [];
+  const index: SourceFileIndex = {};
+
+  function walkDirectory(absoluteDir: string): void {
+    for (const entry of nodeFileSystem.readDir(absoluteDir)) {
+      const absolutePath = join(absoluteDir, entry.name);
+
+      if (entry.isDirectory) {
+        if (skipDirNames.has(entry.name)) {
+          continue;
+        }
+        walkDirectory(absolutePath);
+        continue;
+      }
+
+      if (!entry.isFile) {
+        continue;
+      }
+
+      const ext = entry.name.includes(".")
+        ? `.${entry.name.split(".").pop()}`
+        : "";
+      if (!extensions.has(ext)) {
+        continue;
+      }
+
+      const relativePath = normalizePath(
+        relative(workspaceRoot, absolutePath),
+      );
+      if (relativePath.includes(`${GENERATED_DIR}/`)) {
+        continue;
+      }
+      if (options.excludeRelativePath?.(relativePath)) {
+        continue;
+      }
+
+      const priorEntry = options.priorIndex?.[relativePath];
+      const priorSource = options.priorSourcesByPath?.get(relativePath);
+      const resolved = resolveSourceContent(
+        absolutePath,
+        priorEntry,
+        priorSource,
+      );
+
+      index[relativePath] = {
+        contentHash: resolved.contentHash,
+        size: resolved.size,
+        mtimeMs: resolved.mtimeMs,
+      };
+
+      sources.push({
+        path: relativePath,
+        text: resolved.text,
+        contentHash: resolved.contentHash,
+      });
+    }
+  }
+
+  for (const root of options.roots) {
+    const absoluteRoot = join(workspaceRoot, root);
+    if (nodeFileSystem.exists(absoluteRoot)) {
+      walkDirectory(absoluteRoot);
+    }
+  }
+
+  sources.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  return { sources, index };
+}
+
+export function filterSourcesByPattern(
+  sources: SourceFile[],
+  pattern: RegExp,
+): SourceFile[] {
+  return sources.filter((source) => pattern.test(source.path));
+}

package/src/forge/compiler/package-graph/capabilities-stub.ts

@@ -0,0 +1,33 @@
+import type { CapabilitySet } from "../types/capability.ts";
+import type { ExportClassification } from "../types/package-graph.ts";
+
+export function emptyCapabilitySet(): CapabilitySet {
+  return {
+    network: { status: "unknown", confidence: "static", evidence: [] },
+    filesystem: { status: "unknown", confidence: "static", evidence: [] },
+    process: { status: "unknown", confidence: "static", evidence: [] },
+    nativeAddon: { status: "not-detected", confidence: "static", evidence: [] },
+    lifecycleScripts: {
+      status: "not-detected",
+      confidence: "static",
+      evidence: [],
+    },
+    secrets: [],
+  };
+}
+
+export function stubExportClassification(
+  packageName: string,
+  entrypoint: string,
+  exportName: string,
+): ExportClassification {
+  return {
+    alias: packageName,
+    packageName,
+    entrypoint,
+    exportName,
+    compatible: [],
+    incompatible: [],
+    capabilities: emptyCapabilitySet(),
+  };
+}

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

@@ -0,0 +1,97 @@
+import { join, relative } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+import type { PackageApi } from "../types/package-graph.ts";
+import { readTextFile } from "./read-file.ts";
+
+export function hashPackageJson(installPath: string): string {
+  const packageJsonPath = join(installPath, "package.json");
+  return hashStable(readTextFile(packageJsonPath));
+}
+
+/** Fast cache-key fingerprint: one stat per package.json instead of reading contents. */
+export function hashPackageJsonForCache(installPath: string): string {
+  const packageJsonPath = join(installPath, "package.json");
+  const stat = nodeFileSystem.stat(packageJsonPath);
+  if (stat !== null) {
+    return hashStable(`stat:${stat.size}:${stat.mtimeMs}`);
+  }
+  return hashPackageJson(installPath);
+}
+
+export function hashDtsFiles(installPath: string): string {
+  const files = collectDtsFiles(installPath).sort((a, b) => a.localeCompare(b));
+  const parts: string[] = [];
+  for (const file of files) {
+    const rel = relative(installPath, file).replace(/\\/g, "/");
+    parts.push(rel);
+    parts.push(hashStable(readTextFile(file)));
+  }
+  return hashStable(parts.join("\0"));
+}
+
+/** Fast cache-key fingerprint using file stat metadata instead of reading every .d.ts body. */
+export function hashDtsFilesForCache(installPath: string): string {
+  const files = collectDtsFiles(installPath).sort((a, b) => a.localeCompare(b));
+  const parts: string[] = [];
+  for (const file of files) {
+    const rel = relative(installPath, file).replace(/\\/g, "/");
+    const stat = nodeFileSystem.stat(file);
+    parts.push(rel);
+    parts.push(`${stat?.size ?? 0}:${stat?.mtimeMs ?? 0}`);
+  }
+  return hashStable(parts.join("\0"));
+}
+
+function collectDtsFiles(dir: string): string[] {
+  const files: string[] = [];
+
+  for (const entry of nodeFileSystem.readDir(dir)) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory) {
+      if (entry.name === "node_modules") {
+        continue;
+      }
+      files.push(...collectDtsFiles(full));
+    } else if (entry.name.endsWith(".d.ts")) {
+      files.push(full);
+    }
+  }
+
+  return files;
+}
+
+export function computeContentChecksum(
+  packageJsonHash: string,
+  dtsFilesHash: string,
+  api: Pick<
+    PackageApi,
+    "entrypoints" | "resolutionMode" | "source" | "runtimeShape"
+  >,
+): string {
+  const payload = {
+    packageJsonHash,
+    dtsFilesHash,
+    resolutionMode: api.resolutionMode,
+    source: api.source,
+    runtimeShape: api.runtimeShape ?? null,
+    entrypoints: api.entrypoints.map((ep) => ({
+      subpath: ep.subpath,
+      conditions: ep.conditions,
+      patternBacked: ep.patternBacked,
+      dtsPath: ep.dtsPath,
+      exports: ep.exports.map((ex) => ({
+        name: ex.name,
+        kind: ex.kind,
+        signature: ex.signature,
+        overloads: ex.overloads,
+        declarations: ex.declarations,
+        jsdoc: ex.jsdoc,
+        examples: ex.examples,
+      })),
+    })),
+  };
+
+  return hashStable(canonicalJson(payload));
+}