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

package/src/forge/compiler/cache/key.ts

@@ -1,46 +1,46 @@
-import type { PackageCacheKey } from "../types/lock.ts";
-import { hashStable } from "../primitives/hash.ts";
-import { canonicalJson } from "../primitives/serialize.ts";
-
-export function buildPackageCacheKey(
-  input: PackageCacheKey,
-): PackageCacheKey {
-  return {
-    name: input.name,
-    version: input.version,
-    packageManager: input.packageManager,
-    ...(input.packageIntegrity !== undefined
-      ? { packageIntegrity: input.packageIntegrity }
-      : {}),
-    packageJsonHash: input.packageJsonHash,
-    dtsFilesHash: input.dtsFilesHash,
-    analyzerVersion: input.analyzerVersion,
-    typescriptVersion: input.typescriptVersion,
-    resolutionMode: input.resolutionMode,
-    ...(input.recipeVersion !== undefined
-      ? { recipeVersion: input.recipeVersion }
-      : {}),
-  };
-}
-
-export function serializePackageCacheKey(key: PackageCacheKey): string {
-  return canonicalJson(key);
-}
-
-export function fingerprintPackageCacheKey(key: PackageCacheKey): string {
-  return hashStable(serializePackageCacheKey(key));
-}
-
-export function cacheKeysEqual(
-  a: PackageCacheKey,
-  b: PackageCacheKey,
-): boolean {
-  return serializePackageCacheKey(a) === serializePackageCacheKey(b);
-}
-
-/**
- * Global lockfile hash is informational and intentionally excluded from cache keys.
- */
-export function lockfileHashAffectsCache(_lockfileHash: string): boolean {
-  return false;
-}
+import type { PackageCacheKey } from "../types/lock.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+
+export function buildPackageCacheKey(
+  input: PackageCacheKey,
+): PackageCacheKey {
+  return {
+    name: input.name,
+    version: input.version,
+    packageManager: input.packageManager,
+    ...(input.packageIntegrity !== undefined
+      ? { packageIntegrity: input.packageIntegrity }
+      : {}),
+    packageJsonHash: input.packageJsonHash,
+    dtsFilesHash: input.dtsFilesHash,
+    analyzerVersion: input.analyzerVersion,
+    typescriptVersion: input.typescriptVersion,
+    resolutionMode: input.resolutionMode,
+    ...(input.recipeVersion !== undefined
+      ? { recipeVersion: input.recipeVersion }
+      : {}),
+  };
+}
+
+export function serializePackageCacheKey(key: PackageCacheKey): string {
+  return canonicalJson(key);
+}
+
+export function fingerprintPackageCacheKey(key: PackageCacheKey): string {
+  return hashStable(serializePackageCacheKey(key));
+}
+
+export function cacheKeysEqual(
+  a: PackageCacheKey,
+  b: PackageCacheKey,
+): boolean {
+  return serializePackageCacheKey(a) === serializePackageCacheKey(b);
+}
+
+/**
+ * Global lockfile hash is informational and intentionally excluded from cache keys.
+ */
+export function lockfileHashAffectsCache(_lockfileHash: string): boolean {
+  return false;
+}

package/src/forge/compiler/cache/scheduler.ts

@@ -1,72 +1,72 @@
-export async function runWithConcurrency<T, R>(
-  items: T[],
-  concurrency: number,
-  worker: (item: T, index: number) => Promise<R> | R,
-): Promise<R[]> {
-  const limit = Math.max(1, Math.floor(concurrency));
-  if (items.length === 0) {
-    return [];
-  }
-
-  if (limit === 1) {
-    const sequential: R[] = [];
-    for (let index = 0; index < items.length; index++) {
-      sequential.push(await worker(items[index]!, index));
-    }
-    return sequential;
-  }
-
-  const results = new Array<R>(items.length);
-  let nextIndex = 0;
-
-  async function runWorker(): Promise<void> {
-    while (true) {
-      const index = nextIndex;
-      nextIndex += 1;
-      if (index >= items.length) {
-        return;
-      }
-      results[index] = await worker(items[index]!, index);
-    }
-  }
-
-  const workers = Array.from({ length: Math.min(limit, items.length) }, () =>
-    runWorker(),
-  );
-  await Promise.all(workers);
-  return results;
-}
-
-export class ConcurrencyTracker {
-  current = 0;
-  maxObserved = 0;
-
-  enter(): void {
-    this.current += 1;
-    if (this.current > this.maxObserved) {
-      this.maxObserved = this.current;
-    }
-  }
-
-  leave(): void {
-    this.current -= 1;
-  }
-}
-
-export async function runWithConcurrencyTracked<T, R>(
-  items: T[],
-  concurrency: number,
-  worker: (item: T, index: number) => Promise<R> | R,
-  tracker: ConcurrencyTracker,
-): Promise<R[]> {
-  const limit = Math.max(1, Math.floor(concurrency));
-
-  return runWithConcurrency(items, limit, async (item, index) => {
-    tracker.enter();
-    try {
-      return await worker(item, index);
-    } finally {
-      tracker.leave();
-    }
-  });
-}
+export async function runWithConcurrency<T, R>(
+  items: T[],
+  concurrency: number,
+  worker: (item: T, index: number) => Promise<R> | R,
+): Promise<R[]> {
+  const limit = Math.max(1, Math.floor(concurrency));
+  if (items.length === 0) {
+    return [];
+  }
+
+  if (limit === 1) {
+    const sequential: R[] = [];
+    for (let index = 0; index < items.length; index++) {
+      sequential.push(await worker(items[index]!, index));
+    }
+    return sequential;
+  }
+
+  const results = new Array<R>(items.length);
+  let nextIndex = 0;
+
+  async function runWorker(): Promise<void> {
+    while (true) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= items.length) {
+        return;
+      }
+      results[index] = await worker(items[index]!, index);
+    }
+  }
+
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () =>
+    runWorker(),
+  );
+  await Promise.all(workers);
+  return results;
+}
+
+export class ConcurrencyTracker {
+  current = 0;
+  maxObserved = 0;
+
+  enter(): void {
+    this.current += 1;
+    if (this.current > this.maxObserved) {
+      this.maxObserved = this.current;
+    }
+  }
+
+  leave(): void {
+    this.current -= 1;
+  }
+}
+
+export async function runWithConcurrencyTracked<T, R>(
+  items: T[],
+  concurrency: number,
+  worker: (item: T, index: number) => Promise<R> | R,
+  tracker: ConcurrencyTracker,
+): Promise<R[]> {
+  const limit = Math.max(1, Math.floor(concurrency));
+
+  return runWithConcurrency(items, limit, async (item, index) => {
+    tracker.enter();
+    try {
+      return await worker(item, index);
+    } finally {
+      tracker.leave();
+    }
+  });
+}

package/src/forge/compiler/cache/store.ts

@@ -1,78 +1,78 @@
-import { join } from "node:path";
-import { nodeFileSystem } from "../fs/index.ts";
-import type { PackageApi } from "../types/package-graph.ts";
-import type { PackageCacheKey } from "../types/lock.ts";
-import { canonicalJson } from "../primitives/serialize.ts";
-import {
-  buildPackageCacheKey,
-  cacheKeysEqual,
-  fingerprintPackageCacheKey,
-  serializePackageCacheKey,
-} from "./key.ts";
-
-export interface CacheEntry {
-  key: PackageCacheKey;
-  result: PackageApi;
-}
-
-export class PackageCacheStore {
-  private readonly packagesDir: string;
-
-  constructor(cacheDir: string) {
-    this.packagesDir = join(cacheDir, "packages");
-    nodeFileSystem.mkdirp(this.packagesDir);
-  }
-
-  private entryPath(key: PackageCacheKey): string {
-    return join(this.packagesDir, `${fingerprintPackageCacheKey(key)}.json`);
-  }
-
-  getWithValidation(
-    key: PackageCacheKey,
-  ): { hit: PackageApi } | { miss: true } | { corrupt: true } {
-    const normalizedKey = buildPackageCacheKey(key);
-    const path = this.entryPath(normalizedKey);
-
-    const raw = nodeFileSystem.readText(path);
-    if (raw === null) {
-      return { miss: true };
-    }
-
-    let entry: CacheEntry;
-    try {
-      entry = JSON.parse(raw) as CacheEntry;
-    } catch {
-      return { corrupt: true };
-    }
-
-    if (!cacheKeysEqual(entry.key, normalizedKey)) {
-      return { corrupt: true };
-    }
-
-    return { hit: entry.result };
-  }
-
-  async put(key: PackageCacheKey, result: PackageApi): Promise<void> {
-    const normalizedKey = buildPackageCacheKey(key);
-    const path = this.entryPath(normalizedKey);
-
-    const entry: CacheEntry = {
-      key: normalizedKey,
-      result,
-    };
-
-    nodeFileSystem.writeText(path, serializeCacheEntry(entry));
-  }
-
-  serializeKey(key: PackageCacheKey): string {
-    return serializePackageCacheKey(key);
-  }
-}
-
-function serializeCacheEntry(entry: CacheEntry): string {
-  return `${canonicalJson(entry)}\n`;
-}
-
-export function forgeCacheDiscardedMessage(): string {
-  return "cache entry was discarded due to read or integrity failure; recomputing analysis";
-}
+import { join } from "node:path";
+import { nodeFileSystem } from "../fs/index.ts";
+import type { PackageApi } from "../types/package-graph.ts";
+import type { PackageCacheKey } from "../types/lock.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+import {
+  buildPackageCacheKey,
+  cacheKeysEqual,
+  fingerprintPackageCacheKey,
+  serializePackageCacheKey,
+} from "./key.ts";
+
+export interface CacheEntry {
+  key: PackageCacheKey;
+  result: PackageApi;
+}
+
+export class PackageCacheStore {
+  private readonly packagesDir: string;
+
+  constructor(cacheDir: string) {
+    this.packagesDir = join(cacheDir, "packages");
+    nodeFileSystem.mkdirp(this.packagesDir);
+  }
+
+  private entryPath(key: PackageCacheKey): string {
+    return join(this.packagesDir, `${fingerprintPackageCacheKey(key)}.json`);
+  }
+
+  getWithValidation(
+    key: PackageCacheKey,
+  ): { hit: PackageApi } | { miss: true } | { corrupt: true } {
+    const normalizedKey = buildPackageCacheKey(key);
+    const path = this.entryPath(normalizedKey);
+
+    const raw = nodeFileSystem.readText(path);
+    if (raw === null) {
+      return { miss: true };
+    }
+
+    let entry: CacheEntry;
+    try {
+      entry = JSON.parse(raw) as CacheEntry;
+    } catch {
+      return { corrupt: true };
+    }
+
+    if (!cacheKeysEqual(entry.key, normalizedKey)) {
+      return { corrupt: true };
+    }
+
+    return { hit: entry.result };
+  }
+
+  async put(key: PackageCacheKey, result: PackageApi): Promise<void> {
+    const normalizedKey = buildPackageCacheKey(key);
+    const path = this.entryPath(normalizedKey);
+
+    const entry: CacheEntry = {
+      key: normalizedKey,
+      result,
+    };
+
+    nodeFileSystem.writeText(path, serializeCacheEntry(entry));
+  }
+
+  serializeKey(key: PackageCacheKey): string {
+    return serializePackageCacheKey(key);
+  }
+}
+
+function serializeCacheEntry(entry: CacheEntry): string {
+  return `${canonicalJson(entry)}\n`;
+}
+
+export function forgeCacheDiscardedMessage(): string {
+  return "cache entry was discarded due to read or integrity failure; recomputing analysis";
+}

package/src/forge/compiler/classifier/capabilities.ts

@@ -1,78 +1,78 @@
-import type { CapabilitySet } from "../types/capability.ts";
-import type { IntegrationRecipe } from "../types/integration.ts";
-import type { PackageApi } from "../types/package-graph.ts";
-import { capability, emptyCapabilitySet } from "../recipes/helpers.ts";
-import { gatherSignals } from "./signals.ts";
-
-export function detectCapabilities(
-  api: PackageApi,
-  recipe?: IntegrationRecipe,
-): CapabilitySet {
-  if (recipe) {
-    return cloneCapabilitySet(recipe.capabilities);
-  }
-
-  const signals = gatherSignals(api);
-  const caps = emptyCapabilitySet();
-
-  if (signals.usesNetwork) {
-    caps.network = capability<{ egress?: string[] }>(
-      "required",
-      "static",
-      signals.networkEvidence,
-    );
-  } else {
-    caps.network = capability<{ egress?: string[] }>("unknown", "static", [
-      "static analysis cannot prove absence of network access",
-    ]);
-  }
-
-  if (signals.usesFilesystem) {
-    caps.filesystem = capability<{ read?: boolean; write?: boolean }>(
-      "required",
-      "static",
-      signals.filesystemEvidence,
-      {
-        read: true,
-        write: signals.filesystemEvidence.some((e) => /write/i.test(e)),
-      },
-    );
-  } else {
-    caps.filesystem = capability<{ read?: boolean; write?: boolean }>(
-      "unknown",
-      "static",
-      ["static analysis cannot prove absence of filesystem access"],
-    );
-  }
-
-  if (signals.usesProcess) {
-    caps.process = capability("required", "static", signals.processEvidence);
-  } else {
-    caps.process = capability("unknown", "static", [
-      "static analysis cannot prove absence of process access",
-    ]);
-  }
-
-  if (signals.usesNativeAddon) {
-    caps.nativeAddon = capability("required", "static", signals.nativeAddonEvidence);
-  } else {
-    caps.nativeAddon = capability("not-detected", "static", ["no native addon signals"]);
-  }
-
-  caps.lifecycleScripts = capability("not-detected", "rule", [
-    "forge add disables lifecycle scripts by default",
-  ]);
-
-  return caps;
-}
-
-function cloneCapabilitySet(source: CapabilitySet): CapabilitySet {
-  return {
-    network: { ...source.network },
-    filesystem: { ...source.filesystem },
-    process: { ...source.process },
-    nativeAddon: { ...source.nativeAddon },
-    lifecycleScripts: { ...source.lifecycleScripts },
-    secrets: [...source.secrets],
-  };
-}
+import type { CapabilitySet } from "../types/capability.ts";
+import type { IntegrationRecipe } from "../types/integration.ts";
+import type { PackageApi } from "../types/package-graph.ts";
+import { capability, emptyCapabilitySet } from "../recipes/helpers.ts";
+import { gatherSignals } from "./signals.ts";
+
+export function detectCapabilities(
+  api: PackageApi,
+  recipe?: IntegrationRecipe,
+): CapabilitySet {
+  if (recipe) {
+    return cloneCapabilitySet(recipe.capabilities);
+  }
+
+  const signals = gatherSignals(api);
+  const caps = emptyCapabilitySet();
+
+  if (signals.usesNetwork) {
+    caps.network = capability<{ egress?: string[] }>(
+      "required",
+      "static",
+      signals.networkEvidence,
+    );
+  } else {
+    caps.network = capability<{ egress?: string[] }>("unknown", "static", [
+      "static analysis cannot prove absence of network access",
+    ]);
+  }
+
+  if (signals.usesFilesystem) {
+    caps.filesystem = capability<{ read?: boolean; write?: boolean }>(
+      "required",
+      "static",
+      signals.filesystemEvidence,
+      {
+        read: true,
+        write: signals.filesystemEvidence.some((e) => /write/i.test(e)),
+      },
+    );
+  } else {
+    caps.filesystem = capability<{ read?: boolean; write?: boolean }>(
+      "unknown",
+      "static",
+      ["static analysis cannot prove absence of filesystem access"],
+    );
+  }
+
+  if (signals.usesProcess) {
+    caps.process = capability("required", "static", signals.processEvidence);
+  } else {
+    caps.process = capability("unknown", "static", [
+      "static analysis cannot prove absence of process access",
+    ]);
+  }
+
+  if (signals.usesNativeAddon) {
+    caps.nativeAddon = capability("required", "static", signals.nativeAddonEvidence);
+  } else {
+    caps.nativeAddon = capability("not-detected", "static", ["no native addon signals"]);
+  }
+
+  caps.lifecycleScripts = capability("not-detected", "rule", [
+    "forge add disables lifecycle scripts by default",
+  ]);
+
+  return caps;
+}
+
+function cloneCapabilitySet(source: CapabilitySet): CapabilitySet {
+  return {
+    network: { ...source.network },
+    filesystem: { ...source.filesystem },
+    process: { ...source.process },
+    nativeAddon: { ...source.nativeAddon },
+    lifecycleScripts: { ...source.lifecycleScripts },
+    secrets: [...source.secrets],
+  };
+}