silgi 0.7.0 → 0.7.1

package/dist/cli/build/framework/h3.mjs

@@ -0,0 +1,46 @@
+async function h3Framework(silgi, skip = false) {
+  if (silgi.options.preset !== "h3" && skip === false)
+    return;
+  if (silgi.options.preset === "h3") {
+    silgi.hook("after:prepare:schema.ts", (data) => {
+      data.unshift("type FrameworkContextExtends = NitroApp");
+    });
+  }
+  silgi.hook("prepare:schema.ts", (data) => {
+    data.importItems.nitropack = {
+      import: [
+        { name: "NitroApp", type: true }
+      ],
+      from: "nitropack/types"
+    };
+    data.importItems.h3 = {
+      import: [
+        { name: "H3Event", type: true }
+      ],
+      from: "h3"
+    };
+    data.events.push({
+      key: "H3Event",
+      value: "H3Event",
+      extends: true,
+      isSilgiContext: false
+    });
+  });
+  silgi.hook("prepare:createDTSFramework", (data) => {
+    data.importItems["silgi/types"] = {
+      import: [
+        { name: "ModuleRuntimeContext", type: true }
+      ],
+      from: "silgi/types"
+    };
+    data.customContent?.push(
+      "",
+      'declare module "h3" {',
+      "  interface H3EventContext extends ModuleRuntimeContext {}",
+      "}",
+      ""
+    );
+  });
+}
+
+export { h3Framework };

package/dist/cli/build/framework/index.mjs

@@ -0,0 +1,7 @@
+import { h3Framework } from './h3.mjs';
+import { nitroFramework } from './nitro.mjs';
+import { nuxtFramework } from './nuxt.mjs';
+
+const frameworkSetup = [h3Framework, nitroFramework, nuxtFramework];
+
+export { frameworkSetup };

package/dist/cli/build/framework/nitro.mjs

@@ -0,0 +1,28 @@
+import { join } from 'pathe';
+import { runtimeDir } from 'silgi/runtime/meta';
+import { h3Framework } from './h3.mjs';
+
+async function nitroFramework(silgi, skip = false) {
+  if (silgi.options.preset !== "nitro" && skip === false)
+    return;
+  silgi.hook("prepare:schema.ts", (data) => {
+    data.importItems.nitropack = {
+      import: [
+        { name: "NitroApp", type: true }
+      ],
+      from: "nitropack/types"
+    };
+  });
+  silgi.hook("after:prepare:schema.ts", (data) => {
+    data.unshift("type FrameworkContextExtends = NitroApp");
+  });
+  silgi.options.plugins.push({
+    packageImport: "silgi/runtime/internal/nitro",
+    path: join(runtimeDir, "internal/nitro")
+  });
+  silgi.hook("prepare:core.ts", (_data) => {
+  });
+  await h3Framework(silgi, true);
+}
+
+export { nitroFramework };

package/dist/cli/build/framework/nuxt.mjs

@@ -0,0 +1,9 @@
+import { nitroFramework } from './nitro.mjs';
+
+async function nuxtFramework(silgi, skip = false) {
+  if (silgi.options.preset !== "nuxt" && skip === false)
+    return;
+  await nitroFramework(silgi, true);
+}
+
+export { nuxtFramework };

package/dist/cli/build/prepare.mjs

@@ -0,0 +1,7 @@
+import 'node:fs';
+import 'node:fs/promises';
+
+async function prepare(_silgi) {
+}
+
+export { prepare };

package/dist/cli/build/scanURIs.mjs

@@ -0,0 +1,27 @@
+import { promises } from 'node:fs';
+import { readCoreFile } from '../utils/readCoreFile.mjs';
+import { traverseObject, scanActionModulesUris } from '../utils/uri.mjs';
+
+async function scanUris(silgi) {
+  const { context, object, path } = await readCoreFile(silgi);
+  const uriMap = traverseObject(silgi, object.schemas, []);
+  const modulesURIs = scanActionModulesUris(silgi, object.services, []);
+  const uriContent = Array.from(uriMap.entries()).map(([uri, params]) => `  '${uri}': '${params}',`).join("\n");
+  let newContext = "";
+  if (uriMap.size > 0) {
+    newContext = context.replace(
+      /export const uris = \{[^}]*\}/,
+      `export const uris = {
+${uriContent}
+}`
+    ).replace(
+      /export const modulesURIs = \{[^}]*\}/,
+      `export const modulesURIs = ${JSON.stringify(modulesURIs, null, 2)}`
+    );
+  } else {
+    newContext = context;
+  }
+  await promises.writeFile(path, newContext);
+}
+
+export { scanUris };

package/dist/cli/build/template/framework.mjs

@@ -0,0 +1,91 @@
+import { isAbsolute } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
+import { relativeWithDot } from 'silgi/kit';
+
+async function createCoreFramework(silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  if (silgi.options.preset !== "nitro" && silgi.options.preset !== "h3")
+    return;
+  const importItems = {
+    "silgi/types": {
+      import: [
+        { name: "ModuleRuntimeContext", type: true }
+      ],
+      from: "silgi/types"
+    }
+  };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const customImports = [];
+  const functions = [];
+  await silgi.callHook("prepare:createCoreFramework", {
+    importItems,
+    customImports,
+    functions
+  });
+  const content = [
+    ...functions.map((f) => f.params?.length ? ` await ${f.name}(framework, ${f.params.join(",")})` : ` await ${f.name}(framework)`)
+  ];
+  return {
+    content,
+    importItems,
+    customImports
+  };
+}
+async function createDTSFramework(silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  const importItems = {
+    "silgi/types": {
+      import: [
+        { name: "ModuleRuntimeContext", type: true }
+      ],
+      from: "silgi/types"
+    }
+  };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const customImports = [];
+  const customContent = [];
+  await silgi.callHook("prepare:createDTSFramework", {
+    importItems,
+    customImports,
+    customContent
+  });
+  const content = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    }),
+    "",
+    ...customImports,
+    "",
+    ...customContent,
+    ""
+  ];
+  return {
+    content,
+    importItems
+  };
+}
+
+export { createCoreFramework, createDTSFramework };

package/dist/cli/build/template/schema.mjs

@@ -0,0 +1,115 @@
+import { isAbsolute } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
+import { relativeWithDot } from 'silgi/kit';
+
+async function schemaTemplate(silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  const importItems = {
+    "silgi/types": {
+      import: [
+        { name: "URIsTypes", type: true },
+        { name: "Namespaces", type: true },
+        { name: "ModuleRuntimeContext", type: true }
+      ],
+      from: "silgi/types"
+    }
+  };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const data = {
+    importItems,
+    customImports: [],
+    configs: [],
+    contexts: [],
+    methods: [],
+    shareds: [],
+    events: [],
+    storeBase: [],
+    hooks: [],
+    runtimeHooks: []
+  };
+  const storeBase = [];
+  await silgi.callHook("prepare:schema.ts", data);
+  const silgiExport = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core.ts`);
+  let addSilgiContext = false;
+  const importsContent = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    }),
+    "",
+    ...data.customImports,
+    ""
+  ];
+  const importData = [
+    "interface InferredNamespaces {",
+    ...(silgi.options.namespaces || []).map((key) => `  ${key}: string,`),
+    "}",
+    "",
+    `type SchemaExtends = Namespaces<typeof import('${silgiExport}')['schemas']>`,
+    "",
+    `type SilgiURIsMerge = URIsTypes<typeof import('${silgiExport}')['uris']>`,
+    "",
+    `type SilgiModuleContextExtends = ${data.contexts.length ? data.contexts.map(({ value }) => value).join(" & ") : "{}"}`,
+    "",
+    data.events.length ? `interface SilgiModuleEventsExtends extends ${data.events.map((item) => item.extends ? item.value : "").join(", ")} {
+      ${data.events.map((item) => {
+      if (item.isSilgiContext) {
+        addSilgiContext = true;
+      }
+      return !item.extends && !addSilgiContext ? `  ${item.key}: ${item.value}` : item.isSilgiContext ? " context: ModuleRuntimeContext" : "";
+    }).join(",\n")}
+}` : "interface SilgiModuleEventsExtends {}",
+    "",
+    data.shareds.length ? `type SilgiModuleSharedExtends = ${data.shareds.map(({ value }) => value).join(" & ")}` : "type SilgiModuleSharedExtends = {}",
+    "",
+    "interface SilgiModuleMethodsExtends {",
+    ...(data.methods || []).map(({ key, value }) => `  ${key}: ${value},`),
+    "}",
+    "",
+    "interface SilgiModuleOptionsExtends {",
+    ...(data.configs || []).map(({ key, value }) => `  ${key}: ${value},`),
+    "}",
+    "",
+    "interface SilgiStorageBaseExtends {",
+    ...(storeBase || []).map((value) => `  ${value}: ''`),
+    "}",
+    "",
+    `type ModuleHooksExtend = ${data.hooks?.length ? data.hooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    `type SilgiRuntimeHooksExtends = ${data.runtimeHooks?.length ? data.runtimeHooks.map(({ value }) => `${value}`).join(" & ") : "{}"}`,
+    "",
+    "declare module 'silgi/types' {",
+    " interface FrameworkContext extends FrameworkContextExtends {}",
+    " interface SilgiSchema extends SchemaExtends {}",
+    " interface SilgiNamespaces extends InferredNamespaces {}",
+    " interface SilgiStorageBase extends SilgiStorageBaseExtends {}",
+    " interface SilgiModules extends SilgiModuleOptionsExtends {}",
+    " interface SilgiURIs extends SilgiURIsMerge {}",
+    " interface ModuleRuntimeContext extends SilgiModuleContextExtends {}",
+    " interface SilgiEvent extends SilgiModuleEventsExtends {}",
+    " interface SilgiDefaultShared extends SilgiModuleSharedExtends {}",
+    " interface ModuleRuntimeMethods extends SilgiModuleMethodsExtends {}",
+    " interface ModuleOptions extends SilgiModuleOptionsExtends {}",
+    " interface ModuleRuntimeHooks extends SilgiRuntimeHooksExtends {}",
+    " interface ModuleHooks extends ModuleHooksExtend {}",
+    "}",
+    "",
+    "export {}"
+  ];
+  await silgi.callHook("after:prepare:schema.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+
+export { schemaTemplate };

package/dist/cli/build/template/silgi.mjs

@@ -0,0 +1,149 @@
+import { hash } from 'ohash';
+import { isAbsolute } from 'pathe';
+import { readPackageJSON } from 'pkg-types';
+import { relativeWithDot } from 'silgi/kit';
+
+async function silgiCoreFile(data, frameworkContext, silgi) {
+  const relativeRootDir = relativeWithDot(silgi.options.rootDir, silgi.options.serverDir);
+  let importItems = {
+    "silgi/core": {
+      import: [
+        { name: "createSilgi" }
+      ],
+      from: "silgi/core"
+    },
+    "silgi/types": {
+      import: [
+        { name: "ModuleOptions", type: true },
+        { name: "SilgiOptions", type: true },
+        { name: "FrameworkContext", type: true },
+        { name: "DeepPartial", type: true },
+        { name: "BuildConfig", type: true }
+      ],
+      from: "silgi/types"
+    },
+    "#silgi/vfs": {
+      import: [],
+      from: "./vfs"
+    }
+  };
+  importItems = { ...data._importItems, ...importItems };
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    if (!pkg?.name) {
+      return;
+    }
+    if (importItems[pkg.name]) {
+      importItems[pkg.name].from = isAbsolute(id) ? relativeWithDot(relativeRootDir, id) : id;
+    }
+  }));
+  const customImports = data._customImports || [];
+  const uris = [];
+  const services = [];
+  const shareds = [];
+  const schemas = [];
+  const buildSilgiExtraContent = [];
+  const _silgiOptions = {};
+  const _silgiConfigs = [];
+  for (const module of silgi.scanModules) {
+    _silgiOptions[module.meta.configKey] = {
+      ...module.options
+    };
+  }
+  await silgi.callHook("prepare:core.ts", {
+    importItems,
+    customImports,
+    uris,
+    services,
+    shareds,
+    schemas,
+    buildSilgiExtraContent,
+    _silgiOptions,
+    _silgiConfigs
+  });
+  if (importItems["#silgi/vfs"].import.length === 0) {
+    delete importItems["#silgi/vfs"];
+  }
+  if (services.length > 0) {
+    importItems["silgi/core"].import.push({ name: "mergeServices" });
+  }
+  if (shareds.length > 0) {
+    importItems["silgi/core"].import.push({ name: "mergeShared" });
+  }
+  if (schemas.length > 0) {
+    importItems["silgi/core"].import.push({ name: "mergeSchemas" });
+  }
+  const plugins = [];
+  for (const plugin of silgi.options.plugins) {
+    const pluginImportName = `_${hash(plugin.packageImport)}`;
+    customImports.push(`import ${pluginImportName} from '${plugin.packageImport}'`);
+    plugins.push(pluginImportName);
+  }
+  const importsContent = [
+    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
+      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${from}'`;
+    }),
+    "",
+    ...customImports,
+    ""
+  ];
+  const importData = [
+    "export const uris = {}",
+    "",
+    "export const modulesURIs = {}",
+    "",
+    schemas.length > 0 ? "export const schemas = mergeSchemas([" : "export const schemas = {",
+    ...schemas.map((name) => {
+      return `  ${name},`;
+    }),
+    schemas.length > 0 ? "])" : "}",
+    "",
+    services.length > 0 ? "export const services = mergeServices([" : "export const services = {",
+    ...services.map((name) => {
+      return `  ${name},`;
+    }),
+    services.length > 0 ? "])" : "}",
+    "",
+    shareds.length > 0 ? "export const shareds = mergeShared([" : "export const shareds = {",
+    ...shareds.map((name) => {
+      return `  ${name},`;
+    }),
+    shareds.length > 0 ? "])" : "}",
+    "",
+    `export const _silgiOptions: DeepPartial<ModuleOptions> = ${JSON.stringify(_silgiOptions, null, 2)}`,
+    "",
+    "export async function buildSilgi(framework: FrameworkContext, moduleOptions?: Partial<ModuleOptions>,buildOptions?: Partial<BuildConfig>, ) {",
+    "  const silgi = await createSilgi({",
+    "      framework,",
+    "      shared: shareds as any,",
+    "      services: services as any,",
+    "      schemas: schemas as any,",
+    "      uris,",
+    "      modulesURIs,",
+    `      plugins: [${plugins.join(", ")}],`,
+    _silgiConfigs.length > 0 ? `      ${_silgiConfigs.map((config) => Object.entries(config).map(([key, value]) => `${key}: ${value}`)).join(",\n      ")},` : "",
+    "      ...buildOptions,",
+    "      options: {",
+    `      present: '${silgi.options.preset}',`,
+    "      ..._silgiOptions,",
+    "      ...moduleOptions,",
+    "     },",
+    "    })",
+    "",
+    ...frameworkContext,
+    "",
+    ...buildSilgiExtraContent,
+    "",
+    "  return silgi",
+    "}",
+    ""
+  ];
+  await silgi.callHook("after:prepare:core.ts", importData);
+  importData.unshift(...importsContent);
+  return importData;
+}
+
+export { silgiCoreFile };

package/dist/cli/build/types.mjs

@@ -0,0 +1,130 @@
+import { existsSync } from 'node:fs';
+import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath } from 'mlly';
+import { resolve, relative, isAbsolute, join } from 'pathe';
+import { resolveAlias } from 'pathe/utils';
+import { silgiGenerateType } from 'silgi/core';
+import { isDirectory, writeFile } from 'silgi/kit';
+import { runtimeDir } from 'silgi/runtime/meta';
+import { toExports } from 'unimport';
+import { generateSilgiStorageBaseType } from '../core/storage.mjs';
+import { generateRouterDTS } from '../utils/generateRouterDTS.mjs';
+import { readCoreFile } from '../utils/readCoreFile.mjs';
+import { scanUris } from './scanURIs.mjs';
+import { createCoreFramework, createDTSFramework } from './template/framework.mjs';
+import { schemaTemplate } from './template/schema.mjs';
+import { silgiCoreFile } from './template/silgi.mjs';
+
+async function writeTypesAndFiles(silgi) {
+  const data = await createCoreFramework(silgi);
+  await generateSilgiStorageBaseType(silgi);
+  await generateRouterDTS(silgi);
+  silgi.hook("prepare:types", (opts) => {
+    opts.references.push({ path: "./schema.d.ts" });
+    opts.references.push({ path: "./silgi-routes.d.ts" });
+    opts.references.push({ path: "./framework.d.ts" });
+  });
+  const schemaContent = await schemaTemplate(silgi);
+  const coreContent = await silgiCoreFile({
+    _importItems: data?.importItems ?? {},
+    _customImports: data?.customImports ?? []
+  }, data?.content ?? [], silgi);
+  const frameworkDTS = await createDTSFramework(silgi);
+  const { declarations, tsConfig } = await silgiGenerateType(silgi);
+  const tsConfigPath = resolve(
+    silgi.options.typescript.generateTsConfig ? silgi.options.build.dir : silgi.options.rootDir,
+    silgi.options.typescript.tsconfigPath
+  );
+  const typesDir = resolve(silgi.options.build.typesDir);
+  const silgiDir = resolve(silgi.options.silgi.serverDir);
+  let autoImportedTypes = [];
+  let autoImportExports = "";
+  if (silgi.unimport) {
+    await silgi.unimport.init();
+    const allImports = await silgi.unimport.getImports();
+    autoImportExports = toExports(allImports).replace(
+      /#internal\/nitro/g,
+      relative(typesDir, runtimeDir)
+    );
+    const resolvedImportPathMap = /* @__PURE__ */ new Map();
+    for (const i of allImports.filter((i2) => !i2.type)) {
+      if (resolvedImportPathMap.has(i.from)) {
+        continue;
+      }
+      let path = resolveAlias(i.from, silgi.options.alias);
+      if (isAbsolute(path)) {
+        const resolvedPath = await resolvePath(i.from, {
+          url: silgi.options.nodeModulesDirs
+        }).catch(() => null);
+        if (resolvedPath) {
+          const { dir, name } = parseNodeModulePath(resolvedPath);
+          if (!dir || !name) {
+            path = resolvedPath;
+          } else {
+            const subpath = await lookupNodeModuleSubpath(resolvedPath);
+            path = join(dir, name, subpath || "");
+          }
+        }
+      }
+      if (existsSync(path) && !await isDirectory(path)) {
+        path = path.replace(/\.[a-z]+$/, "");
+      }
+      if (isAbsolute(path)) {
+        path = relative(typesDir, path);
+      }
+      resolvedImportPathMap.set(i.from, path);
+    }
+    autoImportedTypes = [
+      silgi.options.imports && silgi.options.imports.autoImport !== false ? (await silgi.unimport.generateTypeDeclarations({
+        exportHelper: false,
+        resolvePath: (i) => resolvedImportPathMap.get(i.from) ?? i.from
+      })).trim() : ""
+    ];
+  }
+  const buildFiles = [];
+  buildFiles.push({
+    path: join(typesDir, "silgi-routes.d.ts"),
+    // contents: uris.join('\n'),
+    contents: ""
+  });
+  buildFiles.push({
+    path: join(silgiDir, "core.ts"),
+    contents: coreContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "schema.d.ts"),
+    contents: schemaContent.join("\n")
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi-imports.d.ts"),
+    contents: [...autoImportedTypes, autoImportExports || "export {}"].join(
+      "\n"
+    )
+  });
+  buildFiles.push({
+    path: join(typesDir, "silgi.d.ts"),
+    contents: declarations.join("\n")
+  });
+  buildFiles.push({
+    path: tsConfigPath,
+    contents: JSON.stringify(tsConfig, null, 2)
+  });
+  buildFiles.push({
+    path: join(typesDir, "framework.d.ts"),
+    contents: frameworkDTS.content.join("\n")
+  });
+  for await (const file of buildFiles) {
+    await writeFile(
+      resolve(silgi.options.build.dir, file.path),
+      file.contents
+    );
+  }
+  await scanUris(silgi);
+  const readCore = await readCoreFile(silgi);
+  silgi.uris = readCore.object.uris;
+  silgi.modulesURIs = readCore.object.modulesURIs;
+  silgi.schemas = readCore.object.schemas;
+  silgi.shareds = readCore.object.shareds;
+  await silgi.hooks.callHook("finish:types", readCore);
+}
+
+export { writeTypesAndFiles };

package/dist/cli/commands/prepare.mjs

@@ -0,0 +1,49 @@
+import { defineCommand } from 'citty';
+import { resolve } from 'pathe';
+import { version } from 'silgi/meta';
+import { frameworkSetup } from '../build/framework/index.mjs';
+import { prepare as prepare$1 } from '../build/prepare.mjs';
+import { writeTypesAndFiles } from '../build/types.mjs';
+import { commonArgs } from '../common.mjs';
+import { createSilgiCLI } from '../core/silgi.mjs';
+import { readCoreFile } from '../utils/readCoreFile.mjs';
+
+const prepare = defineCommand({
+  meta: {
+    name: "prepare",
+    description: "Generate types for the project",
+    version: version
+  },
+  args: {
+    ...commonArgs,
+    preset: {
+      type: "string",
+      description: "The build preset to use (you can also use `SILGI_PRESET` environment variable)."
+    },
+    stub: {
+      type: "boolean",
+      description: "Run in silgi development mode"
+    }
+  },
+  async run({ args }) {
+    const rootDir = resolve(args.dir || args._dir || ".");
+    const silgi = await createSilgiCLI({
+      rootDir,
+      dev: args.stub,
+      stub: args.stub,
+      typescript: { internalPaths: args.stub }
+    });
+    await prepare$1();
+    for (const framework of frameworkSetup) {
+      await framework(silgi);
+    }
+    await writeTypesAndFiles(silgi);
+    await silgi.callHook("read:core.ts", async () => {
+      const data = await readCoreFile(silgi);
+      return data;
+    });
+    await silgi.close();
+  }
+});
+
+export { prepare as default };

package/dist/cli/common.mjs

@@ -0,0 +1,13 @@
+const commonArgs = {
+  dir: {
+    type: "string",
+    description: "project root directory"
+  },
+  _dir: {
+    type: "positional",
+    default: ".",
+    description: "project root directory (prefer using `--dir`)"
+  }
+};
+
+export { commonArgs };