silgi 0.7.58 → 0.8.1

package/dist/_chunks/index.mjs

@@ -1,4 +1,4 @@
-const version = "0.7.58";
+const version = "0.8.1";
 const packageJson = {
 	version: version};
 

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 as c };

package/dist/cli/config/index.mjs

@@ -1,4 +1,5 @@
-export { l as loadOptions, s as silgiGenerateType } from '../types.mjs';
+export { l as loadOptions } from '../loader.mjs';
+export { s as silgiGenerateType } from '../types.mjs';
 import 'c12';
 import 'compatx';
 import 'klona/full';

package/dist/cli/index.mjs

@@ -1,5 +1,4 @@
 import { defineCommand, runMain } from 'citty';
-import consola from 'consola';
 import { p as packageJson } from '../_chunks/index.mjs';
 
 const main = defineCommand({
@@ -16,10 +15,10 @@ const main = defineCommand({
   },
   subCommands: {
     prepare: () => import('./prepare.mjs').then((m) => m.default),
-    init: () => import('./init.mjs').then((m) => m.default)
+    init: () => import('./init.mjs').then((m) => m.default),
+    run: () => import('./run.mjs').then((m) => m.default)
   },
   run({ args }) {
-    consola.info("Silgi CLI , --help for more info");
     if (args.version)
       console.warn("Silgi version:", packageJson.version);
   }

package/dist/cli/loader.mjs

@@ -0,0 +1,555 @@
+import { watchConfig, loadConfig } from 'c12';
+import { resolveCompatibilityDatesFromEnv, formatDate, resolveCompatibilityDates } from 'compatx';
+import { klona } from 'klona/full';
+import { isDebug, isTest } from 'std-env';
+import _consola from 'consola';
+import { colors } from 'consola/utils';
+import { relative, join, resolve } from 'pathe';
+import escapeRE from 'escape-string-regexp';
+import { resolveModuleExportNames } from 'mlly';
+import { existsSync } from 'node:fs';
+import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
+import { resolveSilgiPath } from 'silgi/kit';
+import { runtimeDir, pkgDir } from 'silgi/runtime/meta';
+import { withLeadingSlash, withTrailingSlash } from 'ufo';
+
+const SilgiCLIDefaults = {
+  // General
+  debug: isDebug,
+  // timing: isDebug,
+  logLevel: isTest ? 1 : 3,
+  // runtimeConfig: { app: {}, silgi: {} },
+  appConfig: {},
+  appConfigFiles: [],
+  // Dirs
+  scanDirs: [],
+  build: {
+    dir: ".silgi",
+    typesDir: "{{ build.dir }}/types",
+    templates: []
+  },
+  output: {
+    dir: "{{ rootDir }}/.output",
+    serverDir: "{{ output.dir }}/server",
+    publicDir: "{{ output.dir }}/public"
+  },
+  serverDir: "{{ rootDir }}/server",
+  clientDir: "{{ rootDir }}/client",
+  silgi: {
+    serverDir: "{{ serverDir }}/silgi",
+    clientDir: "{{ clientDir }}/silgi",
+    publicDir: "{{ silgi.serverDir }}/public",
+    utilsDir: "{{ silgi.serverDir }}/utils",
+    vfsDir: "{{ silgi.serverDir }}/vfs",
+    typesDir: "{{ silgi.serverDir }}/types"
+  },
+  // Modules
+  _modules: [],
+  modules: [],
+  // Features
+  // experimental: {},
+  future: {},
+  storage: {},
+  devStorage: {},
+  stub: false,
+  // bundledStorage: [],
+  // publicAssets: [],
+  // serverAssets: [],
+  plugins: [],
+  // tasks: {},
+  // scheduledTasks: {},
+  imports: {
+    exclude: [],
+    dirs: [],
+    presets: [],
+    virtualImports: ["#silgiImports"]
+  },
+  // virtual: {},
+  // compressPublicAssets: false,
+  ignore: [],
+  // Dev
+  dev: false,
+  // devServer: { watch: [] },
+  watchOptions: { ignoreInitial: true },
+  // devProxy: {},
+  // Logging
+  // logging: {
+  //   compressedSizes: true,
+  //   buildSuccess: true,
+  // },
+  // Routing
+  // baseURL: process.env.NITRO_APP_BASE_URL || '/',
+  // handlers: [],
+  // devHandlers: [],
+  // errorHandler: undefined,
+  // routeRules: {},
+  // Advanced
+  typescript: {
+    strict: false,
+    generateTsConfig: true,
+    // generateRuntimeConfigTypes: true,
+    tsconfigPath: ".silgi/types/silgi.tsconfig.json",
+    tsConfig: {},
+    customConditions: []
+  },
+  conditions: [],
+  nodeModulesDirs: [],
+  // hooks: {},
+  commands: {},
+  // Framework
+  framework: {
+    name: "h3",
+    version: ""
+  },
+  extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"],
+  ignoreOptions: void 0
+};
+
+const fallbackCompatibilityDate = "2025-02-04";
+async function resolveCompatibilityOptions(options) {
+  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
+    options.compatibilityDate
+  );
+  if (!options.compatibilityDate.default) {
+    options.compatibilityDate.default = await _resolveDefault(options);
+  }
+}
+let _fallbackInfoShown = false;
+let _promptedUserToUpdate = false;
+async function _resolveDefault(options) {
+  const _todayDate = formatDate(/* @__PURE__ */ new Date());
+  const consola = _consola.withTag("silgi");
+  consola.warn(`No valid compatibility date is specified.`);
+  const onFallback = () => {
+    if (!_fallbackInfoShown) {
+      consola.info(
+        [
+          `Using \`${fallbackCompatibilityDate}\` as fallback.`,
+          `  Please specify compatibility date to avoid unwanted behavior changes:`,
+          `     - Add \`compatibilityDate: '${_todayDate}'\` to the config file.`,
+          `     - Or set \`COMPATIBILITY_DATE=${_todayDate}\` environment variable.`,
+          ``
+        ].join("\n")
+      );
+      _fallbackInfoShown = true;
+    }
+    return fallbackCompatibilityDate;
+  };
+  const shallUpdate = !_promptedUserToUpdate && await consola.prompt(
+    `Do you want to auto update config file to set ${colors.cyan(`compatibilityDate: '${_todayDate}'`)}?`,
+    {
+      type: "confirm",
+      default: true
+    }
+  );
+  _promptedUserToUpdate = true;
+  if (!shallUpdate) {
+    return onFallback();
+  }
+  const { updateConfig } = await import('c12/update');
+  const updateResult = await updateConfig({
+    configFile: "silgi.config",
+    cwd: options.rootDir,
+    async onCreate({ configFile }) {
+      const shallCreate = await consola.prompt(
+        `Do you want to initialize a new config in ${colors.cyan(relative(".", configFile))}?`,
+        {
+          type: "confirm",
+          default: true
+        }
+      );
+      if (shallCreate !== true) {
+        return false;
+      }
+      return _getDefaultNitroConfig();
+    },
+    async onUpdate(config) {
+      config.compatibilityDate = _todayDate;
+    }
+  }).catch((error) => {
+    consola.error(`Failed to update config: ${error.message}`);
+    return null;
+  });
+  if (updateResult?.configFile) {
+    consola.success(
+      `Compatibility date set to \`${_todayDate}\` in \`${relative(".", updateResult.configFile)}\``
+    );
+    return _todayDate;
+  }
+  return onFallback();
+}
+function _getDefaultNitroConfig() {
+  return (
+    /* js */
+    `
+import { defineSilgiConfig } from 'silgi/config'
+
+export default defineSilgiConfig({})
+  `
+  );
+}
+
+async function resolveImportsOptions(options) {
+  if (options.imports === false) {
+    return;
+  }
+  options.imports.presets ??= [];
+  options.imports.presets.push(...getSilgiImportsPreset());
+  if (options.preset === "h3") {
+    const h3Exports = await resolveModuleExportNames("h3", {
+      url: import.meta.url
+    });
+    options.imports.presets ??= [];
+    options.imports.presets.push({
+      from: "h3",
+      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+    });
+  }
+  options.imports.dirs ??= [];
+  options.imports.dirs.push(
+    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
+  );
+  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
+    options.imports.exclude.push(/[/\\]\.git[/\\]/);
+    options.imports.exclude.push(options.build.dir);
+    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
+    options.imports.exclude.push(
+      scanDirsInNodeModules.length > 0 ? new RegExp(
+        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRE(dir)).join("|")})`
+      ) : /[/\\]node_modules[/\\]/
+    );
+  }
+}
+function getSilgiImportsPreset() {
+  return [
+    // TODO: buraya bizim importlarimiz gelecek.
+    {
+      from: "silgi",
+      imports: [
+        "createShared",
+        "useSilgi",
+        "createService",
+        "createSchema"
+      ]
+    },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['useRuntimeConfig', 'useAppConfig'],
+    // },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['defineNitroPlugin', 'nitroPlugin'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/cache',
+    //   imports: [
+    //     'defineCachedFunction',
+    //     'defineCachedEventHandler',
+    //     'cachedFunction',
+    //     'cachedEventHandler',
+    //   ],
+    // },
+    {
+      from: "silgi/core",
+      imports: ["useSilgiStorage"]
+    }
+    // {
+    //   from: 'nitropack/runtime/internal/renderer',
+    //   imports: ['defineRenderHandler'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/meta',
+    //   imports: ['defineRouteMeta'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/route-rules',
+    //   imports: ['getRouteRules'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/context',
+    //   imports: ['useEvent'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/task',
+    //   imports: ['defineTask', 'runTask'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/error/utils',
+    //   imports: ['defineNitroErrorHandler'],
+    // },
+  ];
+}
+
+async function resolvePathOptions(options) {
+  options.rootDir = resolve(options.rootDir || ".");
+  options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(
+    () => options.rootDir
+  );
+  options.srcDir = resolve(options.srcDir || options.rootDir);
+  for (const key of ["srcDir"]) {
+    options[key] = resolve(options.rootDir, options[key]);
+  }
+  options.build.dir = resolve(options.rootDir, options.build.dir);
+  options.build.typesDir = resolveSilgiPath(
+    options.build.typesDir || SilgiCLIDefaults.build.typesDir,
+    options,
+    options.rootDir
+  );
+  if (options.preset === "npm-package") {
+    const packageJsonPath = resolve(options.rootDir, "package.json");
+    const packageJson = await readPackageJSON(packageJsonPath);
+    if (packageJson.name === void 0) {
+      throw new Error("Package name is undefined");
+    }
+    options.alias ||= {};
+    options.alias[packageJson.name] = join(options.rootDir, "src/module");
+    options.alias[`${packageJson.name}/runtime/`] = join(options.rootDir, "src/runtime");
+    options.alias[`${packageJson.name}/runtime/*`] = join(options.rootDir, "src/runtime/*");
+    options.alias[`${packageJson.name}/types`] = join(options.rootDir, "src/types");
+  }
+  if (options.stub) {
+    options.alias = {
+      ...options.alias,
+      "silgi/runtime": join(runtimeDir),
+      "#internal/silgi": join(runtimeDir),
+      "silgi/runtime/*": join(runtimeDir, "*"),
+      "#internal/silgi/*": join(runtimeDir, "*")
+    };
+  }
+  options.alias = {
+    ...options.alias,
+    "~/": join(options.srcDir, "/"),
+    "@/": join(options.srcDir, "/"),
+    "~~/": join(options.rootDir, "/"),
+    "@@/": join(options.rootDir, "/")
+  };
+  if (options.preset === "npm-package") {
+    options.alias = {
+      ...options.alias,
+      "#silgi/app/": join(options.build.dir, "/")
+    };
+  }
+  if (options.alias && typeof options.alias === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  if (options.typescript.tsConfig.compilerOptions?.paths && typeof options.typescript.tsConfig.compilerOptions.paths === "object") {
+    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
+    const paths = options.typescript.tsConfig.compilerOptions.paths;
+    for (const [key, value] of Object.entries(options.alias)) {
+      if (typeof paths === "object") {
+        paths[key] = [value];
+      }
+    }
+  }
+  options.modulesDir = [resolve(options.rootDir, "node_modules")];
+  options.output.dir = resolveSilgiPath(
+    options.output.dir || SilgiCLIDefaults.output.dir,
+    options,
+    options.rootDir
+  );
+  options.output.publicDir = resolveSilgiPath(
+    options.output.publicDir || SilgiCLIDefaults.output.publicDir,
+    options,
+    options.rootDir
+  );
+  options.output.serverDir = resolveSilgiPath(
+    options.output.serverDir || SilgiCLIDefaults.output.serverDir,
+    options,
+    options.rootDir
+  );
+  options.serverDir = resolveSilgiPath(
+    options.serverDir || SilgiCLIDefaults.serverDir,
+    options,
+    options.rootDir
+  );
+  options.clientDir = resolveSilgiPath(
+    options.clientDir || SilgiCLIDefaults.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.serverDir = resolveSilgiPath(
+    options.silgi.serverDir || SilgiCLIDefaults.silgi.serverDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.clientDir = resolveSilgiPath(
+    options.silgi.clientDir || SilgiCLIDefaults.silgi.clientDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.publicDir = resolveSilgiPath(
+    options.silgi.publicDir || SilgiCLIDefaults.silgi.publicDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.utilsDir = resolveSilgiPath(
+    options.silgi.utilsDir || SilgiCLIDefaults.silgi.utilsDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.vfsDir = resolveSilgiPath(
+    options.silgi.vfsDir || SilgiCLIDefaults.silgi.vfsDir,
+    options,
+    options.rootDir
+  );
+  options.silgi.typesDir = resolveSilgiPath(
+    options.silgi.typesDir || SilgiCLIDefaults.silgi.typesDir,
+    options,
+    options.rootDir
+  );
+  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
+  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
+  options.nodeModulesDirs = [
+    ...new Set(
+      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir))
+    )
+  ];
+  options.scanDirs.unshift(options.srcDir);
+  options.scanDirs = options.scanDirs.map(
+    (dir) => resolve(options.srcDir, dir)
+  );
+  options.scanDirs = [...new Set(options.scanDirs)];
+  options.appConfigFiles ??= [];
+  options.appConfigFiles = options.appConfigFiles.map((file) => _tryResolve(resolveSilgiPath(file, options))).filter(Boolean);
+  for (const dir of options.scanDirs) {
+    const configFile = _tryResolve("app.config", dir);
+    if (configFile && !options.appConfigFiles.includes(configFile)) {
+      options.appConfigFiles.push(configFile);
+    }
+  }
+}
+function _tryResolve(path, base = ".", extensions = ["", ".js", ".ts", ".mjs", ".cjs", ".json"]) {
+  path = resolve(base, path);
+  if (existsSync(path)) {
+    return path;
+  }
+  for (const ext of extensions) {
+    const p = path + ext;
+    if (existsSync(p)) {
+      return p;
+    }
+  }
+}
+
+async function resolveStorageOptions(options) {
+  const fsMounts = {
+    root: resolve(options.rootDir),
+    src: resolve(options.srcDir),
+    build: resolve(options.build.dir),
+    cache: resolve(options.build.dir, "cache")
+  };
+  for (const p in fsMounts) {
+    options.devStorage[p] = options.devStorage[p] || {
+      driver: "fs",
+      readOnly: p === "root" || p === "src",
+      base: fsMounts[p]
+    };
+  }
+  if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) {
+    options.devStorage.data = {
+      driver: "fs",
+      base: resolve(options.rootDir, ".data/kv")
+    };
+  }
+}
+
+async function resolveURLOptions(options) {
+  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
+}
+
+const configResolvers = [
+  resolveCompatibilityOptions,
+  resolvePathOptions,
+  resolveImportsOptions,
+  // resolveRouteRulesOptions,
+  // resolveDatabaseOptions,
+  // resolveFetchOptions,
+  // resolveExportConditionsOptions,
+  // resolveRuntimeConfigOptions,
+  // resolveOpenAPIOptions,
+  resolveURLOptions,
+  // resolveAssetsOptions,
+  resolveStorageOptions
+  // resolveErrorOptions,
+];
+async function loadOptions(configOverrides = {}, opts = {}) {
+  const options = await _loadUserConfig(configOverrides, opts);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}) {
+  const presetOverride = configOverrides.preset || process.env.SILGI_PRESET;
+  if (configOverrides.dev) ;
+  configOverrides = klona(configOverrides);
+  globalThis.defineSilgiConfig = globalThis.defineSilgiConfig || ((c) => c);
+  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.SILGI_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
+  const { resolvePreset } = await import('silgi/presets');
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "silgi",
+    cwd: configOverrides.rootDir,
+    dotenv: configOverrides.dev,
+    extend: { extendKey: ["extends", "preset"] },
+    overrides: {
+      ...configOverrides,
+      preset: presetOverride
+    },
+    async defaultConfig({ configs }) {
+      const getConf = (key) => configs.main?.[key] ?? configs.rc?.[key] ?? configs.packageJson?.[key];
+      if (!compatibilityDate) {
+        compatibilityDate = getConf("compatibilityDate");
+      }
+      return {
+        // typescript: {
+        //   generateRuntimeConfigTypes:
+        //     !framework?.name || framework.name === 'nitro',
+        // },
+        preset: presetOverride || (await resolvePreset("", {
+          static: getConf("static"),
+          compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+        }))?._meta?.name
+      };
+    },
+    defaults: SilgiCLIDefaults,
+    jitiOptions: {
+      alias: {
+        "silgi": "silgi/config",
+        "silgi/config": "silgi/config"
+      }
+    },
+    async resolve(id) {
+      const preset = await resolvePreset(id, {
+        static: configOverrides.static,
+        compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+      });
+      if (preset) {
+        return {
+          config: klona(preset)
+        };
+      }
+    },
+    ...opts.c12
+  });
+  delete globalThis.defineSilgiConfig;
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || presetOverride;
+  options.preset = _presetName;
+  options.compatibilityDate = resolveCompatibilityDates(
+    compatibilityDate,
+    options.compatibilityDate
+  );
+  return options;
+}
+
+export { loadOptions as l };

package/dist/cli/prepare.mjs

@@ -6,12 +6,13 @@ import { promises, existsSync, readFileSync, writeFileSync, mkdirSync } from 'no
 import { readdir } from 'node:fs/promises';
 import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath, resolve as resolve$1 } from 'mlly';
 import { resolveAlias } from 'pathe/utils';
-import { relativeWithDot, isDirectory, writeFile, resolveAlias as resolveAlias$1, resolvePath as resolvePath$1, normalizeTemplate, useLogger } from 'silgi/kit';
+import { relativeWithDot, isDirectory, writeFile, resolveAlias as resolveAlias$1, resolvePath as resolvePath$1, normalizeTemplate, useLogger, addTemplate } from 'silgi/kit';
 import { toExports, scanExports, createUnimport } from 'unimport';
 import { createJiti } from 'dev-jiti';
 import { readPackageJSON } from 'pkg-types';
 import { hash } from 'ohash';
-import { s as silgiGenerateType, l as loadOptions } from './types.mjs';
+import { s as silgiGenerateType } from './types.mjs';
+import { c as commonArgs } from './common.mjs';
 import { consola } from 'consola';
 import { createHooks, createDebugger } from 'hookable';
 import { useSilgiCLI, silgiCLICtx } from 'silgi/core';
@@ -24,14 +25,15 @@ import ignore from 'ignore';
 import { parseSync } from '@oxc-parser/wasm';
 import { klona } from 'klona';
 import { createStorage, builtinDrivers } from 'unstorage';
+import { l as loadOptions } from './loader.mjs';
+import 'defu';
+import 'semver/functions/satisfies.js';
 import 'c12';
 import 'compatx';
 import 'klona/full';
 import 'std-env';
 import 'consola/utils';
 import 'escape-string-regexp';
-import 'defu';
-import 'semver/functions/satisfies.js';
 
 async function h3Framework(silgi, skip = false) {
   if (silgi.options.preset !== "h3" && skip === false)
@@ -822,18 +824,6 @@ async function writeTypesAndFiles(silgi) {
   await silgi.hooks.callHook("finish:types", readCore);
 }
 
-const commonArgs = {
-  dir: {
-    type: "string",
-    description: "project root directory"
-  },
-  _dir: {
-    type: "positional",
-    default: ".",
-    description: "project root directory (prefer using `--dir`)"
-  }
-};
-
 async function registerModuleExportScan(silgi) {
   silgi.hook("prepare:schema.ts", async (options) => {
     for (const module of silgi.scanModules) {
@@ -1545,6 +1535,19 @@ async function compileTemplate(template, ctx) {
   throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
 }
 
+async function commands(silgi) {
+  const commands2 = {
+    ...silgi.options.commands
+  };
+  await silgi.callHook("prepare:commands", commands2);
+  addTemplate({
+    filename: "cli.json",
+    where: ".silgi",
+    write: true,
+    getContents: () => JSON.stringify(commands2, null, 2)
+  });
+}
+
 const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
 async function scanAndSyncOptions(silgi) {
   const scannedModules = await scanModules(silgi);
@@ -1633,6 +1636,7 @@ async function createSilgiCLI(config = {}, opts = {}) {
   silgi.hooks.addHooks(silgi.options.hooks);
   await installModules(silgi);
   await silgi.hooks.callHook("scanFiles:done", silgi);
+  await commands(silgi);
   await generateApp(silgi);
   if (silgi.options.imports) {
     silgi.unimport = createUnimport(silgi.options.imports);