@ronaldjdevfs/forge 1.0.1

package/skills/forge/scripts/bootstrap.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, renameSync } from "fs";
+import { join } from "path";
+import { buildContext } from "./context.mjs";
+import { detectProfile } from "./profile.mjs";
+
+const ROOT = process.cwd();
+const SRC = join(ROOT, "src");
+
+function isDir(path) {
+  try { return existsSync(path) && statSync(path).isDirectory(); }
+  catch { return false; }
+}
+
+function listDir(path) {
+  try { return readdirSync(path).filter(e => isDir(join(path, e))); }
+  catch { return []; }
+}
+
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+    return true;
+  }
+  return false;
+}
+
+function writeIndex(path, content = "") {
+  const indexFile = join(path, "index.ts");
+  if (!existsSync(indexFile)) {
+    writeFileSync(indexFile, content, "utf-8");
+  }
+}
+
+const PLATFORM_COMPONENTS = {
+  config: 'export * from "./config";\n',
+  database: 'export * from "./database";\n',
+  http: 'export * from "./http";\n',
+  server: 'export * from "./server";\n',
+  logger: 'export * from "./logger";\n',
+  cache: 'export * from "./cache";\n',
+  security: 'export * from "./security";\n',
+  events: 'export * from "./events";\n',
+  scheduler: 'export * from "./scheduler";\n',
+  observability: 'export * from "./observability";\n',
+  di: 'export * from "./di";\n',
+};
+
+const SHARED_COMPONENTS = {
+  errors: 'export * from "./errors";\n',
+  contracts: 'export * from "./contracts";\n',
+  types: 'export * from "./types";\n',
+  utils: 'export * from "./utils";\n',
+};
+
+function getProfileComponents(profile) {
+  const base = ["config", "server", "logger", "di"];
+
+  if (profile.includes("express") || profile.includes("fastify") || profile.includes("nestjs")) {
+    base.push("http");
+  }
+
+  if (profile.includes("prisma") || profile.includes("mongodb") || profile.includes("postgres") || profile.includes("pg")) {
+    base.push("database");
+  }
+
+  if (profile.includes("redis")) {
+    base.push("cache");
+  }
+
+  return [...new Set(base)];
+}
+
+export async function bootstrapPlatform(projectRoot = ROOT) {
+  const src = join(projectRoot, "src");
+  const ctx = await buildContext(projectRoot);
+  const profile = detectProfile(ctx);
+  const created = { platform: [], shared: [], infra: [] };
+
+  /* ── 1. Ensure src/ exists ── */
+  ensureDir(src);
+
+  /* ── 2. Platform Layer ── */
+  const platformDir = join(src, "platform");
+  const wasCreated = ensureDir(platformDir);
+
+  const profileComps = getProfileComponents(profile);
+  for (const comp of profileComps) {
+    const compDir = join(platformDir, comp);
+    if (ensureDir(compDir)) {
+      writeIndex(compDir, `// ${comp} — Platform Component\n`);
+      created.platform.push(comp);
+    }
+  }
+
+  if (wasCreated || created.platform.length > 0) {
+    writeIndex(platformDir);
+  }
+
+  /* ── 3. Shared Layer ── */
+  const sharedDir = join(src, "shared");
+  if (ensureDir(sharedDir)) {
+    for (const [comp, content] of Object.entries(SHARED_COMPONENTS)) {
+      const compDir = join(sharedDir, comp);
+      if (ensureDir(compDir)) {
+        writeIndex(compDir, `// ${comp} — Shared Component\n`);
+        created.shared.push(comp);
+      }
+    }
+    writeIndex(sharedDir);
+  }
+
+  /* ── 4. Infra Layer ── */
+  const infraDir = join(src, "infra");
+  if (ensureDir(infraDir)) {
+    if (profile.includes("prisma")) {
+      const prismaDir = join(infraDir, "prisma");
+      if (ensureDir(prismaDir)) {
+        writeIndex(prismaDir, "// Prisma — ORM\n");
+        created.infra.push("prisma");
+      }
+    }
+    if (profile.includes("mongodb") || profile.includes("mongoose")) {
+      const mongoDir = join(infraDir, "mongodb");
+      if (ensureDir(mongoDir)) {
+        writeIndex(mongoDir, "// MongoDB — Database\n");
+        created.infra.push("mongodb");
+      }
+    }
+    if (profile.includes("redis")) {
+      const redisDir = join(infraDir, "redis");
+      if (ensureDir(redisDir)) {
+        writeIndex(redisDir, "// Redis — Cache/Queue\n");
+        created.infra.push("redis");
+      }
+    }
+    writeIndex(infraDir);
+  }
+
+  /* ── 5. Organize existing orphan dirs ── */
+  const orphanDirs = listDir(src).filter(d =>
+    !["platform", "features", "shared", "infra", "infrastructure", "core", "lib", "adapters", "application", "domain", "setting"].includes(d)
+    && !d.startsWith(".")
+  );
+
+  for (const dir of orphanDirs) {
+    const srcPath = join(src, dir);
+    if (!isDir(srcPath)) continue;
+
+    const lower = dir.toLowerCase();
+    let target = null;
+
+    if (["config", "database", "http", "server", "logger", "cache", "security", "events", "di", "middleware"].includes(lower)) {
+      target = join(platformDir, lower);
+    } else if (["errors", "contracts", "types", "utils", "helpers", "constants", "enums"].includes(lower)) {
+      target = join(sharedDir, lower);
+    } else if (["prisma", "mongodb", "postgres", "redis", "mail", "s3", "stripe", "queue"].includes(lower)) {
+      target = join(infraDir, lower);
+    }
+
+    if (target && !existsSync(target)) {
+      try {
+        renameSync(srcPath, target);
+        console.log(`  → Movido ${dir}/ → ${target.replace(projectRoot + "/", "")}`);
+      } catch (e) {
+        console.log(`  ⚠ No se pudo mover ${dir}/: ${e.message}`);
+      }
+    }
+  }
+
+  return { created, profile, hasPlatform: isDir(platformDir), hasShared: isDir(sharedDir), hasInfra: isDir(infraDir) };
+}
+
+async function main() {
+  console.log("\n  Bootstrap — Platform Initialization\n");
+  const result = await bootstrapPlatform();
+  console.log(`  Profile: ${result.profile}`);
+  console.log(`  Platform: ${result.created.platform.join(", ") || "(existing)"}`);
+  console.log(`  Shared: ${result.created.shared.join(", ") || "(existing)"}`);
+  console.log(`  Infra: ${result.created.infra.join(", ") || "(existing)"}`);
+  console.log();
+}
+
+if (process.argv[1] && (process.argv[1].endsWith("bootstrap.mjs") || process.argv[1].endsWith("bootstrap.js"))) {
+  main().catch(console.error);
+}

package/skills/forge/scripts/chain.mjs

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+
+import { buildGraph } from "./graph.mjs";
+
+export function buildDependencyGraph(projectRoot) {
+  const graph = buildGraph(projectRoot);
+
+  const layers = {
+    platform: [],
+    features: [],
+    shared: [],
+    infra: [],
+  };
+
+  for (const n of graph.nodes) {
+    if (n.type === "platform") layers.platform.push(n);
+    else if (n.type === "feature") layers.features.push(n);
+    else if (n.type === "shared") layers.shared.push(n);
+    else if (n.type === "infra") layers.infra.push(n);
+  }
+
+  /* Layer-specific edges (excluding violations) */
+  function layerEdges(type) {
+    return graph.edges.filter(e =>
+      e.type !== "violates" &&
+      e.from.startsWith(`${type}:`) &&
+      e.to.startsWith(`${type}:`)
+    );
+  }
+
+  const platformEdges = layerEdges("platform");
+  const featureEdges = layerEdges("feature");
+  const sharedEdges = layerEdges("shared");
+  const infraEdges = layerEdges("infra");
+
+  /* Topological sort helper */
+  function topoSort(nodes, edges) {
+    const adj = {};
+    const inDegree = {};
+    const ids = nodes.map(n => n.id);
+    for (const id of ids) {
+      adj[id] = [];
+      inDegree[id] = 0;
+    }
+    for (const e of edges) {
+      if (adj[e.from]) {
+        adj[e.from].push(e.to);
+        inDegree[e.to] = (inDegree[e.to] || 0) + 1;
+      }
+    }
+    const queue = ids.filter(id => inDegree[id] === 0);
+    const order = [];
+    while (queue.length > 0) {
+      const node = queue.shift();
+      order.push(node);
+      for (const nb of adj[node] || []) {
+        inDegree[nb]--;
+        if (inDegree[nb] === 0) queue.push(nb);
+      }
+    }
+    return {
+      order,
+      hasCycles: order.length < ids.length,
+      cycleFree: order.length === ids.length,
+    };
+  }
+
+  const featTopo = topoSort(layers.features, featureEdges);
+  const platTopo = layers.platform.length > 0
+    ? topoSort(layers.platform, platformEdges)
+    : { order: [], hasCycles: false, cycleFree: true };
+  const sharedTopo = layers.shared.length > 0
+    ? topoSort(layers.shared, sharedEdges)
+    : { order: [], hasCycles: false, cycleFree: true };
+  const infraTopo = layers.infra.length > 0
+    ? topoSort(layers.infra, infraEdges)
+    : { order: [], hasCycles: false, cycleFree: true };
+
+  /* Global cycle detection across all layers */
+  const globalEdges = graph.edges.filter(e => e.type !== "violates");
+  const globalAdj = {};
+  const allIds = [...new Set(globalEdges.flatMap(e => [e.from, e.to]))];
+  for (const id of allIds) globalAdj[id] = [];
+  for (const e of globalEdges) {
+    if (globalAdj[e.from]) globalAdj[e.from].push(e.to);
+  }
+
+  let hasGlobalCycle = false;
+  function dfs(node, visited, stack) {
+    if (stack.has(node)) return true;
+    if (visited.has(node)) return false;
+    visited.add(node);
+    stack.add(node);
+    for (const nb of globalAdj[node] || []) {
+      if (dfs(nb, visited, stack)) return true;
+    }
+    stack.delete(node);
+    return false;
+  }
+  const gVisited = new Set();
+  for (const n of allIds) {
+    if (hasGlobalCycle) break;
+    if (!gVisited.has(n)) {
+      if (dfs(n, gVisited, new Set())) hasGlobalCycle = true;
+    }
+  }
+
+  /* Illegal chains (transitive violations) */
+  const illegalChains = [];
+  const allowedDirections = {
+    feature: ["platform", "shared", "domain"],
+    platform: ["infra", "shared"],
+    shared: [],
+    infra: [],
+    domain: ["shared"],
+    adapter: ["domain", "infra", "platform", "shared"],
+  };
+
+  for (const e of graph.edges) {
+    if (e.type === "violates") continue;
+    const fromType = e.from.split(":")[0];
+    const toType = e.to.split(":")[0];
+    if (!allowedDirections[fromType]) continue;
+    if (!allowedDirections[fromType].includes(toType)) {
+      illegalChains.push({
+        from: e.from,
+        to: e.to,
+        type: e.type,
+        file: e.file,
+        reason: `${fromType} → ${toType} no es una dirección permitida`,
+      });
+    }
+  }
+
+  /* Isolated components (no edges at all) */
+  const connected = new Set();
+  for (const e of graph.edges) {
+    connected.add(e.from);
+    connected.add(e.to);
+  }
+  const isolated = graph.nodes.filter(n => !connected.has(n.id));
+
+  /* Format feature edges as simple source/target (backward compat) */
+  const simpleFeatEdges = featureEdges.map(e => ({
+    source: e.from.replace("feature:", ""),
+    target: e.to.replace("feature:", ""),
+    file: e.file,
+  }));
+
+  const allFeatIds = [...new Set([
+    ...simpleFeatEdges.map(e => e.source),
+    ...simpleFeatEdges.map(e => e.target),
+    ...layers.features.map(n => n.id.replace("feature:", "")),
+  ])];
+
+  return {
+    nodes: allFeatIds.map(id => ({ id, type: "feature" })),
+    edges: simpleFeatEdges,
+    features: allFeatIds,
+    topologicalOrder: featTopo.order,
+    hasCycles: featTopo.hasCycles,
+    cycleFree: featTopo.cycleFree,
+    layers: {
+      platform: {
+        nodes: layers.platform.map(n => n.id),
+        edges: platformEdges,
+        order: platTopo.order,
+        hasCycles: platTopo.hasCycles,
+      },
+      features: {
+        nodes: allFeatIds,
+        edges: simpleFeatEdges,
+        order: featTopo.order,
+        hasCycles: featTopo.hasCycles,
+      },
+      shared: {
+        nodes: layers.shared.map(n => n.id),
+        edges: sharedEdges,
+        order: sharedTopo.order,
+        hasCycles: sharedTopo.hasCycles,
+      },
+      infra: {
+        nodes: layers.infra.map(n => n.id),
+        edges: infraEdges,
+        order: infraTopo.order,
+        hasCycles: infraTopo.hasCycles,
+      },
+    },
+    globalCycles: hasGlobalCycle,
+    illegalChains,
+    isolated: isolated.map(n => n.id),
+    graph,
+  };
+}
+
+async function main() {
+  const depGraph = buildDependencyGraph();
+  const args = process.argv.slice(2);
+  if (args.includes("--json")) {
+    console.log(JSON.stringify(depGraph, null, 2));
+  } else {
+    console.log("## Chain — Multi-layer Dependency Analysis\n");
+    console.log(`### Features (${depGraph.features.length})`);
+    console.log(`  Order: ${depGraph.topologicalOrder.join(" → ") || "(none)"}`);
+    console.log(`  Cycles: ${depGraph.hasCycles ? "YES ⚠" : "None ✓"}`);
+    console.log();
+
+    console.log(`### Platform (${depGraph.layers.platform.nodes.length})`);
+    if (depGraph.layers.platform.nodes.length > 0) {
+      console.log(`  Order: ${depGraph.layers.platform.order.join(" → ") || "(independent)"}`);
+      console.log(`  Cycles: ${depGraph.layers.platform.hasCycles ? "YES ⚠" : "None ✓"}`);
+    } else {
+      console.log("  (none detected)");
+    }
+    console.log();
+
+    console.log(`### Shared (${depGraph.layers.shared.nodes.length})`);
+    if (depGraph.layers.shared.nodes.length > 0) {
+      console.log(`  Cycles: ${depGraph.layers.shared.hasCycles ? "YES ⚠" : "None ✓"}`);
+    } else {
+      console.log("  (none detected)");
+    }
+    console.log();
+
+    console.log(`### Infra (${depGraph.layers.infra.nodes.length})`);
+    if (depGraph.layers.infra.nodes.length > 0) {
+      console.log(`  Cycles: ${depGraph.layers.infra.hasCycles ? "YES ⚠" : "None ✓"}`);
+    } else {
+      console.log("  (none detected)");
+    }
+    console.log();
+
+    console.log(`### Global Cycles: ${depGraph.globalCycles ? "YES ⚠" : "None ✓"}`);
+    console.log();
+
+    if (depGraph.illegalChains.length > 0) {
+      console.log("### Illegal Chains");
+      for (const c of depGraph.illegalChains) {
+        console.log(`  ⚠ ${c.from} → ${c.to} (${c.reason})${c.file ? ` — ${c.file}` : ""}`);
+      }
+      console.log();
+    }
+
+    if (depGraph.isolated.length > 0) {
+      console.log("### Isolated Components");
+      for (const id of depGraph.isolated) {
+        console.log(`  ○ ${id}`);
+      }
+      console.log();
+    }
+  }
+}
+
+if (process.argv[1] && (process.argv[1].endsWith("chain.mjs") || process.argv[1].endsWith("chain.js"))) {
+  main().catch(console.error);
+}
+
+

package/skills/forge/scripts/context.mjs

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, basename } from "path";
+import { buildGraph } from "./graph.mjs";
+import { buildOwnershipReport } from "./armorer.mjs";
+
+const ROOT = process.cwd();
+const SRC = join(ROOT, "src");
+const FEATURES = join(SRC, "features");
+
+const PLATFORM_KNOWN = ["config", "database", "http", "server", "logger", "cache", "security", "events", "scheduler", "observability", "di"];
+const SHARED_KNOWN = ["errors", "contracts", "types", "utils", "helpers", "constants", "enums"];
+const INFRA_KNOWN = ["prisma", "mongodb", "postgres", "redis", "mail", "s3", "cloudinary", "stripe", "sqs", "rabbitmq", "kafka", "smtp"];
+
+function read(path) {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function exists(path) {
+  return existsSync(path);
+}
+
+function isDir(path) {
+  return existsSync(path) && statSync(path).isDirectory();
+}
+
+function listDir(path) {
+  try {
+    return readdirSync(path);
+  } catch {
+    return [];
+  }
+}
+
+function detectFramework(pkg) {
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deps["@nestjs/core"]) return "NestJS";
+  if (deps.fastify) return "Fastify";
+  if (deps.express) return "Express";
+  return "unknown";
+}
+
+function detectDatabase(pkg) {
+  const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+  if (deps.some((d) => d.includes("mongodb") || d === "mongoose")) return "MongoDB";
+  if (deps.includes("pg") || deps.includes("postgres")) return "PostgreSQL";
+  if (deps.includes("mysql") || deps.includes("mysql2")) return "MySQL";
+  if (deps.includes("sqlite3") || deps.includes("better-sqlite3")) return "SQLite";
+  return "unknown";
+}
+
+function detectOrm(pkg) {
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deps.mongoose) return "Mongoose";
+  if (deps["@prisma/client"] || deps.prisma) return "Prisma";
+  if (deps["typeorm"]) return "TypeORM";
+  if (deps["drizzle-orm"]) return "Drizzle";
+  if (deps["pg"] || deps["mysql2"]) return "native";
+  return "none";
+}
+
+function detectDI(pkg) {
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (deps["tsyringe"]) return "tsyringe";
+  if (deps["@nestjs/core"]) return "framework";
+  if (deps["typedi"]) return "typedi";
+  if (deps["awilix"]) return "awilix";
+  return "manual";
+}
+
+function detectFeatures() {
+  if (!isDir(FEATURES)) return [];
+  return listDir(FEATURES).filter((f) => isDir(join(FEATURES, f)));
+}
+
+function detectLegacyFeatures() {
+  const legacy = [];
+  const ucBase = join(SRC, "application", "use-cases");
+  const ctrlDir = join(SRC, "adapters", "in", "http", "controllers");
+
+  const seen = new Set();
+  for (const sub of listDir(ucBase)) {
+    if (isDir(join(ucBase, sub))) {
+      legacy.push(sub);
+      seen.add(sub);
+    }
+  }
+  for (const file of listDir(ctrlDir)) {
+    const m = file.match(/^(.+)\.controller\.(ts|js)$/);
+    if (m && !seen.has(m[1])) {
+      legacy.push(m[1]);
+      seen.add(m[1]);
+    }
+  }
+
+  return legacy;
+}
+
+function detectPlatform() {
+  const platformDir = join(SRC, "platform");
+  if (!isDir(platformDir)) return { components: [], exists: false };
+  const components = listDir(platformDir).filter((d) => isDir(join(platformDir, d)) || d.endsWith(".ts") || d.endsWith(".js"));
+  const known = components.filter((c) => PLATFORM_KNOWN.includes(c.replace(/\.(ts|js)$/, "")));
+  const unknown = components.filter((c) => !PLATFORM_KNOWN.includes(c.replace(/\.(ts|js)$/, "")));
+  return { components, exists: true, known, unknown };
+}
+
+function detectShared() {
+  const sharedDir = join(SRC, "shared");
+  if (!isDir(sharedDir)) return { components: [], exists: false };
+  const components = listDir(sharedDir).filter((d) => isDir(join(sharedDir, d)) || d.endsWith(".ts") || d.endsWith(".js"));
+  const known = components.filter((c) => SHARED_KNOWN.includes(c.replace(/\.(ts|js)$/, "")));
+  const unknown = components.filter((c) => !SHARED_KNOWN.includes(c.replace(/\.(ts|js)$/, "")));
+  return { components, exists: true, known, unknown };
+}
+
+function detectInfra() {
+  const infraDir = join(SRC, "infra");
+  const infraDir2 = join(SRC, "infrastructure");
+  const dir = isDir(infraDir) ? infraDir : isDir(infraDir2) ? infraDir2 : null;
+  if (!dir) return { components: [], exists: false };
+  const components = listDir(dir).filter((d) => isDir(join(dir, d)) || d.endsWith(".ts") || d.endsWith(".js"));
+  const known = components.filter((c) => INFRA_KNOWN.includes(c.replace(/\.(ts|js)$/, "")));
+  const unknown = components.filter((c) => !INFRA_KNOWN.includes(c.replace(/\.(ts|js)$/, "")));
+  return { components, exists: true, known, unknown };
+}
+
+function detectOrphans() {
+  const report = buildOwnershipReport();
+  return report.orphans;
+}
+
+function stripJsonComments(raw) {
+  const lines = raw.split("\n");
+  const out = [];
+  for (let line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("/*") && trimmed.endsWith("*/")) continue;
+    const slashSlash = trimmed.indexOf("//");
+    if (slashSlash === 0) continue;
+    const ci = line.indexOf("/*");
+    if (ci > 0 && line.slice(ci).trim().endsWith("*/")) {
+      out.push(line.slice(0, ci));
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n").replace(/,\s*([}\]])/g, "$1");
+}
+
+function readJson(path) {
+  const raw = read(path);
+  if (!raw) return null;
+  try {
+    return JSON.parse(stripJsonComments(raw));
+  } catch {
+    return null;
+  }
+}
+
+export async function buildContext(projectRoot = ROOT) {
+  const root = projectRoot;
+  const src = join(root, "src");
+
+  const pkg = readJson(join(root, "package.json")) || {};
+  const tsconfig = readJson(join(root, "tsconfig.json"));
+
+  const framework = detectFramework(pkg);
+  const database = detectDatabase(pkg);
+  const orm = detectOrm(pkg);
+  const diStrategy = detectDI(pkg);
+
+  const hasDecorators =
+    tsconfig?.compilerOptions?.experimentalDecorators === true;
+  const hasDecoratorMetadata =
+    tsconfig?.compilerOptions?.emitDecoratorMetadata === true;
+
+  const migratedFeatures = detectFeatures();
+  const legacyFeatures = detectLegacyFeatures();
+  const platform = detectPlatform();
+  const shared = detectShared();
+  const infra = detectInfra();
+  const orphans = detectOrphans();
+  const graph = buildGraph(root);
+  const ownership = buildOwnershipReport(root);
+
+  const hasFeatures = migratedFeatures.length > 0;
+  const hasLegacy = legacyFeatures.length > 0;
+
+  return {
+    projectName: basename(root),
+    framework,
+    runtime: `Node ${process.version}`,
+    database,
+    orm,
+    diStrategy,
+    tsconfig: {
+      experimentalDecorators: hasDecorators,
+      emitDecoratorMetadata: hasDecoratorMetadata,
+    },
+    platform,
+    shared,
+    infra,
+    features: {
+      migrated: migratedFeatures,
+      legacy: legacyFeatures,
+      total: migratedFeatures.length + legacyFeatures.length,
+    },
+    orphans,
+    ownership,
+    hasSrc: isDir(src),
+    hasFeaturesDir: isDir(join(src, "features")),
+    hasPlatformDir: platform.exists,
+    hasSharedDir: shared.exists,
+    hasInfraDir: infra.exists,
+    isMigrating: hasLegacy && hasFeatures,
+    isFullyMigrated: hasFeatures && !hasLegacy,
+    isLegacy: hasLegacy && !hasFeatures,
+    isGreenfield: !hasLegacy && !hasFeatures && isDir(src),
+    graph,
+    dependencies: {},
+  };
+}
+
+async function main() {
+  const ctx = await buildContext();
+  console.log(JSON.stringify(ctx, null, 2));
+}
+
+if (process.argv[1] && (process.argv[1].endsWith("context.mjs") || process.argv[1].endsWith("context.js"))) {
+  main().catch(console.error);
+}