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

package/src/forge/compiler/package-manager/detect.ts

@@ -1,55 +1,55 @@
 import { join } from "node:path";
 import { nodeFileSystem } from "../fs/index.ts";
 import type { PackageManager } from "../types/runtime.ts";
-
-/** Lockfiles checked in priority order when `packageManager` is absent. */
-export const LOCKFILE_PM_MAP: readonly { file: string; pm: PackageManager }[] = [
-  { file: "bun.lockb", pm: "bun" },
-  { file: "bun.lock", pm: "bun" },
-  { file: "pnpm-lock.yaml", pm: "pnpm" },
-  { file: "yarn.lock", pm: "yarn" },
-  { file: "package-lock.json", pm: "npm" },
-] as const;
-
-const PM_FROM_FIELD = /^(bun|npm|pnpm|yarn)(?:@|$)/;
-
-export function parsePackageManagerField(value: string): PackageManager | null {
-  const match = value.trim().match(PM_FROM_FIELD);
-  return match ? (match[1] as PackageManager) : null;
-}
-
-export function getLockfileForPm(pm: PackageManager): string {
-  switch (pm) {
-    case "bun":
-      return "bun.lock";
-    case "npm":
-      return "package-lock.json";
-    case "pnpm":
-      return "pnpm-lock.yaml";
-    case "yarn":
-      return "yarn.lock";
-  }
-}
-
-/** All lockfile names that may exist for a given package manager. */
-export function getLockfileCandidates(pm: PackageManager): readonly string[] {
-  if (pm === "bun") {
-    return ["bun.lock", "bun.lockb"];
-  }
-  return [getLockfileForPm(pm)];
-}
-
-export function detectPackageManagerFromLockfiles(
-  workspaceRoot: string,
-): PackageManager | null {
-  for (const { file, pm } of LOCKFILE_PM_MAP) {
-    if (nodeFileSystem.exists(join(workspaceRoot, file))) {
-      return pm;
-    }
-  }
-  return null;
-}
-
+
+/** Lockfiles checked in priority order when `packageManager` is absent. */
+export const LOCKFILE_PM_MAP: readonly { file: string; pm: PackageManager }[] = [
+  { file: "bun.lockb", pm: "bun" },
+  { file: "bun.lock", pm: "bun" },
+  { file: "pnpm-lock.yaml", pm: "pnpm" },
+  { file: "yarn.lock", pm: "yarn" },
+  { file: "package-lock.json", pm: "npm" },
+] as const;
+
+const PM_FROM_FIELD = /^(bun|npm|pnpm|yarn)(?:@|$)/;
+
+export function parsePackageManagerField(value: string): PackageManager | null {
+  const match = value.trim().match(PM_FROM_FIELD);
+  return match ? (match[1] as PackageManager) : null;
+}
+
+export function getLockfileForPm(pm: PackageManager): string {
+  switch (pm) {
+    case "bun":
+      return "bun.lock";
+    case "npm":
+      return "package-lock.json";
+    case "pnpm":
+      return "pnpm-lock.yaml";
+    case "yarn":
+      return "yarn.lock";
+  }
+}
+
+/** All lockfile names that may exist for a given package manager. */
+export function getLockfileCandidates(pm: PackageManager): readonly string[] {
+  if (pm === "bun") {
+    return ["bun.lock", "bun.lockb"];
+  }
+  return [getLockfileForPm(pm)];
+}
+
+export function detectPackageManagerFromLockfiles(
+  workspaceRoot: string,
+): PackageManager | null {
+  for (const { file, pm } of LOCKFILE_PM_MAP) {
+    if (nodeFileSystem.exists(join(workspaceRoot, file))) {
+      return pm;
+    }
+  }
+  return null;
+}
+
 /**
  * Detect the active package manager via `package.json#packageManager` or lockfile presence.
  * Defaults to `npm` when the project has not declared a package manager.
@@ -58,22 +58,22 @@ export function detectPackageManagerFromLockfiles(
  * launches from ambiguous `bun` associations.
  */
 export function detectPackageManager(workspaceRoot: string): PackageManager {
-  const pkgPath = join(workspaceRoot, "package.json");
-  if (nodeFileSystem.exists(pkgPath)) {
-    try {
-      const pkg = JSON.parse((nodeFileSystem.readText(pkgPath) ?? "")) as {
-        packageManager?: string;
-      };
-      if (pkg.packageManager) {
-        const fromField = parsePackageManagerField(pkg.packageManager);
-        if (fromField) {
-          return fromField;
-        }
-      }
-    } catch {
-      // fall through to lockfile detection
-    }
-  }
+  const pkgPath = join(workspaceRoot, "package.json");
+  if (nodeFileSystem.exists(pkgPath)) {
+    try {
+      const pkg = JSON.parse((nodeFileSystem.readText(pkgPath) ?? "")) as {
+        packageManager?: string;
+      };
+      if (pkg.packageManager) {
+        const fromField = parsePackageManagerField(pkg.packageManager);
+        if (fromField) {
+          return fromField;
+        }
+      }
+    } catch {
+      // fall through to lockfile detection
+    }
+  }
 
   return detectPackageManagerFromLockfiles(workspaceRoot) ?? "npm";
 }

package/src/forge/compiler/package-manager/executor.ts

@@ -9,14 +9,14 @@ import {
 export interface CommandRunOptions {
   cwd: string;
   env?: Record<string, string | undefined>;
-}
-
-export interface CommandRunResult {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-}
-
+}
+
+export interface CommandRunResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
 export interface CommandExecutor {
   run(argv: string[], options: CommandRunOptions): Promise<CommandRunResult>;
 }
@@ -67,27 +67,27 @@ function resolveWindowsCommand(command: string): string {
 
   return command;
 }
-
-export class PackageManagerCommandError extends Error {
-  readonly exitCode: number;
-  readonly stdout: string;
-  readonly stderr: string;
-  readonly argv: readonly string[];
-
-  constructor(
-    message: string,
-    argv: readonly string[],
-    result: CommandRunResult,
-  ) {
-    super(message);
-    this.name = "PackageManagerCommandError";
-    this.argv = argv;
-    this.exitCode = result.exitCode;
-    this.stdout = result.stdout;
-    this.stderr = result.stderr;
-  }
-}
-
+
+export class PackageManagerCommandError extends Error {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly argv: readonly string[];
+
+  constructor(
+    message: string,
+    argv: readonly string[],
+    result: CommandRunResult,
+  ) {
+    super(message);
+    this.name = "PackageManagerCommandError";
+    this.argv = argv;
+    this.exitCode = result.exitCode;
+    this.stdout = result.stdout;
+    this.stderr = result.stderr;
+  }
+}
+
 export const defaultCommandExecutor: CommandExecutor = {
   async run(argv, options) {
     const resolvedArgv = resolvePackageManagerArgv(argv);

package/src/forge/compiler/package-manager/index.ts

@@ -1,22 +1,22 @@
-export type {
-  PackageManagerAdapter,
-  DryRunAddResult,
-  CreatePackageManagerAdapterOptions,
-} from "./adapter.ts";
-export {
-  createPackageManagerAdapter,
-  detectAndCreatePackageManagerAdapter,
-  dryRunRecipeFallbackMessage,
-  detectPackageManager,
-  detectPackageManagerFromLockfiles,
-  getLockfileForPm,
-  getLockfileCandidates,
-  parsePackageManagerField,
-  LOCKFILE_PM_MAP,
-  buildAddCommand,
-  parsePackageName,
-  readInstalledVersion,
-  defaultCommandExecutor,
-  PackageManagerCommandError,
-} from "./adapter.ts";
-export type { CommandExecutor, CommandRunResult } from "./executor.ts";
+export type {
+  PackageManagerAdapter,
+  DryRunAddResult,
+  CreatePackageManagerAdapterOptions,
+} from "./adapter.ts";
+export {
+  createPackageManagerAdapter,
+  detectAndCreatePackageManagerAdapter,
+  dryRunRecipeFallbackMessage,
+  detectPackageManager,
+  detectPackageManagerFromLockfiles,
+  getLockfileForPm,
+  getLockfileCandidates,
+  parsePackageManagerField,
+  LOCKFILE_PM_MAP,
+  buildAddCommand,
+  parsePackageName,
+  readInstalledVersion,
+  defaultCommandExecutor,
+  PackageManagerCommandError,
+} from "./adapter.ts";
+export type { CommandExecutor, CommandRunResult } from "./executor.ts";

package/src/forge/compiler/package-manager/parse-spec.ts

@@ -1,16 +1,16 @@
-/**
- * Parse a package name from an install spec (e.g. "lodash@4.17.21", "@scope/pkg@1.0.0").
- */
-export function parsePackageName(spec: string): string {
-  const trimmed = spec.trim();
-  if (trimmed.startsWith("@")) {
-    const slashIdx = trimmed.indexOf("/");
-    if (slashIdx === -1) {
-      return trimmed;
-    }
-    const versionAt = trimmed.indexOf("@", slashIdx + 1);
-    return versionAt === -1 ? trimmed : trimmed.slice(0, versionAt);
-  }
-  const atIdx = trimmed.indexOf("@");
-  return atIdx === -1 ? trimmed : trimmed.slice(0, atIdx);
-}
+/**
+ * Parse a package name from an install spec (e.g. "lodash@4.17.21", "@scope/pkg@1.0.0").
+ */
+export function parsePackageName(spec: string): string {
+  const trimmed = spec.trim();
+  if (trimmed.startsWith("@")) {
+    const slashIdx = trimmed.indexOf("/");
+    if (slashIdx === -1) {
+      return trimmed;
+    }
+    const versionAt = trimmed.indexOf("@", slashIdx + 1);
+    return versionAt === -1 ? trimmed : trimmed.slice(0, versionAt);
+  }
+  const atIdx = trimmed.indexOf("@");
+  return atIdx === -1 ? trimmed : trimmed.slice(0, atIdx);
+}

package/src/forge/compiler/package-manager/version.ts

@@ -1,27 +1,27 @@
 import { join } from "node:path";
 import { nodeFileSystem } from "../fs/index.ts";
 import { parsePackageName } from "./parse-spec.ts";
-
-export function readInstalledVersion(
-  specOrName: string,
-  cwd: string,
-): string | null {
+
+export function readInstalledVersion(
+  specOrName: string,
+  cwd: string,
+): string | null {
   const name = parsePackageName(specOrName);
   const segments = name.startsWith("@")
     ? name.split("/")
     : [name];
-  const pkgJsonPath = join(cwd, "node_modules", ...segments, "package.json");
-
-  if (!nodeFileSystem.exists(pkgJsonPath)) {
-    return null;
-  }
-
-  try {
-    const pkg = JSON.parse((nodeFileSystem.readText(pkgJsonPath) ?? "")) as {
-      version?: string;
-    };
-    return typeof pkg.version === "string" ? pkg.version : null;
-  } catch {
-    return null;
-  }
-}
+  const pkgJsonPath = join(cwd, "node_modules", ...segments, "package.json");
+
+  if (!nodeFileSystem.exists(pkgJsonPath)) {
+    return null;
+  }
+
+  try {
+    const pkg = JSON.parse((nodeFileSystem.readText(pkgJsonPath) ?? "")) as {
+      version?: string;
+    };
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}

package/src/forge/compiler/primitives/compare.ts

@@ -1,26 +1,26 @@
-/**
- * Compare two strings by UTF-8 byte sequence (case-sensitive, locale-independent).
- * Returns negative if a < b, positive if a > b, zero if equal.
- */
-export function compareBytes(a: string, b: string): number {
-  const aBytes = new TextEncoder().encode(a);
-  const bBytes = new TextEncoder().encode(b);
-  const len = Math.min(aBytes.length, bBytes.length);
-
-  for (let i = 0; i < len; i++) {
-    const diff = aBytes[i]! - bBytes[i]!;
-    if (diff !== 0) {
-      return diff;
-    }
-  }
-
-  return aBytes.length - bBytes.length;
-}
-
-export function compareBytesAsc(a: string, b: string): number {
-  return compareBytes(a, b);
-}
-
-export function compareBytesDesc(a: string, b: string): number {
-  return compareBytes(b, a);
-}
+/**
+ * Compare two strings by UTF-8 byte sequence (case-sensitive, locale-independent).
+ * Returns negative if a < b, positive if a > b, zero if equal.
+ */
+export function compareBytes(a: string, b: string): number {
+  const aBytes = new TextEncoder().encode(a);
+  const bBytes = new TextEncoder().encode(b);
+  const len = Math.min(aBytes.length, bBytes.length);
+
+  for (let i = 0; i < len; i++) {
+    const diff = aBytes[i]! - bBytes[i]!;
+    if (diff !== 0) {
+      return diff;
+    }
+  }
+
+  return aBytes.length - bBytes.length;
+}
+
+export function compareBytesAsc(a: string, b: string): number {
+  return compareBytes(a, b);
+}
+
+export function compareBytesDesc(a: string, b: string): number {
+  return compareBytes(b, a);
+}

package/src/forge/compiler/primitives/hash.ts

@@ -1,40 +1,49 @@
 import { createHash } from "node:crypto";
 import { stripDeterministicHeader } from "./header.ts";
-
-/**
- * SHA-256 hash of UTF-8 content, returned as lowercase hex.
- */
+
+/**
+ * SHA-256 hash of UTF-8 text, returned as lowercase hex.
+ *
+ * Forge generated artifacts must be stable across Windows and Linux checkouts.
+ * Git may materialize source files with CRLF locally and LF in CI, so text
+ * hashes normalize line endings. Use hashUtf8Bytes when byte-level identity is
+ * required.
+ */
 export function hashStable(content: string): string {
-  return createHash("sha256").update(content).digest("hex");
+  return createHash("sha256").update(normalizeHashText(content)).digest("hex");
 }
-
-/**
- * Hash content after stripping the deterministic header (for diff/cache keys).
- */
-export function hashStableBody(content: string): string {
-  return hashStable(stripDeterministicHeader(content));
-}
-
-export interface StableSymbolIdInput {
-  kind: string;
-  canonicalModulePath: string;
-  qualifiedName: string;
-  exportPath: string;
-}
-
-/**
- * Derive a collision-safe stable symbol id from kind + module + name + export path.
- */
-export function deriveStableSymbolId(input: StableSymbolIdInput): string {
-  const parts = [
-    input.kind,
-    input.canonicalModulePath,
-    input.qualifiedName,
-    input.exportPath,
-  ];
-  return hashStable(parts.join("\0"));
-}
-
+
+export function normalizeHashText(content: string): string {
+  return content.replace(/\r\n?/g, "\n");
+}
+
+/**
+ * Hash content after stripping the deterministic header (for diff/cache keys).
+ */
+export function hashStableBody(content: string): string {
+  return hashStable(stripDeterministicHeader(content));
+}
+
+export interface StableSymbolIdInput {
+  kind: string;
+  canonicalModulePath: string;
+  qualifiedName: string;
+  exportPath: string;
+}
+
+/**
+ * Derive a collision-safe stable symbol id from kind + module + name + export path.
+ */
+export function deriveStableSymbolId(input: StableSymbolIdInput): string {
+  const parts = [
+    input.kind,
+    input.canonicalModulePath,
+    input.qualifiedName,
+    input.exportPath,
+  ];
+  return hashStable(parts.join("\0"));
+}
+
 export function hashUtf8Bytes(bytes: Uint8Array): string {
   return createHash("sha256").update(bytes).digest("hex");
 }

package/src/forge/compiler/primitives/header.ts

@@ -1,45 +1,45 @@
-import { hashStable } from "./hash.ts";
-
-export const DETERMINISTIC_HEADER_PREFIX = "// @forge-generated";
-
-export interface DeterministicHeaderFields {
-  generatorVersion: string;
-  inputHash: string;
-  contentHash: string;
-}
-
+import { hashStable } from "./hash.ts";
+
+export const DETERMINISTIC_HEADER_PREFIX = "// @forge-generated";
+
+export interface DeterministicHeaderFields {
+  generatorVersion: string;
+  inputHash: string;
+  contentHash: string;
+}
+
 const HEADER_PATTERN =
   /^\/\/ @forge-generated generator=([^\s]+) input=([^\s]+) content=([^\s]+)\r?\n/;
-
-export function formatDeterministicHeader(
-  fields: DeterministicHeaderFields,
-): string {
-  return `${DETERMINISTIC_HEADER_PREFIX} generator=${fields.generatorVersion} input=${fields.inputHash} content=${fields.contentHash}\n`;
-}
-
-export function parseDeterministicHeader(
-  content: string,
-): DeterministicHeaderFields | null {
-  const match = content.match(HEADER_PATTERN);
-  if (match === null) {
-    return null;
-  }
-
-  return {
-    generatorVersion: match[1]!,
-    inputHash: match[2]!,
-    contentHash: match[3]!,
-  };
-}
-
-export function stripDeterministicHeader(content: string): string {
-  return content.replace(HEADER_PATTERN, "");
-}
-
-export function prependDeterministicHeader(
-  body: string,
-  fields: Omit<DeterministicHeaderFields, "contentHash">,
-): string {
-  const contentHash = hashStable(body);
-  return formatDeterministicHeader({ ...fields, contentHash }) + body;
-}
+
+export function formatDeterministicHeader(
+  fields: DeterministicHeaderFields,
+): string {
+  return `${DETERMINISTIC_HEADER_PREFIX} generator=${fields.generatorVersion} input=${fields.inputHash} content=${fields.contentHash}\n`;
+}
+
+export function parseDeterministicHeader(
+  content: string,
+): DeterministicHeaderFields | null {
+  const match = content.match(HEADER_PATTERN);
+  if (match === null) {
+    return null;
+  }
+
+  return {
+    generatorVersion: match[1]!,
+    inputHash: match[2]!,
+    contentHash: match[3]!,
+  };
+}
+
+export function stripDeterministicHeader(content: string): string {
+  return content.replace(HEADER_PATTERN, "");
+}
+
+export function prependDeterministicHeader(
+  body: string,
+  fields: Omit<DeterministicHeaderFields, "contentHash">,
+): string {
+  const contentHash = hashStable(body);
+  return formatDeterministicHeader({ ...fields, contentHash }) + body;
+}

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

@@ -1,45 +1,45 @@
-export { Result, ok, err, isOk, isErr } from "./result.ts";
-export type { Ok, Err } from "./result.ts";
-export {
-  compareBytes,
-  compareBytesAsc,
-  compareBytesDesc,
-} from "./compare.ts";
-export { normalizePath, comparePaths } from "./paths.ts";
-export {
-  hashStable,
-  hashStableBody,
-  deriveStableSymbolId,
-  hashUtf8Bytes,
-} from "./hash.ts";
-export type { StableSymbolIdInput } from "./hash.ts";
-export {
-  DETERMINISTIC_HEADER_PREFIX,
-  formatDeterministicHeader,
-  parseDeterministicHeader,
-  stripDeterministicHeader,
-  prependDeterministicHeader,
-} from "./header.ts";
-export type { DeterministicHeaderFields } from "./header.ts";
-export {
-  normalizeNewlines,
-  canonicalJson,
-  serializeCanonical,
-  serializeJsonValue,
-} from "./serialize.ts";
-export {
-  compareSymbols,
-  compareEdges,
-  comparePackages,
-  compareEntrypoints,
-  compareExports,
-  compareEmitFiles,
-  stableSortSymbols,
-  stableSortEdges,
-  stableSortPackages,
-  stableSortEntrypoints,
-  stableSortExports,
-  stableSortEmitFiles,
-  stableSortStrings,
-  stableSortByPath,
-} from "./sort.ts";
+export { Result, ok, err, isOk, isErr } from "./result.ts";
+export type { Ok, Err } from "./result.ts";
+export {
+  compareBytes,
+  compareBytesAsc,
+  compareBytesDesc,
+} from "./compare.ts";
+export { normalizePath, comparePaths } from "./paths.ts";
+export {
+  hashStable,
+  hashStableBody,
+  deriveStableSymbolId,
+  hashUtf8Bytes,
+} from "./hash.ts";
+export type { StableSymbolIdInput } from "./hash.ts";
+export {
+  DETERMINISTIC_HEADER_PREFIX,
+  formatDeterministicHeader,
+  parseDeterministicHeader,
+  stripDeterministicHeader,
+  prependDeterministicHeader,
+} from "./header.ts";
+export type { DeterministicHeaderFields } from "./header.ts";
+export {
+  normalizeNewlines,
+  canonicalJson,
+  serializeCanonical,
+  serializeJsonValue,
+} from "./serialize.ts";
+export {
+  compareSymbols,
+  compareEdges,
+  comparePackages,
+  compareEntrypoints,
+  compareExports,
+  compareEmitFiles,
+  stableSortSymbols,
+  stableSortEdges,
+  stableSortPackages,
+  stableSortEntrypoints,
+  stableSortExports,
+  stableSortEmitFiles,
+  stableSortStrings,
+  stableSortByPath,
+} from "./sort.ts";