forgeos 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/forge/compiler/emitter/barrel.ts

@@ -1,44 +1,44 @@
-import { comparePaths, normalizeNewlines, normalizePath } from "../primitives/index.ts";
-import { BARREL_INDEX_PATH, GENERATED_DIR } from "./constants.ts";
-
-function toBarrelExportPath(filePath: string): string {
-  const normalized = normalizePath(filePath);
-  const generatedPrefix = `${GENERATED_DIR}/`;
-
-  if (!normalized.startsWith(generatedPrefix)) {
-    throw new Error(`barrel export path must live under ${GENERATED_DIR}: ${filePath}`);
-  }
-
-  const relative = normalized.slice(generatedPrefix.length);
-  const withoutExtension = relative.replace(/\.tsx?$/, "");
-  return `./${withoutExtension}`;
-}
-
-/**
- * Build barrel index.ts body (sorted re-exports, no header).
- */
-export function buildBarrelIndexBody(exportFilePaths: string[]): string {
-  const candidates = exportFilePaths
-    .map(normalizePath)
-    .filter(
+import { comparePaths, normalizeNewlines, normalizePath } from "../primitives/index.ts";
+import { BARREL_INDEX_PATH, GENERATED_DIR } from "./constants.ts";
+
+function toBarrelExportPath(filePath: string): string {
+  const normalized = normalizePath(filePath);
+  const generatedPrefix = `${GENERATED_DIR}/`;
+
+  if (!normalized.startsWith(generatedPrefix)) {
+    throw new Error(`barrel export path must live under ${GENERATED_DIR}: ${filePath}`);
+  }
+
+  const relative = normalized.slice(generatedPrefix.length);
+  const withoutExtension = relative.replace(/\.tsx?$/, "");
+  return `./${withoutExtension}`;
+}
+
+/**
+ * Build barrel index.ts body (sorted re-exports, no header).
+ */
+export function buildBarrelIndexBody(exportFilePaths: string[]): string {
+  const candidates = exportFilePaths
+    .map(normalizePath)
+    .filter(
       (path) =>
         path.startsWith(`${GENERATED_DIR}/`) &&
         (path.endsWith(".ts") || path.endsWith(".tsx")) &&
         !path.endsWith(".d.ts") &&
         path !== BARREL_INDEX_PATH,
     );
-
-  const unique = [...new Set(candidates)];
-  unique.sort(comparePaths);
-
-  const lines = unique.map((path) => {
-    const exportPath = toBarrelExportPath(path);
-    return `export * from "${exportPath}";`;
-  });
-
-  if (lines.length === 0) {
-    return normalizeNewlines("// Forge generated barrel\n");
-  }
-
-  return normalizeNewlines(lines.join("\n"));
-}
+
+  const unique = [...new Set(candidates)];
+  unique.sort(comparePaths);
+
+  const lines = unique.map((path) => {
+    const exportPath = toBarrelExportPath(path);
+    return `export * from "${exportPath}";`;
+  });
+
+  if (lines.length === 0) {
+    return normalizeNewlines("// Forge generated barrel\n");
+  }
+
+  return normalizeNewlines(lines.join("\n"));
+}

package/src/forge/compiler/emitter/constants.ts

@@ -1,7 +1,7 @@
-import { GENERATOR_VERSION } from "../package-graph/constants.ts";
-
-export const FORGE_LOCK_SCHEMA_VERSION = "1.0.0";
-export const GENERATED_DIR = "src/forge/_generated";
-export const FORGE_LOCK_PATH = "forge.lock";
-export const BARREL_INDEX_PATH = `${GENERATED_DIR}/index.ts`;
-export { GENERATOR_VERSION };
+import { GENERATOR_VERSION } from "../package-graph/constants.ts";
+
+export const FORGE_LOCK_SCHEMA_VERSION = "1.0.0";
+export const GENERATED_DIR = "src/forge/_generated";
+export const FORGE_LOCK_PATH = "forge.lock";
+export const BARREL_INDEX_PATH = `${GENERATED_DIR}/index.ts`;
+export { GENERATOR_VERSION };

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

@@ -1,237 +1,234 @@
-import { join } from "node:path";
-import type { Diagnostic } from "../types/diagnostic.ts";
-import type { EmitFile, EmitMode, EmitPlan } from "../types/emit.ts";
-import { runWithConcurrency } from "../cache/scheduler.ts";
-import { nodeFileSystem } from "../fs/index.ts";
-import type { FileSystem } from "../fs/index.ts";
-import {
-  forgeDrift,
-  forgeOrphanedGeneratedFile,
-  forgeWriteError,
-} from "../diagnostics/create.ts";
-import {
-  hashStable,
-  normalizePath,
-  stableSortByPath,
-  stableSortEmitFiles,
-  stripDeterministicHeader,
-} from "../primitives/index.ts";
-import { buildBarrelIndexBody } from "./barrel.ts";
-import {
-  BARREL_INDEX_PATH,
-  FORGE_LOCK_PATH,
-  GENERATED_DIR,
-} from "./constants.ts";
-import { serializeForgeLock } from "./lock.ts";
-import { render, renderBody, type RenderContext } from "./render.ts";
-import {
-  readTextFileIfExists,
-  removeFileIfExists,
-  writeFileAtomic,
-} from "./write.ts";
-
-export interface EmitOptions {
-  workspaceRoot: string;
-  mode: EmitMode;
-  fs?: FileSystem;
-}
-
-export interface EmitResult {
-  changed: string[];
-  unchanged: string[];
-  removed: string[];
-  wouldChange: string[];
-  warnings: Diagnostic[];
-  errors: Diagnostic[];
-  exitCode: 0 | 1;
-}
-
-function resolveWorkspacePath(workspaceRoot: string, relativePath: string): string {
-  return join(workspaceRoot, normalizePath(relativePath));
-}
-
-function bodiesDiffer(rendered: string, onDisk: string | null): boolean {
-  const renderedBody = stripDeterministicHeader(rendered);
-  if (onDisk === null) {
-    return true;
-  }
-  const diskBody = stripDeterministicHeader(onDisk);
-  return renderedBody !== diskBody;
-}
-
-function buildRenderContext(plan: EmitPlan): RenderContext {
-  return {
-    generatorVersion: plan.lock.generatorVersion,
-    inputHash: plan.lock.inputHash,
-  };
-}
-
-function upsertBarrelFile(files: EmitFile[], exportPaths: string[]): EmitFile[] {
-  const body = buildBarrelIndexBody(exportPaths);
-  const barrel: EmitFile = {
-    path: BARREL_INDEX_PATH,
-    content: body,
-    contentHash: hashStable(body),
-  };
-
-  const withoutBarrel = files.filter((file) => file.path !== BARREL_INDEX_PATH);
-  return stableSortEmitFiles([...withoutBarrel, barrel]);
-}
-
-function preparePlannedFiles(plan: EmitPlan): EmitFile[] {
-  const exportPaths = plan.files.map((file) => file.path);
-  return upsertBarrelFile(plan.files, exportPaths);
-}
-
-async function classifyFile(
-  file: EmitFile,
-  context: RenderContext,
-  workspaceRoot: string,
-  fs: FileSystem = nodeFileSystem,
-): Promise<"changed" | "unchanged"> {
-  const rendered = render(file, context);
-  const absolutePath = resolveWorkspacePath(workspaceRoot, file.path);
-  const onDisk = await readTextFileIfExists(absolutePath, fs);
-  return bodiesDiffer(rendered, onDisk) ? "changed" : "unchanged";
-}
-
-export async function emit(plan: EmitPlan, options: EmitOptions): Promise<EmitResult> {
-  const { workspaceRoot, mode } = options;
-  const fs = options.fs ?? nodeFileSystem;
-  const context = buildRenderContext(plan);
-  const plannedFiles = preparePlannedFiles(plan);
-  const sortedOrphans = stableSortByPath([...plan.orphanedFiles]);
-
-  const changed: string[] = [];
-  const unchanged: string[] = [];
-  const wouldChange: string[] = [];
-  const removed: string[] = [];
-  const warnings: Diagnostic[] = [];
-  const errors: Diagnostic[] = [];
-
-  const classifications = await runWithConcurrency(
-    plannedFiles,
-    8,
-    async (file) => {
-      const rendered = render(file, context);
-      const absolutePath = resolveWorkspacePath(workspaceRoot, file.path);
-      const onDisk = await readTextFileIfExists(absolutePath, fs);
-      return {
-        file,
-        rendered,
-        differs: bodiesDiffer(rendered, onDisk),
-      };
-    },
-  );
-
-  for (const { file, rendered, differs } of classifications) {
-    if (differs) {
-      changed.push(file.path);
-      wouldChange.push(file.path);
-
-      if (mode === "check" || mode === "dry-run") {
-        warnings.push(forgeDrift(file.path));
-        continue;
-      }
-
-      try {
-        const absolutePath = resolveWorkspacePath(workspaceRoot, file.path);
-        await writeFileAtomic(absolutePath, rendered, fs);
-      } catch {
-        errors.push(forgeWriteError(file.path));
-      }
-    } else {
-      unchanged.push(file.path);
-    }
-  }
-
-  for (const orphan of sortedOrphans) {
-    const normalizedOrphan = normalizePath(orphan);
-    if (!normalizedOrphan.startsWith(`${GENERATED_DIR}/`)) {
-      continue;
-    }
-
-    const absoluteOrphan = resolveWorkspacePath(workspaceRoot, normalizedOrphan);
-
-    if (mode === "check") {
-      errors.push(forgeOrphanedGeneratedFile(normalizedOrphan));
-      continue;
-    }
-
-    if (mode === "dry-run") {
-      wouldChange.push(normalizedOrphan);
-      continue;
-    }
-
-    const removedOrphan = await removeFileIfExists(absoluteOrphan, fs);
-    if (removedOrphan) {
-      removed.push(normalizedOrphan);
-    }
-  }
-
-  const lockDiffers = await lockWouldChange(plan, workspaceRoot, fs);
-
-  if (lockDiffers) {
-    wouldChange.push(FORGE_LOCK_PATH);
-    if (mode === "check" || mode === "dry-run") {
-      warnings.push(forgeDrift(FORGE_LOCK_PATH));
-    }
-  }
-
-  if (mode === "write" && errors.length === 0) {
-    const lockContent = serializeForgeLock(plan.lock);
-    const lockAbsolutePath = resolveWorkspacePath(workspaceRoot, FORGE_LOCK_PATH);
-
-    try {
-      if (lockDiffers) {
-        await writeFileAtomic(lockAbsolutePath, lockContent, fs);
-        changed.push(FORGE_LOCK_PATH);
-      } else {
-        unchanged.push(FORGE_LOCK_PATH);
-      }
-    } catch {
-      errors.push(forgeWriteError(FORGE_LOCK_PATH));
-    }
-  }
-
-  const driftFailure =
-    mode === "check" &&
-    (changed.length > 0 || sortedOrphans.length > 0 || lockDiffers);
-  const exitCode: 0 | 1 =
-    errors.length > 0 || driftFailure ? 1 : 0;
-
-  return {
-    changed,
-    unchanged,
-    removed,
-    wouldChange,
-    warnings,
-    errors,
-    exitCode,
-  };
-}
-
-async function lockWouldChange(
-  plan: EmitPlan,
-  workspaceRoot: string,
-  fs: FileSystem = nodeFileSystem,
-): Promise<boolean> {
-  const lockContent = serializeForgeLock(plan.lock);
-  const lockAbsolutePath = resolveWorkspacePath(workspaceRoot, FORGE_LOCK_PATH);
-  const onDisk = await readTextFileIfExists(lockAbsolutePath, fs);
-  return onDisk !== lockContent;
-}
-
-/**
- * Exposed for tests: classify a single file without writing.
- */
-export async function classifyPlannedFile(
-  file: EmitFile,
-  context: RenderContext,
-  workspaceRoot: string,
-  fs: FileSystem = nodeFileSystem,
-): Promise<"changed" | "unchanged"> {
-  return classifyFile(file, context, workspaceRoot, fs);
-}
-
-export { render, renderBody, serializeForgeLock, buildBarrelIndexBody };
+import { join } from "node:path";
+import type { Diagnostic } from "../types/diagnostic.ts";
+import type { EmitFile, EmitMode, EmitPlan } from "../types/emit.ts";
+import { runWithConcurrency } from "../cache/scheduler.ts";
+import { nodeFileSystem } from "../fs/index.ts";
+import type { FileSystem } from "../fs/index.ts";
+import {
+  forgeDrift,
+  forgeOrphanedGeneratedFile,
+  forgeWriteError,
+} from "../diagnostics/create.ts";
+import {
+  hashStable,
+  normalizePath,
+  stableSortByPath,
+  stableSortEmitFiles,
+} from "../primitives/index.ts";
+import { buildBarrelIndexBody } from "./barrel.ts";
+import {
+  BARREL_INDEX_PATH,
+  FORGE_LOCK_PATH,
+  GENERATED_DIR,
+} from "./constants.ts";
+import { serializeForgeLock } from "./lock.ts";
+import { render, renderBody, type RenderContext } from "./render.ts";
+import {
+  readTextFileIfExists,
+  removeFileIfExists,
+  writeFileAtomic,
+} from "./write.ts";
+
+export interface EmitOptions {
+  workspaceRoot: string;
+  mode: EmitMode;
+  fs?: FileSystem;
+}
+
+export interface EmitResult {
+  changed: string[];
+  unchanged: string[];
+  removed: string[];
+  wouldChange: string[];
+  warnings: Diagnostic[];
+  errors: Diagnostic[];
+  exitCode: 0 | 1;
+}
+
+function resolveWorkspacePath(workspaceRoot: string, relativePath: string): string {
+  return join(workspaceRoot, normalizePath(relativePath));
+}
+
+function bodiesDiffer(rendered: string, onDisk: string | null): boolean {
+  if (onDisk === null) {
+    return true;
+  }
+  return rendered !== onDisk;
+}
+
+function buildRenderContext(plan: EmitPlan): RenderContext {
+  return {
+    generatorVersion: plan.lock.generatorVersion,
+    inputHash: plan.lock.inputHash,
+  };
+}
+
+function upsertBarrelFile(files: EmitFile[], exportPaths: string[]): EmitFile[] {
+  const body = buildBarrelIndexBody(exportPaths);
+  const barrel: EmitFile = {
+    path: BARREL_INDEX_PATH,
+    content: body,
+    contentHash: hashStable(body),
+  };
+
+  const withoutBarrel = files.filter((file) => file.path !== BARREL_INDEX_PATH);
+  return stableSortEmitFiles([...withoutBarrel, barrel]);
+}
+
+function preparePlannedFiles(plan: EmitPlan): EmitFile[] {
+  const exportPaths = plan.files.map((file) => file.path);
+  return upsertBarrelFile(plan.files, exportPaths);
+}
+
+async function classifyFile(
+  file: EmitFile,
+  context: RenderContext,
+  workspaceRoot: string,
+  fs: FileSystem = nodeFileSystem,
+): Promise<"changed" | "unchanged"> {
+  const rendered = render(file, context);
+  const absolutePath = resolveWorkspacePath(workspaceRoot, file.path);
+  const onDisk = await readTextFileIfExists(absolutePath, fs);
+  return bodiesDiffer(rendered, onDisk) ? "changed" : "unchanged";
+}
+
+export async function emit(plan: EmitPlan, options: EmitOptions): Promise<EmitResult> {
+  const { workspaceRoot, mode } = options;
+  const fs = options.fs ?? nodeFileSystem;
+  const context = buildRenderContext(plan);
+  const plannedFiles = preparePlannedFiles(plan);
+  const sortedOrphans = stableSortByPath([...plan.orphanedFiles]);
+
+  const changed: string[] = [];
+  const unchanged: string[] = [];
+  const wouldChange: string[] = [];
+  const removed: string[] = [];
+  const warnings: Diagnostic[] = [];
+  const errors: Diagnostic[] = [];
+
+  const classifications = await runWithConcurrency(
+    plannedFiles,
+    8,
+    async (file) => {
+      const rendered = render(file, context);
+      const absolutePath = resolveWorkspacePath(workspaceRoot, file.path);
+      const onDisk = await readTextFileIfExists(absolutePath, fs);
+      return {
+        file,
+        rendered,
+        differs: bodiesDiffer(rendered, onDisk),
+      };
+    },
+  );
+
+  for (const { file, rendered, differs } of classifications) {
+    if (differs) {
+      changed.push(file.path);
+      wouldChange.push(file.path);
+
+      if (mode === "check" || mode === "dry-run") {
+        warnings.push(forgeDrift(file.path));
+        continue;
+      }
+
+      try {
+        const absolutePath = resolveWorkspacePath(workspaceRoot, file.path);
+        await writeFileAtomic(absolutePath, rendered, fs);
+      } catch {
+        errors.push(forgeWriteError(file.path));
+      }
+    } else {
+      unchanged.push(file.path);
+    }
+  }
+
+  for (const orphan of sortedOrphans) {
+    const normalizedOrphan = normalizePath(orphan);
+    if (!normalizedOrphan.startsWith(`${GENERATED_DIR}/`)) {
+      continue;
+    }
+
+    const absoluteOrphan = resolveWorkspacePath(workspaceRoot, normalizedOrphan);
+
+    if (mode === "check") {
+      errors.push(forgeOrphanedGeneratedFile(normalizedOrphan));
+      continue;
+    }
+
+    if (mode === "dry-run") {
+      wouldChange.push(normalizedOrphan);
+      continue;
+    }
+
+    const removedOrphan = await removeFileIfExists(absoluteOrphan, fs);
+    if (removedOrphan) {
+      removed.push(normalizedOrphan);
+    }
+  }
+
+  const lockDiffers = await lockWouldChange(plan, workspaceRoot, fs);
+
+  if (lockDiffers) {
+    wouldChange.push(FORGE_LOCK_PATH);
+    if (mode === "check" || mode === "dry-run") {
+      warnings.push(forgeDrift(FORGE_LOCK_PATH));
+    }
+  }
+
+  if (mode === "write" && errors.length === 0) {
+    const lockContent = serializeForgeLock(plan.lock);
+    const lockAbsolutePath = resolveWorkspacePath(workspaceRoot, FORGE_LOCK_PATH);
+
+    try {
+      if (lockDiffers) {
+        await writeFileAtomic(lockAbsolutePath, lockContent, fs);
+        changed.push(FORGE_LOCK_PATH);
+      } else {
+        unchanged.push(FORGE_LOCK_PATH);
+      }
+    } catch {
+      errors.push(forgeWriteError(FORGE_LOCK_PATH));
+    }
+  }
+
+  const driftFailure =
+    mode === "check" &&
+    (changed.length > 0 || sortedOrphans.length > 0 || lockDiffers);
+  const exitCode: 0 | 1 =
+    errors.length > 0 || driftFailure ? 1 : 0;
+
+  return {
+    changed,
+    unchanged,
+    removed,
+    wouldChange,
+    warnings,
+    errors,
+    exitCode,
+  };
+}
+
+async function lockWouldChange(
+  plan: EmitPlan,
+  workspaceRoot: string,
+  fs: FileSystem = nodeFileSystem,
+): Promise<boolean> {
+  const lockContent = serializeForgeLock(plan.lock);
+  const lockAbsolutePath = resolveWorkspacePath(workspaceRoot, FORGE_LOCK_PATH);
+  const onDisk = await readTextFileIfExists(lockAbsolutePath, fs);
+  return onDisk !== lockContent;
+}
+
+/**
+ * Exposed for tests: classify a single file without writing.
+ */
+export async function classifyPlannedFile(
+  file: EmitFile,
+  context: RenderContext,
+  workspaceRoot: string,
+  fs: FileSystem = nodeFileSystem,
+): Promise<"changed" | "unchanged"> {
+  return classifyFile(file, context, workspaceRoot, fs);
+}
+
+export { render, renderBody, serializeForgeLock, buildBarrelIndexBody };

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

@@ -1,24 +1,24 @@
-export {
-  FORGE_LOCK_SCHEMA_VERSION,
-  GENERATED_DIR,
-  FORGE_LOCK_PATH,
-  BARREL_INDEX_PATH,
-  GENERATOR_VERSION,
-} from "./constants.ts";
-export { detectArtifactKind } from "./artifact-kind.ts";
-export type { ArtifactKind } from "./artifact-kind.ts";
-export { render, renderBody } from "./render.ts";
-export type { RenderContext } from "./render.ts";
-export { serializeForgeLock } from "./lock.ts";
-export { buildBarrelIndexBody } from "./barrel.ts";
-export {
-  readTextFileIfExists,
-  writeFileAtomic,
-  removeFileIfExists,
-} from "./write.ts";
-export {
-  emit,
-  classifyPlannedFile,
-  type EmitOptions,
-  type EmitResult,
-} from "./emit.ts";
+export {
+  FORGE_LOCK_SCHEMA_VERSION,
+  GENERATED_DIR,
+  FORGE_LOCK_PATH,
+  BARREL_INDEX_PATH,
+  GENERATOR_VERSION,
+} from "./constants.ts";
+export { detectArtifactKind } from "./artifact-kind.ts";
+export type { ArtifactKind } from "./artifact-kind.ts";
+export { render, renderBody } from "./render.ts";
+export type { RenderContext } from "./render.ts";
+export { serializeForgeLock } from "./lock.ts";
+export { buildBarrelIndexBody } from "./barrel.ts";
+export {
+  readTextFileIfExists,
+  writeFileAtomic,
+  removeFileIfExists,
+} from "./write.ts";
+export {
+  emit,
+  classifyPlannedFile,
+  type EmitOptions,
+  type EmitResult,
+} from "./emit.ts";