@tyyyho/treg 0.1.2 → 0.1.6

package/dist/init-project/mrm-rules/ai-skills.js

@@ -0,0 +1,200 @@
+import { existsSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const START_MARKER = "<!-- treg:skills:start -->";
+const END_MARKER = "<!-- treg:skills:end -->";
+const SKILLS_BASE_DIR = "skills";
+const FEATURE_SKILLS = {
+    format: {
+        name: "treg/format",
+        description: "Run and verify formatting rules.",
+        when: "在提交前或大範圍改動後，統一格式化程式碼。",
+        checklist: ["執行 format", "執行 format:check", "確認未變動非目標檔案"],
+    },
+    husky: {
+        name: "treg/husky",
+        description: "Verify and maintain git hook automation.",
+        when: "需要保證 pre-commit / pre-push 自動檢查時。",
+        checklist: [
+            "確認 hooks 可執行",
+            "確認含 format:check 與 lint:check",
+            "若啟用型別/測試，也要納入 hooks",
+        ],
+    },
+    lint: {
+        name: "treg/lint",
+        description: "Run and validate lint rules.",
+        when: "新增規則或調整工具鏈後，驗證 lint 一致性。",
+        checklist: ["執行 lint", "執行 lint:check", "修正 max-warnings 問題"],
+    },
+    test: {
+        name: "treg/test",
+        description: "Validate test runner setup and execution.",
+        when: "新增測試規則或調整測試設定時。",
+        checklist: [
+            "確認 test runner 與專案一致",
+            "執行 test",
+            "視需要執行 test:coverage",
+        ],
+    },
+    typescript: {
+        name: "treg/typescript",
+        description: "Validate TypeScript strictness and config.",
+        when: "調整 tsconfig 或型別嚴格度規則時。",
+        checklist: [
+            "執行 type-check",
+            "確認 strict 相關選項仍生效",
+            "檢查 exclude 不含產品邏輯路徑",
+        ],
+    },
+};
+const FEATURE_STEP_LABELS = {
+    format: "格式處理",
+    husky: "Git hook 維護",
+    lint: "Lint 規則檢查",
+    test: "測試規則調整",
+    typescript: "TypeScript 型別與設定",
+};
+function resolveSkillsDoc(projectDir) {
+    const agentsPath = path.join(projectDir, "AGENTS.md");
+    if (existsSync(agentsPath)) {
+        return agentsPath;
+    }
+    const claudePath = path.join(projectDir, "CLAUDE.md");
+    if (existsSync(claudePath)) {
+        return claudePath;
+    }
+    return null;
+}
+function getEnabledFeatures(enabledFeatures) {
+    return Object.entries(enabledFeatures)
+        .filter(([, value]) => value)
+        .map(([name]) => name)
+        .sort((a, b) => a.localeCompare(b));
+}
+function getSkillRelativePath(feature) {
+    return `${SKILLS_BASE_DIR}/${feature}/SKILL.md`;
+}
+function buildSkillFile(feature, skill, testRunner) {
+    const extra = feature === "test"
+        ? `\n## Current Test Runner\n\n- \`${testRunner}\`\n`
+        : "";
+    return `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+# ${skill.name}
+
+## When To Use
+
+${skill.when}
+
+## Validation Checklist
+
+- ${skill.checklist.join("\n- ")}
+${extra}`;
+}
+async function ensureSkillFiles(projectDir, enabled, testRunner, dryRun) {
+    for (const feature of enabled) {
+        const skill = FEATURE_SKILLS[feature];
+        if (!skill)
+            continue;
+        const relativePath = getSkillRelativePath(feature);
+        const fullPath = path.join(projectDir, relativePath);
+        const content = buildSkillFile(feature, skill, testRunner);
+        if (dryRun) {
+            console.log(`[dry-run] Would upsert ${relativePath}`);
+            continue;
+        }
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        const current = existsSync(fullPath)
+            ? await fs.readFile(fullPath, "utf8")
+            : null;
+        if (current === content) {
+            continue;
+        }
+        await fs.writeFile(fullPath, content, "utf8");
+        console.log(`${current === null ? "Created" : "Updated"} ${relativePath}`);
+    }
+}
+function buildSkillSection(context) {
+    const { enabledFeatures, testRunner } = context;
+    const enabled = getEnabledFeatures(enabledFeatures);
+    const lines = [
+        START_MARKER,
+        "## treg AI Skills",
+        "",
+        "### 執行步驟與 Skill 對應",
+        "",
+    ];
+    if (enabled.length === 0) {
+        lines.push("1. 本次未啟用任何 feature，無需呼叫 skill。");
+        lines.push("");
+        lines.push(END_MARKER);
+        lines.push("");
+        return lines.join("\n");
+    }
+    enabled.forEach((feature, index) => {
+        const skill = FEATURE_SKILLS[feature];
+        if (!skill)
+            return;
+        const skillRelativePath = getSkillRelativePath(feature);
+        const stepLabel = FEATURE_STEP_LABELS[feature] ?? feature;
+        lines.push(`${index + 1}. ${stepLabel}：呼叫 [${skill.name}](${skillRelativePath})`);
+        if (feature === "test") {
+            lines.push(`   - 目前測試工具：\`${testRunner}\``);
+        }
+    });
+    lines.push("");
+    lines.push(END_MARKER);
+    lines.push("");
+    return lines.join("\n");
+}
+function upsertSkillSection(content, nextSection) {
+    const start = content.indexOf(START_MARKER);
+    const end = content.indexOf(END_MARKER);
+    if (start !== -1 && end !== -1 && end > start) {
+        const suffixStart = end + END_MARKER.length;
+        const before = content.slice(0, start).trimEnd();
+        const after = content.slice(suffixStart).trimStart();
+        const rebuilt = `${before}\n\n${nextSection.trim()}\n`;
+        return after ? `${rebuilt}\n${after}\n` : `${rebuilt}`;
+    }
+    if (!content.trim()) {
+        return `${nextSection.trim()}\n`;
+    }
+    return `${content.trimEnd()}\n\n${nextSection.trim()}\n`;
+}
+export async function runAiSkillsRule(context) {
+    const { projectDir, dryRun } = context;
+    const targetFile = resolveSkillsDoc(projectDir);
+    if (!targetFile) {
+        console.log("Skip ai-skills (AGENTS.md/CLAUDE.md not found)");
+        return;
+    }
+    const enabled = getEnabledFeatures(context.enabledFeatures);
+    await ensureSkillFiles(projectDir, enabled, context.testRunner, dryRun);
+    const section = buildSkillSection(context);
+    const current = await fs.readFile(targetFile, "utf8");
+    const updated = upsertSkillSection(current, section);
+    if (dryRun) {
+        console.log(`[dry-run] Would update ${path.basename(targetFile)} with AI skill guidance`);
+        return;
+    }
+    if (updated !== current) {
+        await fs.writeFile(targetFile, updated, "utf8");
+        console.log(`Updated ${path.basename(targetFile)} with AI skill guidance`);
+        return;
+    }
+    console.log(`${path.basename(targetFile)} already contains latest AI skill guidance`);
+}
+export const __testables__ = {
+    buildSkillSection,
+    buildSkillFile,
+    ensureSkillFiles,
+    getEnabledFeatures,
+    getSkillRelativePath,
+    resolveSkillsDoc,
+    upsertSkillSection,
+};

package/dist/init-project/mrm-rules/format.js

@@ -0,0 +1,44 @@
+import { lines, packageJson } from "../mrm-core.js";
+import { installPackages, withProjectCwd, writeFile } from "./shared.js";
+const PRETTIER_CONFIG = `{
+  "semi": false,
+  "trailingComma": "es5",
+  "singleQuote": false,
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "bracketSpacing": true,
+  "arrowParens": "avoid",
+  "endOfLine": "lf"
+}
+`;
+const PRETTIER_IGNORE = [
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    "coverage",
+    "*.log",
+    ".env*",
+    ".vercel",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock",
+];
+export async function runFormatRule(context) {
+    const { projectDir, pm, force, dryRun } = context;
+    installPackages(projectDir, pm, ["prettier"], true, dryRun);
+    await writeFile(projectDir, ".prettierrc.json", PRETTIER_CONFIG, force, dryRun);
+    withProjectCwd(projectDir, () => {
+        if (dryRun) {
+            console.log("[dry-run] Would update .prettierignore");
+            console.log("[dry-run] Would set package scripts: format, format:check");
+            return;
+        }
+        lines(".prettierignore").add(PRETTIER_IGNORE).save();
+        packageJson()
+            .setScript("format", "prettier --write .")
+            .setScript("format:check", "prettier --check .")
+            .save();
+    });
+}

package/dist/init-project/mrm-rules/husky.js

@@ -0,0 +1,61 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { packageJson } from "../mrm-core.js";
+import { existsSync } from "node:fs";
+import { getRunCommand, runCommand } from "../package-manager.js";
+import { installPackages, withProjectCwd, writeFile } from "./shared.js";
+function buildHookCommands(runner, enabledFeatures) {
+    const preCommit = [
+        `${runner} format:check || exit 1`,
+        `${runner} lint:check || exit 1`,
+    ];
+    if (enabledFeatures.typescript) {
+        preCommit.push(`${runner} type-check || exit 1`);
+    }
+    const prePush = [...preCommit];
+    if (enabledFeatures.test) {
+        prePush.push(`${runner} test || exit 1`);
+    }
+    return { preCommit, prePush };
+}
+export async function runHuskyRule(context) {
+    const { projectDir, pm, force, dryRun, skipHuskyInstall, enabledFeatures } = context;
+    installPackages(projectDir, pm, ["husky"], true, dryRun);
+    const runner = getRunCommand(pm);
+    const { preCommit, prePush } = buildHookCommands(runner, enabledFeatures);
+    await writeFile(projectDir, ".husky/pre-commit", `# Husky pre-commit\n${preCommit.join("\n")}\n`, force, dryRun);
+    await writeFile(projectDir, ".husky/pre-push", `# Husky pre-push\n${prePush.join("\n")}\n`, force, dryRun);
+    if (!dryRun) {
+        await fs.chmod(path.join(projectDir, ".husky/pre-commit"), 0o755);
+        await fs.chmod(path.join(projectDir, ".husky/pre-push"), 0o755);
+    }
+    withProjectCwd(projectDir, () => {
+        if (dryRun) {
+            console.log("[dry-run] Would set package script: prepare");
+            return;
+        }
+        packageJson().setScript("prepare", "husky").save();
+    });
+    if (skipHuskyInstall) {
+        console.log("Skip husky install (--skip-husky-install)");
+        return;
+    }
+    if (!existsSync(path.join(projectDir, ".git"))) {
+        console.log("Skip husky install (.git not found)");
+        return;
+    }
+    if (!dryRun) {
+        runHuskyInstallCommand(pm, projectDir);
+    }
+}
+function runHuskyInstallCommand(pm, projectDir) {
+    if (pm === "pnpm") {
+        runCommand("pnpm exec husky", projectDir, false);
+        return;
+    }
+    if (pm === "yarn") {
+        runCommand("yarn husky", projectDir, false);
+        return;
+    }
+    runCommand("npx husky", projectDir, false);
+}

package/dist/init-project/mrm-rules/index.js

@@ -0,0 +1,33 @@
+import { runAiSkillsRule } from "./ai-skills.js";
+import { runFormatRule } from "./format.js";
+import { runHuskyRule } from "./husky.js";
+import { runLintRule } from "./lint.js";
+import { runTestJestRule } from "./test-jest.js";
+import { runTestVitestRule } from "./test-vitest.js";
+import { runTypescriptRule } from "./typescript.js";
+export async function runFeatureRules(context) {
+    const { enabledFeatures, skills, testRunner } = context;
+    if (enabledFeatures.format) {
+        await runFormatRule(context);
+    }
+    if (enabledFeatures.lint) {
+        await runLintRule(context);
+    }
+    if (enabledFeatures.typescript) {
+        await runTypescriptRule(context);
+    }
+    if (enabledFeatures.test) {
+        if (testRunner === "vitest") {
+            await runTestVitestRule(context);
+        }
+        else {
+            await runTestJestRule(context);
+        }
+    }
+    if (enabledFeatures.husky) {
+        await runHuskyRule(context);
+    }
+    if (skills) {
+        await runAiSkillsRule(context);
+    }
+}

package/dist/init-project/mrm-rules/lint.js

@@ -0,0 +1,16 @@
+import { packageJson } from "../mrm-core.js";
+import { installPackages, withProjectCwd } from "./shared.js";
+export async function runLintRule(context) {
+    const { projectDir, pm, dryRun } = context;
+    installPackages(projectDir, pm, ["eslint"], true, dryRun);
+    withProjectCwd(projectDir, () => {
+        if (dryRun) {
+            console.log("[dry-run] Would set package scripts: lint, lint:check");
+            return;
+        }
+        packageJson()
+            .setScript("lint", "eslint .")
+            .setScript("lint:check", "eslint . --max-warnings 0")
+            .save();
+    });
+}

package/dist/init-project/mrm-rules/shared.js

@@ -0,0 +1,91 @@
+import { existsSync } from "node:fs";
+import { promises as fs } from "node:fs";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { installPackages as installByPackageManager } from "../package-manager.js";
+export function withProjectCwd(projectDir, fn) {
+    const original = process.cwd();
+    process.chdir(projectDir);
+    try {
+        return fn();
+    }
+    finally {
+        process.chdir(original);
+    }
+}
+export function getInstallOptions(pm) {
+    if (pm === "pnpm")
+        return { pnpm: true };
+    if (pm === "yarn")
+        return { yarn: true };
+    return {};
+}
+export function installPackages(projectDir, pm, packages, dev = true, dryRun = false) {
+    const missingPackages = filterUninstalledPackages(projectDir, packages);
+    if (missingPackages.length === 0) {
+        console.log(`Skip install (already present): ${packages.join(", ")}`);
+        return;
+    }
+    if (missingPackages.length !== packages.length) {
+        const installedPackages = packages.filter(candidate => !missingPackages.includes(candidate));
+        console.log(`Skip already installed: ${installedPackages.join(", ")}`);
+    }
+    installByPackageManager(pm, projectDir, missingPackages, dev, dryRun);
+}
+export function filterUninstalledPackages(projectDir, packages) {
+    if (packages.length === 0)
+        return [];
+    const installed = getInstalledPackageNames(projectDir);
+    if (installed.size === 0)
+        return packages;
+    return packages.filter(pkg => !installed.has(getPackageName(pkg)));
+}
+function getInstalledPackageNames(projectDir) {
+    const packageJsonPath = path.join(projectDir, "package.json");
+    if (!existsSync(packageJsonPath))
+        return new Set();
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return new Set([
+            ...Object.keys(packageJson.dependencies ?? {}),
+            ...Object.keys(packageJson.devDependencies ?? {}),
+            ...Object.keys(packageJson.peerDependencies ?? {}),
+            ...Object.keys(packageJson.optionalDependencies ?? {}),
+        ]);
+    }
+    catch {
+        return new Set();
+    }
+}
+function getPackageName(pkg) {
+    if (pkg.startsWith("@")) {
+        const scopeEnd = pkg.indexOf("/", 1);
+        if (scopeEnd < 0)
+            return pkg;
+        const versionStart = pkg.indexOf("@", scopeEnd + 1);
+        return versionStart < 0 ? pkg : pkg.slice(0, versionStart);
+    }
+    const versionStart = pkg.indexOf("@");
+    return versionStart < 0 ? pkg : pkg.slice(0, versionStart);
+}
+export async function writeFile(projectDir, relativePath, content, force, dryRun) {
+    const targetPath = path.join(projectDir, relativePath);
+    try {
+        await fs.access(targetPath);
+        if (!force) {
+            console.log(`Skip ${relativePath} (already exists)`);
+            return false;
+        }
+    }
+    catch {
+        // File doesn't exist.
+    }
+    if (dryRun) {
+        console.log(`[dry-run] Would ${force ? "update" : "create"} ${relativePath}`);
+        return true;
+    }
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, content, "utf8");
+    console.log(`${force ? "Updated" : "Created"} ${relativePath}`);
+    return true;
+}

package/dist/init-project/mrm-rules/test-jest.js

@@ -0,0 +1,48 @@
+import { packageJson } from "../mrm-core.js";
+import { installPackages, withProjectCwd, writeFile } from "./shared.js";
+function getJestConfig(testEnvironment) {
+    return `/** @type {import("jest").Config} */
+const config = {
+  testEnvironment: "${testEnvironment}",
+  setupFilesAfterEnv: ["<rootDir>/jest.setup.js"],
+  testMatch: ["**/*.test.[jt]s?(x)", "**/*.test.ts"],
+}
+
+module.exports = config
+`;
+}
+function getSetupFile(frameworkId) {
+    if (frameworkId === "react") {
+        return `require("@testing-library/jest-dom")
+
+// Jest setup (add custom matchers or globals here)
+`;
+    }
+    return `// Jest setup (add custom matchers or globals here)
+`;
+}
+export async function runTestJestRule(context) {
+    const { framework, projectDir, pm, force, dryRun } = context;
+    const deps = ["jest"];
+    if (framework.testEnvironment === "jsdom") {
+        deps.push("jest-environment-jsdom");
+    }
+    if (framework.id === "react") {
+        deps.push("@testing-library/jest-dom");
+        deps.push("@testing-library/react");
+    }
+    installPackages(projectDir, pm, deps, true, dryRun);
+    await writeFile(projectDir, "jest.config.js", getJestConfig(framework.testEnvironment), force, dryRun);
+    await writeFile(projectDir, "jest.setup.js", getSetupFile(framework.id), force, dryRun);
+    withProjectCwd(projectDir, () => {
+        if (dryRun) {
+            console.log("[dry-run] Would set package scripts: test, test:watch, test:coverage");
+            return;
+        }
+        packageJson()
+            .setScript("test", "NODE_OPTIONS=--experimental-vm-modules jest --passWithNoTests")
+            .setScript("test:watch", "NODE_OPTIONS=--experimental-vm-modules jest --watch")
+            .setScript("test:coverage", "NODE_OPTIONS=--experimental-vm-modules jest --coverage")
+            .save();
+    });
+}

package/dist/init-project/mrm-rules/test-vitest.js

@@ -0,0 +1,46 @@
+import { packageJson } from "../mrm-core.js";
+import { installPackages, withProjectCwd, writeFile } from "./shared.js";
+function getVitestConfig(framework) {
+    return `import { defineConfig } from "vitest/config"
+
+export default defineConfig({
+  test: {
+    environment: "${framework.testEnvironment}",
+    setupFiles: ["./vitest.setup.js"],
+  },
+})
+`;
+}
+function getVitestSetup(framework) {
+    if (framework.id === "react") {
+        return `import "@testing-library/jest-dom/vitest"
+`;
+    }
+    return `// Vitest setup
+`;
+}
+export async function runTestVitestRule(context) {
+    const { framework, projectDir, pm, force, dryRun } = context;
+    const deps = ["vitest"];
+    if (framework.testEnvironment === "jsdom") {
+        deps.push("jsdom");
+    }
+    if (framework.id === "react") {
+        deps.push("@testing-library/jest-dom");
+        deps.push("@testing-library/react");
+    }
+    installPackages(projectDir, pm, deps, true, dryRun);
+    await writeFile(projectDir, "vitest.config.ts", getVitestConfig(framework), force, dryRun);
+    await writeFile(projectDir, "vitest.setup.js", getVitestSetup(framework), force, dryRun);
+    withProjectCwd(projectDir, () => {
+        if (dryRun) {
+            console.log("[dry-run] Would set package scripts: test, test:watch, test:coverage");
+            return;
+        }
+        packageJson()
+            .setScript("test", "vitest run")
+            .setScript("test:watch", "vitest")
+            .setScript("test:coverage", "vitest run --coverage")
+            .save();
+    });
+}

package/dist/init-project/mrm-rules/typescript.js

@@ -0,0 +1,40 @@
+import { json, packageJson } from "../mrm-core.js";
+import { installPackages, withProjectCwd } from "./shared.js";
+const TS_REQUIRED_OPTIONS = {
+    strict: true,
+    strictNullChecks: true,
+    noImplicitAny: true,
+    noImplicitThis: true,
+    exactOptionalPropertyTypes: true,
+    noUncheckedIndexedAccess: true,
+    noUnusedLocals: true,
+    noUnusedParameters: true,
+};
+export async function runTypescriptRule(context) {
+    const { framework, projectDir, pm, dryRun } = context;
+    installPackages(projectDir, pm, ["typescript"], true, dryRun);
+    withProjectCwd(projectDir, () => {
+        if (dryRun) {
+            console.log("[dry-run] Would update tsconfig.json");
+            console.log("[dry-run] Would set package script: type-check");
+            return;
+        }
+        const tsconfig = json("tsconfig.json", {
+            compilerOptions: {},
+            exclude: [],
+        });
+        const mergedCompilerOptions = {
+            ...(tsconfig.get("compilerOptions") ?? {}),
+            ...TS_REQUIRED_OPTIONS,
+        };
+        const exclude = new Set(tsconfig.get("exclude", []));
+        for (const entry of framework.tsRequiredExcludes) {
+            exclude.add(entry);
+        }
+        tsconfig
+            .set("compilerOptions", mergedCompilerOptions)
+            .set("exclude", Array.from(exclude))
+            .save();
+        packageJson().setScript("type-check", "tsc --noEmit").save();
+    });
+}

package/dist/init-project/package-manager.js

@@ -0,0 +1,57 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+export function detectPackageManager(projectDir) {
+    if (existsSync(path.join(projectDir, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(path.join(projectDir, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (existsSync(path.join(projectDir, "package-lock.json"))) {
+        return "npm";
+    }
+    return "npm";
+}
+export function getRunCommand(pm) {
+    if (pm === "pnpm")
+        return "pnpm";
+    if (pm === "yarn")
+        return "yarn";
+    return "npm run";
+}
+export function runCommand(command, cwd, dryRun = false) {
+    if (dryRun) {
+        console.log(`[dry-run] Would run: ${command}`);
+        return;
+    }
+    execSync(command, { cwd, stdio: "inherit" });
+}
+export function runScript(pm, scriptName, cwd, dryRun = false) {
+    if (pm === "pnpm") {
+        runCommand(`pnpm ${scriptName}`, cwd, dryRun);
+        return;
+    }
+    if (pm === "yarn") {
+        runCommand(`yarn ${scriptName}`, cwd, dryRun);
+        return;
+    }
+    runCommand(`npm run ${scriptName}`, cwd, dryRun);
+}
+export function installPackages(pm, projectDir, packages, isDev, dryRun = false) {
+    if (packages.length === 0)
+        return;
+    const list = packages.join(" ");
+    let command = "";
+    if (pm === "pnpm") {
+        command = `pnpm add ${isDev ? "-D " : ""}${list}`;
+    }
+    else if (pm === "yarn") {
+        command = `yarn add ${isDev ? "-D " : ""}${list}`;
+    }
+    else {
+        command = `npm install ${isDev ? "-D " : ""}${list}`;
+    }
+    console.log(`${dryRun ? "[dry-run] " : ""}Installing ${isDev ? "dev " : ""}dependencies: ${packages.join(", ")}`);
+    runCommand(command, projectDir, dryRun);
+}

package/dist/init-project/types.js

@@ -0,0 +1 @@
+export {};

package/dist/init-project/utils.js

@@ -0,0 +1,9 @@
+export function hasPackage(pkg, name) {
+    return Boolean(pkg.dependencies?.[name] ||
+        pkg.devDependencies?.[name] ||
+        pkg.peerDependencies?.[name]);
+}
+export function formatStep(step, total, message, dryRun) {
+    const suffix = dryRun ? " [dry-run]" : "";
+    return `[${step}/${total}] ${message}${suffix}`;
+}

package/dist/init-project.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { main } from "./init-project/index.js";
+main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}