axigen 0.1.0

package/README.md

@@ -0,0 +1,109 @@
+# axigen
+
+> Generate typed Axios client functions from OpenAPI / Swagger specs
+
+[![npm version](https://img.shields.io/npm/v/axigen)](https://www.npmjs.com/package/axigen)
+[![license](https://img.shields.io/npm/l/axigen)](./LICENSE)
+
+## نصب
+
+```bash
+npm install -D axigen
+# یا
+pnpm add -D axigen
+```
+
+## شروع سریع
+
+**۱. ساخت فایل کانفیگ:**
+
+```bash
+npx axigen init
+```
+
+**۲. ویرایش `axigen.config.js`:**
+
+```js
+/** @type {import('axigen').AxigenConfig} */
+module.exports = {
+  input: "./openapi.yaml",
+  output: {
+    client: "./src/api/client.ts",
+    types: "./src/api/types.ts",
+  },
+  axiosInstancePath: "../lib/axios",
+  language: "ts",
+  jsdoc: true,
+};
+```
+
+**۳. Generate:**
+
+```bash
+npx axigen generate
+# یا کوتاه‌تر:
+npx axigen
+```
+
+## خروجی
+
+از این OpenAPI:
+
+```yaml
+paths:
+  /users/{userId}:
+    get:
+      operationId: getUserById
+      parameters:
+        - name: userId
+          in: path
+          required: true
+```
+
+این کد generate میشه:
+
+```ts
+/**
+ * دریافت کاربر با ID
+ * `GET /users/{userId}`
+ */
+export async function getUserById(userId: GetUserByIdPathParams["userId"]): Promise<AxiosResponse<GetUserByIdResponse>> {
+  return axiosInstance.get(`/users/${userId}`);
+}
+```
+
+## گزینه‌های کانفیگ
+
+| گزینه                 | نوع            | پیش‌فرض         | توضیح                               |
+| --------------------- | -------------- | --------------- | ----------------------------------- |
+| `input`               | `string`       | —               | مسیر فایل OpenAPI (yaml یا json)    |
+| `output.client`       | `string`       | —               | مسیر خروجی فایل توابع               |
+| `output.types`        | `string`       | —               | مسیر خروجی فایل types (اختیاری)     |
+| `axiosInstancePath`   | `string`       | —               | مسیر import مربوط به axios instance |
+| `axiosInstanceExport` | `string`       | `axiosInstance` | نام export                          |
+| `language`            | `'ts' \| 'js'` | `'ts'`          | زبان خروجی                          |
+| `jsdoc`               | `boolean`      | `true`          | اضافه کردن JSDoc                    |
+| `tags`                | `string[]`     | —               | فیلتر بر اساس تگ                    |
+
+## دستورات CLI
+
+```bash
+axigen generate [--config <path>] [--cwd <path>]
+axigen init
+axigen --version
+axigen --help
+```
+
+## استفاده programmatic
+
+```ts
+import { generate, loadConfig } from "axigen";
+
+const config = await loadConfig(process.cwd());
+const result = await generate(config, process.cwd());
+console.log(`Generated ${result.endpointCount} endpoints`);
+```
+
+## لایسنس
+
+MIT

package/dist/cli/index.mjs

@@ -0,0 +1,525 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import path4 from "path";
+import fs4 from "fs";
+
+// src/config/loader.ts
+import path from "path";
+import fs from "fs";
+var CONFIG_FILES = ["axigen.config.js", "axigen.config.cjs", "axigen.config.mjs", "axigen.config.ts"];
+async function loadConfig(cwd, configPath) {
+  if (configPath) {
+    const abs = path.resolve(cwd, configPath);
+    if (!fs.existsSync(abs)) {
+      throw new Error(`Config file not found: ${abs}`);
+    }
+    return importConfig(abs);
+  }
+  for (const filename of CONFIG_FILES) {
+    const abs = path.join(cwd, filename);
+    if (fs.existsSync(abs)) {
+      return importConfig(abs);
+    }
+  }
+  throw new Error(`No config file found. Create one of: ${CONFIG_FILES.join(", ")}
+Or run: axigen init`);
+}
+async function importConfig(filePath) {
+  let raw;
+  try {
+    const mod = await import(filePath);
+    raw = mod.default ?? mod;
+  } catch {
+    throw new Error(`Failed to load config: ${filePath}`);
+  }
+  return validateConfig(raw, filePath);
+}
+function validateConfig(raw, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`Invalid config in ${filePath}: must export an object`);
+  }
+  const cfg = raw;
+  if (!cfg.input || typeof cfg.input !== "string") {
+    throw new Error(`Config error: "input" must be a string path to your OpenAPI file`);
+  }
+  if (!cfg.output || typeof cfg.output !== "object") {
+    throw new Error(`Config error: "output" must be an object with at least "client" path`);
+  }
+  const output = cfg.output;
+  if (!output.client || typeof output.client !== "string") {
+    throw new Error(`Config error: "output.client" is required`);
+  }
+  if (!cfg.axiosInstancePath || typeof cfg.axiosInstancePath !== "string") {
+    throw new Error(`Config error: "axiosInstancePath" is required (path to your axios instance)`);
+  }
+  return {
+    input: cfg.input,
+    output: {
+      client: output.client,
+      types: typeof output.types === "string" ? output.types : void 0
+    },
+    axiosInstancePath: cfg.axiosInstancePath,
+    axiosInstanceExport: typeof cfg.axiosInstanceExport === "string" ? cfg.axiosInstanceExport : "axiosInstance",
+    language: cfg.language === "js" ? "js" : "ts",
+    jsdoc: cfg.jsdoc !== false,
+    tags: Array.isArray(cfg.tags) ? cfg.tags : void 0
+  };
+}
+
+// src/generate.ts
+import fs3 from "fs";
+import path3 from "path";
+
+// src/parser/openapi.ts
+import fs2 from "fs";
+import path2 from "path";
+import yaml from "js-yaml";
+function parseOpenAPIFile(filePath) {
+  if (!fs2.existsSync(filePath)) {
+    throw new Error(`OpenAPI file not found: ${filePath}`);
+  }
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const ext = path2.extname(filePath).toLowerCase();
+  let spec;
+  if (ext === ".json") {
+    spec = JSON.parse(content);
+  } else {
+    spec = yaml.load(content);
+  }
+  return validateSpec(spec, filePath);
+}
+function validateSpec(raw, filePath) {
+  if (!raw || typeof raw !== "object") {
+    throw new Error(`Invalid OpenAPI file: ${filePath}`);
+  }
+  const s = raw;
+  const isOpenAPI3 = typeof s.openapi === "string" && s.openapi.startsWith("3.");
+  const isSwagger2 = typeof s.swagger === "string" && s.swagger.startsWith("2.");
+  if (!isOpenAPI3 && !isSwagger2) {
+    throw new Error(`Unsupported spec format in ${filePath}.
+Expected OpenAPI 3.x or Swagger 2.x`);
+  }
+  if (!s.paths || typeof s.paths !== "object") {
+    throw new Error(`OpenAPI spec has no "paths" defined: ${filePath}`);
+  }
+  return raw;
+}
+function extractEndpoints(spec, filterTags) {
+  const endpoints = [];
+  for (const [urlPath, pathItem] of Object.entries(spec.paths)) {
+    const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const tags = operation.tags ?? [];
+      if (filterTags && filterTags.length > 0) {
+        if (!tags.some((t) => filterTags.includes(t))) continue;
+      }
+      const operationId = operation.operationId ?? buildOperationId(method, urlPath);
+      const allParams = [...pathItem.parameters ?? [], ...operation.parameters ?? []];
+      const pathParams = allParams.filter((p) => !("$ref" in p) && p.in === "path").map(normalizeParam);
+      const queryParams = allParams.filter((p) => !("$ref" in p) && p.in === "query").map(normalizeParam);
+      let bodySchema;
+      let bodyRequired = false;
+      if (operation.requestBody && !("$ref" in operation.requestBody)) {
+        bodyRequired = operation.requestBody.required ?? false;
+        const content = operation.requestBody.content;
+        const jsonContent = content?.["application/json"];
+        bodySchema = jsonContent?.schema;
+      }
+      let responseSchema;
+      for (const [status, response] of Object.entries(operation.responses)) {
+        if (status.startsWith("2") && !("$ref" in response)) {
+          const jsonContent = response.content?.["application/json"];
+          responseSchema = jsonContent?.schema;
+          break;
+        }
+      }
+      endpoints.push({
+        operationId,
+        method,
+        path: urlPath,
+        summary: operation.summary,
+        description: operation.description,
+        tags,
+        pathParams,
+        queryParams,
+        bodySchema,
+        bodyRequired,
+        responseSchema
+      });
+    }
+  }
+  return endpoints;
+}
+function normalizeParam(p) {
+  return {
+    name: p.name,
+    required: p.required ?? false,
+    schema: p.schema,
+    description: p.description
+  };
+}
+function buildOperationId(method, urlPath) {
+  const parts = urlPath.split("/").filter(Boolean).map((segment) => {
+    if (segment.startsWith("{") && segment.endsWith("}")) {
+      const name = segment.slice(1, -1);
+      return "By" + capitalize(name);
+    }
+    return capitalize(segment);
+  });
+  return method.toLowerCase() + parts.join("");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/generator/types.ts
+function schemaToTSType(schema, indent = 0) {
+  if (!schema) return "unknown";
+  if (schema.$ref) {
+    return refToTypeName(schema.$ref);
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    return schema.allOf.map((s) => schemaToTSType(s, indent)).join(" & ");
+  }
+  if (schema.anyOf || schema.oneOf) {
+    const variants = schema.anyOf ?? schema.oneOf;
+    return variants.map((s) => schemaToTSType(s, indent)).join(" | ");
+  }
+  if (schema.enum) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  const nullable = schema.nullable ? " | null" : "";
+  switch (schema.type) {
+    case "string":
+      return `string${nullable}`;
+    case "number":
+    case "integer":
+      return `number${nullable}`;
+    case "boolean":
+      return `boolean${nullable}`;
+    case "null":
+      return "null";
+    case "array":
+      return `Array<${schemaToTSType(schema.items, indent)}>${nullable}`;
+    case "object":
+      return buildObjectType(schema, indent) + nullable;
+    default:
+      if (schema.properties) {
+        return buildObjectType(schema, indent) + nullable;
+      }
+      return `unknown${nullable}`;
+  }
+}
+function buildObjectType(schema, indent) {
+  if (!schema.properties || Object.keys(schema.properties).length === 0) {
+    return "Record<string, unknown>";
+  }
+  const required = new Set(schema.required ?? []);
+  const pad = "  ".repeat(indent + 1);
+  const closePad = "  ".repeat(indent);
+  const fields = Object.entries(schema.properties).map(([key, val]) => {
+    const optional = !required.has(key) ? "?" : "";
+    const comment = val.description ? `${pad}/** ${val.description} */
+` : "";
+    const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `'${key}'`;
+    return `${comment}${pad}${safeName}${optional}: ${schemaToTSType(val, indent + 1)}`;
+  }).join("\n");
+  return `{
+${fields}
+${closePad}}`;
+}
+function refToTypeName(ref) {
+  const parts = ref.split("/");
+  return parts[parts.length - 1] ?? "unknown";
+}
+function generateTypesFile(endpoints, schemas = {}) {
+  const lines = [];
+  lines.push(`// This file is auto-generated by axigen. DO NOT EDIT.`);
+  lines.push(`// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  if (Object.keys(schemas).length > 0) {
+    lines.push("// \u2500\u2500\u2500 Component Schemas \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    lines.push("");
+    for (const [name, schema] of Object.entries(schemas)) {
+      if (schema.description) {
+        lines.push(`/** ${schema.description} */`);
+      }
+      lines.push(`export type ${name} = ${schemaToTSType(schema)}`);
+      lines.push("");
+    }
+  }
+  lines.push("// \u2500\u2500\u2500 Endpoint Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  lines.push("");
+  for (const ep of endpoints) {
+    const baseName = operationToTypeName(ep.operationId);
+    if (ep.pathParams.length > 0) {
+      lines.push(`export interface ${baseName}PathParams {`);
+      for (const p of ep.pathParams) {
+        const type = schemaToTSType(p.schema);
+        const comment = p.description ? `  /** ${p.description} */
+` : "";
+        lines.push(`${comment}  ${p.name}: ${type}`);
+      }
+      lines.push(`}`);
+      lines.push("");
+    }
+    if (ep.queryParams.length > 0) {
+      lines.push(`export interface ${baseName}QueryParams {`);
+      for (const p of ep.queryParams) {
+        const optional = !p.required ? "?" : "";
+        const type = schemaToTSType(p.schema);
+        const comment = p.description ? `  /** ${p.description} */
+` : "";
+        lines.push(`${comment}  ${p.name}${optional}: ${type}`);
+      }
+      lines.push(`}`);
+      lines.push("");
+    }
+    if (ep.bodySchema) {
+      lines.push(`export type ${baseName}Body = ${schemaToTSType(ep.bodySchema)}`);
+      lines.push("");
+    }
+    if (ep.responseSchema) {
+      lines.push(`export type ${baseName}Response = ${schemaToTSType(ep.responseSchema)}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function operationToTypeName(operationId) {
+  return operationId.charAt(0).toUpperCase() + operationId.slice(1);
+}
+
+// src/generator/axios.ts
+function generateClientFile(opts) {
+  const { endpoints, config, typesRelativePath } = opts;
+  const isTS = config.language !== "js";
+  const instanceExport = config.axiosInstanceExport ?? "axiosInstance";
+  const lines = [];
+  lines.push(`// This file is auto-generated by axigen. DO NOT EDIT.`);
+  lines.push(`// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  if (isTS) {
+    lines.push(`import type { AxiosResponse } from 'axios'`);
+  }
+  lines.push(`import { ${instanceExport} } from '${config.axiosInstancePath}'`);
+  if (isTS && typesRelativePath) {
+    const typeImports = collectTypeImports(endpoints);
+    if (typeImports.length > 0) {
+      lines.push(`import type { ${typeImports.join(", ")} } from '${typesRelativePath}'`);
+    }
+  }
+  lines.push("");
+  lines.push("");
+  for (const ep of endpoints) {
+    const fn = buildFunction(ep, isTS, instanceExport, config.jsdoc !== false);
+    lines.push(fn);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildFunction(ep, isTS, instanceExport, jsdoc) {
+  const typeName = operationToTypeName(ep.operationId);
+  const lines = [];
+  if (jsdoc) {
+    lines.push(`/**`);
+    if (ep.summary) lines.push(` * ${ep.summary}`);
+    if (ep.description && ep.description !== ep.summary) {
+      lines.push(` * ${ep.description}`);
+    }
+    lines.push(` * \`${ep.method.toUpperCase()} ${ep.path}\``);
+    if (ep.tags.length > 0) lines.push(` * @tags ${ep.tags.join(", ")}`);
+    lines.push(` */`);
+  }
+  const params = buildParams(ep, typeName, isTS);
+  const returnType = isTS ? buildReturnType(ep, typeName) : "";
+  const asyncKw = "async ";
+  lines.push(`export ${asyncKw}function ${ep.operationId}(${params})${returnType} {`);
+  const callLines = buildAxiosCall(ep, instanceExport, typeName, isTS);
+  for (const l of callLines) {
+    lines.push(`  ${l}`);
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+function buildParams(ep, typeName, isTS) {
+  const parts = [];
+  for (const p of ep.pathParams) {
+    const type = isTS ? `: ${typeName}PathParams['${p.name}']` : "";
+    parts.push(`${p.name}${type}`);
+  }
+  if (ep.bodySchema) {
+    const optional = !ep.bodyRequired ? "?" : "";
+    const type = isTS ? `: ${typeName}Body` : "";
+    parts.push(`data${optional}${type}`);
+  }
+  if (ep.queryParams.length > 0) {
+    const optional = ep.queryParams.every((p) => !p.required) ? "?" : "";
+    const type = isTS ? `: ${typeName}QueryParams` : "";
+    parts.push(`params${optional}${type}`);
+  }
+  return parts.join(", ");
+}
+function buildReturnType(ep, typeName) {
+  const responseType = ep.responseSchema ? `${typeName}Response` : "unknown";
+  return `: Promise<AxiosResponse<${responseType}>>`;
+}
+function buildAxiosCall(ep, instanceExport, _typeName, _isTS) {
+  const lines = [];
+  const interpolatedPath = ep.pathParams.length > 0 ? "`" + ep.path.replace(/\{(\w+)\}/g, "${$1}") + "`" : `'${ep.path}'`;
+  const hasBody = !!ep.bodySchema;
+  const hasQuery = ep.queryParams.length > 0;
+  const method = ep.method.toLowerCase();
+  if (method === "get" || method === "delete" || method === "head") {
+    if (hasQuery) {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath}, { params })`);
+    } else {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath})`);
+    }
+  } else {
+    const bodyArg = hasBody ? "data" : "undefined";
+    if (hasQuery) {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath}, ${bodyArg}, { params })`);
+    } else {
+      lines.push(`return ${instanceExport}.${method}(${interpolatedPath}, ${bodyArg})`);
+    }
+  }
+  return lines;
+}
+function collectTypeImports(endpoints) {
+  const names = /* @__PURE__ */ new Set();
+  for (const ep of endpoints) {
+    const typeName = operationToTypeName(ep.operationId);
+    if (ep.pathParams.length > 0) names.add(`${typeName}PathParams`);
+    if (ep.queryParams.length > 0) names.add(`${typeName}QueryParams`);
+    if (ep.bodySchema) names.add(`${typeName}Body`);
+    if (ep.responseSchema) names.add(`${typeName}Response`);
+  }
+  return [...names].sort();
+}
+
+// src/generate.ts
+async function generate(config, cwd) {
+  const specPath = path3.resolve(cwd, config.input);
+  const spec = parseOpenAPIFile(specPath);
+  const endpoints = extractEndpoints(spec, config.tags);
+  if (endpoints.length === 0) {
+    throw new Error("No endpoints found in the OpenAPI spec. Check your input file or tags filter.");
+  }
+  const clientPath = path3.resolve(cwd, config.output.client);
+  const typesPath = config.output.types ? path3.resolve(cwd, config.output.types) : void 0;
+  let typesRelativePath;
+  if (typesPath) {
+    typesRelativePath = toRelativeImportPath(path3.dirname(clientPath), typesPath);
+  }
+  const schemas = spec.components?.schemas ?? {};
+  let typesContent;
+  if (config.language !== "js" && typesPath) {
+    typesContent = generateTypesFile(endpoints, schemas);
+  }
+  const clientContent = generateClientFile({
+    endpoints,
+    config,
+    typesRelativePath
+  });
+  ensureDir(path3.dirname(clientPath));
+  fs3.writeFileSync(clientPath, clientContent, "utf-8");
+  if (typesPath && typesContent) {
+    ensureDir(path3.dirname(typesPath));
+    fs3.writeFileSync(typesPath, typesContent, "utf-8");
+  }
+  return {
+    clientPath,
+    typesPath,
+    endpointCount: endpoints.length
+  };
+}
+function ensureDir(dir) {
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+}
+function toRelativeImportPath(fromDir, toFile) {
+  let rel = path3.relative(fromDir, toFile);
+  rel = rel.replace(/\.(ts|js|d\.ts)$/, "");
+  if (!rel.startsWith(".")) {
+    rel = "./" + rel;
+  }
+  return rel.replace(/\\/g, "/");
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("axigen").description("Generate typed Axios client functions from OpenAPI / Swagger specs").version(getVersion());
+program.command("generate", { isDefault: true }).alias("gen").description("Generate axios client from OpenAPI spec").option("-c, --config <path>", "Path to config file (default: axigen.config.js)").option("--cwd <path>", "Working directory (default: process.cwd())").action(async (opts) => {
+  const cwd = opts.cwd ? path4.resolve(opts.cwd) : process.cwd();
+  const spinner = ora({
+    text: chalk.dim("Loading config..."),
+    color: "cyan"
+  }).start();
+  try {
+    const config = await loadConfig(cwd, opts.config);
+    spinner.text = chalk.dim(`Parsing ${config.input}...`);
+    const result = await generate(config, cwd);
+    spinner.succeed(chalk.green("Generated successfully!"));
+    console.log("");
+    console.log(chalk.bold("  Output:"));
+    console.log(`  ${chalk.cyan("client")}  \u2192  ${chalk.white(relPath(cwd, result.clientPath))}`);
+    if (result.typesPath) {
+      console.log(`  ${chalk.cyan("types")}   \u2192  ${chalk.white(relPath(cwd, result.typesPath))}`);
+    }
+    console.log("");
+    console.log(`  ${chalk.green("\u2713")} ${chalk.bold(result.endpointCount)} endpoint${result.endpointCount !== 1 ? "s" : ""} generated`);
+    console.log("");
+  } catch (err) {
+    spinner.fail(chalk.red("Generation failed"));
+    console.error("");
+    console.error(chalk.red("  Error: ") + (err instanceof Error ? err.message : String(err)));
+    console.error("");
+    process.exit(1);
+  }
+});
+program.command("init").description("Create a starter axigen.config.js in the current directory").option("--cwd <path>", "Working directory").action((opts) => {
+  const cwd = opts.cwd ? path4.resolve(opts.cwd) : process.cwd();
+  const dest = path4.join(cwd, "axigen.config.js");
+  if (fs4.existsSync(dest)) {
+    console.log(chalk.yellow("  axigen.config.js already exists."));
+    return;
+  }
+  const template = `/** @type {import('axigen').AxigenConfig} */
+module.exports = {
+  input: './openapi.yaml',
+
+  output: {
+    client: './src/api/client.ts',
+    types: './src/api/types.ts',
+  },
+  axiosInstancePath: '../lib/axios',
+  language: 'ts',
+  jsdoc: true,
+}
+`;
+  fs4.writeFileSync(dest, template, "utf-8");
+  console.log(chalk.green(`  \u2713 Created axigen.config.js`));
+  console.log(chalk.dim(`  Edit it and run: axigen generate`));
+});
+program.parse();
+function relPath(cwd, abs) {
+  return path4.relative(cwd, abs);
+}
+function getVersion() {
+  try {
+    const pkgPath = new URL("../../package.json", import.meta.url).pathname;
+    const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}