forgeos 0.1.0-alpha.69 → 0.1.0-alpha.70

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

@@ -1,4 +1,4 @@
-import type { CapabilitySet } from "../types/capability.ts";
+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";
@@ -14,66 +14,66 @@ export function detectCapabilities(
   }
 
   const signals = precomputedSignals ?? 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],
-  };
-}
+  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],
+  };
+}

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

@@ -1,32 +1,32 @@
-import type { CapabilitySet, SecretRequirement } from "../types/capability.ts";
-import type { RuntimeClassification } from "../types/classification.ts";
-import type { ExportClassification } from "../types/package-graph.ts";
-import type { IntegrationRecipe } from "../types/integration.ts";
-import type { PackageApi } from "../types/package-graph.ts";
-import { compareBytes } from "../primitives/compare.ts";
-import { resolveByPackageName } from "../recipes/registry.ts";
+import type { CapabilitySet, SecretRequirement } from "../types/capability.ts";
+import type { RuntimeClassification } from "../types/classification.ts";
+import type { ExportClassification } from "../types/package-graph.ts";
+import type { IntegrationRecipe } from "../types/integration.ts";
+import type { PackageApi } from "../types/package-graph.ts";
+import { compareBytes } from "../primitives/compare.ts";
+import { resolveByPackageName } from "../recipes/registry.ts";
 import { detectCapabilities } from "./capabilities.ts";
 import { partitionContexts } from "./contexts.ts";
 import { detectSecrets } from "./secrets.ts";
 import { gatherSignals, type PackageSignals } from "./signals.ts";
-
-export interface RuntimeClassifier {
-  classify(api: PackageApi, recipe?: IntegrationRecipe): RuntimeClassification;
-  detectCapabilities(api: PackageApi, recipe?: IntegrationRecipe): CapabilitySet;
-  detectSecrets(api: PackageApi, recipe?: IntegrationRecipe): SecretRequirement[];
-}
-
-function resolveRecipeForApi(
-  api: PackageApi,
-  recipe?: IntegrationRecipe,
-): IntegrationRecipe | undefined {
-  return recipe ?? resolveByPackageName(api.name) ?? undefined;
-}
-
-function classifyExport(
-  api: PackageApi,
-  entrypoint: string,
-  exportName: string,
+
+export interface RuntimeClassifier {
+  classify(api: PackageApi, recipe?: IntegrationRecipe): RuntimeClassification;
+  detectCapabilities(api: PackageApi, recipe?: IntegrationRecipe): CapabilitySet;
+  detectSecrets(api: PackageApi, recipe?: IntegrationRecipe): SecretRequirement[];
+}
+
+function resolveRecipeForApi(
+  api: PackageApi,
+  recipe?: IntegrationRecipe,
+): IntegrationRecipe | undefined {
+  return recipe ?? resolveByPackageName(api.name) ?? undefined;
+}
+
+function classifyExport(
+  api: PackageApi,
+  entrypoint: string,
+  exportName: string,
   recipe: IntegrationRecipe | undefined,
   caps: CapabilitySet,
   alias: string,
@@ -35,24 +35,24 @@ function classifyExport(
   const { compatible, incompatible } = partitionContexts(
     recipe,
     caps,
-    signals,
-    api.name,
-  );
-
-  return {
-    alias,
-    packageName: api.name,
-    entrypoint,
-    exportName,
-    compatible,
-    incompatible,
-    capabilities: caps,
-  };
-}
-
-export function classify(
-  api: PackageApi,
-  recipe?: IntegrationRecipe,
+    signals,
+    api.name,
+  );
+
+  return {
+    alias,
+    packageName: api.name,
+    entrypoint,
+    exportName,
+    compatible,
+    incompatible,
+    capabilities: caps,
+  };
+}
+
+export function classify(
+  api: PackageApi,
+  recipe?: IntegrationRecipe,
 ): RuntimeClassification {
   const resolvedRecipe = resolveRecipeForApi(api, recipe);
   const signals = gatherSignals(api);
@@ -62,17 +62,17 @@ export function classify(
     secrets: detectSecrets(api, resolvedRecipe, signals),
   };
   const alias = resolvedRecipe?.alias ?? api.name;
-
-  const { compatible, incompatible, rationale } = partitionContexts(
-    resolvedRecipe,
-    capsWithSecrets,
-    signals,
-    api.name,
-  );
-
-  const perEntrypoint: ExportClassification[] = [];
-  for (const ep of api.entrypoints) {
-    for (const exp of ep.exports) {
+
+  const { compatible, incompatible, rationale } = partitionContexts(
+    resolvedRecipe,
+    capsWithSecrets,
+    signals,
+    api.name,
+  );
+
+  const perEntrypoint: ExportClassification[] = [];
+  for (const ep of api.entrypoints) {
+    for (const exp of ep.exports) {
       perEntrypoint.push(
         classifyExport(
           api,
@@ -113,25 +113,25 @@ export function classify(
       ),
     );
   }
-
-  perEntrypoint.sort((a, b) => {
-    const ep = compareBytes(a.entrypoint, b.entrypoint);
-    if (ep !== 0) return ep;
-    return compareBytes(a.exportName, b.exportName);
-  });
-
-  return {
-    compatible,
-    incompatible,
-    rationale,
-    perEntrypoint,
-  };
-}
-
-export function createRuntimeClassifier(): RuntimeClassifier {
-  return {
-    classify,
-    detectCapabilities,
-    detectSecrets,
-  };
-}
+
+  perEntrypoint.sort((a, b) => {
+    const ep = compareBytes(a.entrypoint, b.entrypoint);
+    if (ep !== 0) return ep;
+    return compareBytes(a.exportName, b.exportName);
+  });
+
+  return {
+    compatible,
+    incompatible,
+    rationale,
+    perEntrypoint,
+  };
+}
+
+export function createRuntimeClassifier(): RuntimeClassifier {
+  return {
+    classify,
+    detectCapabilities,
+    detectSecrets,
+  };
+}