@akanjs/devkit 0.0.139 → 0.0.141

package/cjs/src/aiEditor.js

@@ -122,7 +122,7 @@ class AiSession {
       const stream = await AiSession.#chat.stream(this.messageHistory);
       let fullResponse = "", tokenIdx = 0;
       for await (const chunk of stream) {
-        if (loader.isSpinning())
+        if (loader.isSpinning() && chunk.content.length)
           loader.succeed(`${AiSession.#chat.model} responded`);
         const content = chunk.content;
         if (typeof content === "string") {

package/cjs/src/commandDecorators/argMeta.js

@@ -18,6 +18,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var argMeta_exports = {};
 __export(argMeta_exports, {
   App: () => App,
+  Argument: () => Argument,
   Exec: () => Exec,
   Lib: () => Lib,
   Option: () => Option,
@@ -30,7 +31,7 @@ __export(argMeta_exports, {
 });
 module.exports = __toCommonJS(argMeta_exports);
 var import_reflect_metadata = require("reflect-metadata");
-const argTypes = ["Option"];
+const argTypes = ["Argument", "Option"];
 const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg", "Exec"];
 const getArgMetas = (command, key) => {
   const allArgMetas = getArgMetasOnPrototype(command.prototype, key);
@@ -51,6 +52,7 @@ const getArg = (type) => function(name, argsOption = {}) {
     setArgMetasOnPrototype(prototype, key, argMetas);
   };
 };
+const Argument = getArg("Argument");
 const Option = getArg("Option");
 const createArgMetaDecorator = (type) => {
   return function(option = {}) {
@@ -70,6 +72,7 @@ const Workspace = createArgMetaDecorator("Workspace");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   App,
+  Argument,
   Exec,
   Lib,
   Option,

package/cjs/src/commandDecorators/command.js

@@ -55,6 +55,16 @@ const handleOption = (programCommand, argMeta) => {
   );
   return programCommand;
 };
+const handleArgument = (programCommand, argMeta) => {
+  const kebabName = camelToKebabCase(argMeta.name);
+  if ((argMeta.argsOption.type ?? "string") !== "string")
+    throw new Error(`Argument type must be string: ${argMeta.name}`);
+  programCommand.argument(
+    `[${kebabName}]`,
+    `${argMeta.argsOption.desc}${argMeta.argsOption.example ? ` (example: ${argMeta.argsOption.example})` : ""}`
+  );
+  return programCommand;
+};
 const convertOptionValue = (value, type) => {
   if (type === "string")
     return value;
@@ -91,7 +101,21 @@ const getOptionValue = async (argMeta, opt) => {
       return convertOptionValue(await (0, import_prompts.input)({ message }), type ?? "string");
   }
 };
-const getArgumentValue = async (argMeta, value, workspace) => {
+const getArgumentValue = async (argMeta, value) => {
+  const {
+    name,
+    argsOption: { default: defaultValue, type, desc, nullable, example, ask }
+  } = argMeta;
+  if (value !== void 0)
+    return value;
+  else if (defaultValue !== void 0)
+    return defaultValue;
+  else if (nullable)
+    return null;
+  const message = ask ? `${ask}: ` : desc ? `${desc}: ` : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+  return await (0, import_prompts.input)({ message });
+};
+const getInternalArgumentValue = async (argMeta, value, workspace) => {
   if (argMeta.type === "Workspace")
     return workspace;
   const sysType = argMeta.type.toLowerCase();
@@ -156,6 +180,7 @@ const getArgumentValue = async (argMeta, value, workspace) => {
 const runCommands = async (...commands) => {
   process.on("unhandledRejection", (error) => {
     console.error(import_chalk.default.red("[fatal]"), error);
+    process.exit(1);
   });
   const hasPackageJson = import_fs.default.existsSync(`${__dirname}/../package.json`);
   const version = hasPackageJson ? JSON.parse(import_fs.default.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
@@ -176,6 +201,8 @@ const runCommands = async (...commands) => {
         for (const argMeta of allArgMetas) {
           if (argMeta.type === "Option")
             programCommand = handleOption(programCommand, argMeta);
+          else if (argMeta.type === "Argument")
+            programCommand = handleArgument(programCommand, argMeta);
           else if (argMeta.type === "Workspace")
             continue;
           const sysType = argMeta.type.toLowerCase();
@@ -186,6 +213,7 @@ const runCommands = async (...commands) => {
         }
         programCommand = programCommand.option(`-v, --verbose [boolean]`, `verbose output`);
         programCommand.action(async (...args) => {
+          import_common.Logger.rawLog();
           const cmdArgs = args.slice(0, args.length - 2);
           const opt = args[args.length - 2];
           const commandArgs = [];
@@ -193,8 +221,14 @@ const runCommands = async (...commands) => {
           for (const argMeta of allArgMetas) {
             if (argMeta.type === "Option")
               commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt);
+            else if (argMeta.type === "Argument")
+              commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx]);
             else
-              commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
+              commandArgs[argMeta.idx] = await getInternalArgumentValue(
+                argMeta,
+                cmdArgs[argMeta.idx],
+                workspace
+              );
             if (commandArgs[argMeta.idx] instanceof import_executors.AppExecutor)
               process.env.NEXT_PUBLIC_APP_NAME = commandArgs[argMeta.idx].name;
             if (opt.verbose)
@@ -203,6 +237,7 @@ const runCommands = async (...commands) => {
           const cmd = new command();
           try {
             await cmd[targetMeta.key](...commandArgs);
+            import_common.Logger.rawLog();
           } catch (e) {
             const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
             import_common.Logger.error(`Command Error: ${import_chalk.default.red(errMsg)}`);

package/cjs/src/executors.js

@@ -71,13 +71,20 @@ class Executor {
     if (!import_fs.default.existsSync(cwdPath))
       import_fs.default.mkdirSync(cwdPath, { recursive: true });
   }
+  #stdout(data) {
+    if (Executor.verbose)
+      import_common.Logger.raw(import_chalk.default.dim(data.toString()));
+  }
+  #stderr(data) {
+    import_common.Logger.raw(import_chalk.default.red(data.toString()));
+  }
   exec(command, options = {}) {
     const proc = (0, import_child_process.exec)(command, { cwd: this.cwdPath, ...options });
     proc.stdout?.on("data", (data) => {
-      import_common.Logger.raw(import_chalk.default.dim(data.toString()));
+      this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(import_chalk.default.dim(data.toString()));
+      this.#stdout(data);
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -91,14 +98,14 @@ class Executor {
   spawn(command, args = [], options = {}) {
     const proc = (0, import_child_process.spawn)(command, args, {
       cwd: this.cwdPath,
-      stdio: Executor.verbose ? "inherit" : "ignore",
+      stdio: "inherit",
       ...options
     });
     proc.stdout?.on("data", (data) => {
-      import_common.Logger.raw(import_chalk.default.dim(data.toString()));
+      this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(import_chalk.default.dim(data.toString()));
+      this.#stderr(data);
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -112,14 +119,14 @@ class Executor {
   fork(modulePath, args = [], options = {}) {
     const proc = (0, import_child_process.fork)(modulePath, args, {
       cwd: this.cwdPath,
-      stdio: Executor.verbose ? ["ignore", "inherit", "inherit", "ipc"] : ["ignore", "ignore", "ignore", "ipc"],
+      stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      this.#stderr(data);
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -144,6 +151,20 @@ class Executor {
     const readPath = this.#getPath(filePath);
     return import_fs.default.existsSync(readPath);
   }
+  remove(filePath) {
+    const readPath = this.#getPath(filePath);
+    if (import_fs.default.existsSync(readPath))
+      import_fs.default.unlinkSync(readPath);
+    this.logger.verbose(`Remove file ${readPath}`);
+    return this;
+  }
+  removeDir(dirPath) {
+    const readPath = this.#getPath(dirPath);
+    if (import_fs.default.existsSync(readPath))
+      import_fs.default.rmSync(readPath, { recursive: true });
+    this.logger.verbose(`Remove directory ${readPath}`);
+    return this;
+  }
   writeFile(filePath, content, { overwrite = true } = {}) {
     const writePath = this.#getPath(filePath);
     const dir = import_path.default.dirname(writePath);
@@ -364,23 +385,41 @@ class WorkspaceExecutor extends Executor {
   }
   setTsPaths(type, name) {
     const rootTsConfig = this.readJson("tsconfig.json");
-    if (type === "lib")
+    if (type === "lib" || type === "pkg")
       rootTsConfig.compilerOptions.paths[`@${name}`] = [`${type}s/${name}/index.ts`];
     rootTsConfig.compilerOptions.paths[`@${name}/*`] = [`${type}s/${name}/*`];
+    if (rootTsConfig.references) {
+      if (!rootTsConfig.references.some((ref) => ref.path === `./${type}s/${name}/tsconfig.json`))
+        rootTsConfig.references.push({ path: `./${type}s/${name}/tsconfig.json` });
+    }
+    this.writeJson("tsconfig.json", rootTsConfig);
+    return this;
+  }
+  unsetTsPaths(type, name) {
+    const rootTsConfig = this.readJson("tsconfig.json");
+    const filteredKeys = Object.keys(rootTsConfig.compilerOptions.paths).filter((key) => !key.startsWith(`@${name}`));
+    rootTsConfig.compilerOptions.paths = Object.fromEntries(
+      filteredKeys.map((key) => [key, rootTsConfig.compilerOptions.paths[key]])
+    );
+    if (rootTsConfig.references) {
+      rootTsConfig.references = rootTsConfig.references.filter(
+        (ref) => !ref.path.startsWith(`./${type}s/${name}`)
+      );
+    }
     this.writeJson("tsconfig.json", rootTsConfig);
     return this;
   }
   async getDirInModule(basePath, name) {
-    const AVOID_DIRS = ["__lib", "__scalar", `_${name}`];
+    const AVOID_DIRS = ["__lib", "__scalar", `_`, `_${name}`];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
       const dirs = await import_promises.default.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
-          if (AVOID_DIRS.includes(dir))
+          if (dir.includes("_") || AVOID_DIRS.includes(dir))
             return;
           const dirPath = import_path.default.join(dirname, dir);
           if (import_fs.default.lstatSync(dirPath).isDirectory()) {
-            results.push(`${name}/${prefix}${dir}`);
+            results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
               await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
           }
@@ -427,6 +466,22 @@ class WorkspaceExecutor extends Executor {
     ];
     return scalarConstantExampleFiles;
   }
+  async getConstantFiles() {
+    const [appNames, libNames] = await this.getSyss();
+    const moduleConstantExampleFiles = [
+      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getConstantFiles()))).flat(),
+      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getConstantFiles()))).flat()
+    ];
+    return moduleConstantExampleFiles;
+  }
+  async getDictionaryFiles() {
+    const [appNames, libNames] = await this.getSyss();
+    const moduleDictionaryExampleFiles = [
+      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getDictionaryFiles()))).flat(),
+      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getDictionaryFiles()))).flat()
+    ];
+    return moduleDictionaryExampleFiles;
+  }
   async getViewFiles() {
     const [appNames, libNames] = await this.getSyss();
     const viewExampleFiles = [
@@ -656,9 +711,15 @@ class SysExecutor extends Executor {
   }
   async getScalarDictionaryFiles() {
     const scalarModules = await this.getScalarModules();
-    return scalarModules.map(
-      (scalarModule) => this.getLocalFile(`lib/__scalar/${scalarModule}/${scalarModule}.dictionary.ts`)
-    );
+    return scalarModules.map((scalarModule) => this.getLocalFile(`lib/${scalarModule}/${scalarModule}.dictionary.ts`));
+  }
+  async getConstantFiles() {
+    const modules = await this.getModules();
+    return modules.map((module2) => this.getLocalFile(`lib/${module2}/${module2}.constant.ts`));
+  }
+  async getDictionaryFiles() {
+    const modules = await this.getModules();
+    return modules.map((module2) => this.getLocalFile(`lib/${module2}/${module2}.dictionary.ts`));
   }
   setTsPaths() {
     this.workspace.setTsPaths(this.type, this.name);

package/esm/src/aiEditor.js

@@ -89,7 +89,7 @@ class AiSession {
       const stream = await AiSession.#chat.stream(this.messageHistory);
       let fullResponse = "", tokenIdx = 0;
       for await (const chunk of stream) {
-        if (loader.isSpinning())
+        if (loader.isSpinning() && chunk.content.length)
           loader.succeed(`${AiSession.#chat.model} responded`);
         const content = chunk.content;
         if (typeof content === "string") {

package/esm/src/commandDecorators/argMeta.js

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-const argTypes = ["Option"];
+const argTypes = ["Argument", "Option"];
 const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg", "Exec"];
 const getArgMetas = (command, key) => {
   const allArgMetas = getArgMetasOnPrototype(command.prototype, key);
@@ -20,6 +20,7 @@ const getArg = (type) => function(name, argsOption = {}) {
     setArgMetasOnPrototype(prototype, key, argMetas);
   };
 };
+const Argument = getArg("Argument");
 const Option = getArg("Option");
 const createArgMetaDecorator = (type) => {
   return function(option = {}) {
@@ -38,6 +39,7 @@ const Pkg = createArgMetaDecorator("Pkg");
 const Workspace = createArgMetaDecorator("Workspace");
 export {
   App,
+  Argument,
   Exec,
   Lib,
   Option,

package/esm/src/commandDecorators/command.js

@@ -23,6 +23,16 @@ const handleOption = (programCommand, argMeta) => {
   );
   return programCommand;
 };
+const handleArgument = (programCommand, argMeta) => {
+  const kebabName = camelToKebabCase(argMeta.name);
+  if ((argMeta.argsOption.type ?? "string") !== "string")
+    throw new Error(`Argument type must be string: ${argMeta.name}`);
+  programCommand.argument(
+    `[${kebabName}]`,
+    `${argMeta.argsOption.desc}${argMeta.argsOption.example ? ` (example: ${argMeta.argsOption.example})` : ""}`
+  );
+  return programCommand;
+};
 const convertOptionValue = (value, type) => {
   if (type === "string")
     return value;
@@ -59,7 +69,21 @@ const getOptionValue = async (argMeta, opt) => {
       return convertOptionValue(await input({ message }), type ?? "string");
   }
 };
-const getArgumentValue = async (argMeta, value, workspace) => {
+const getArgumentValue = async (argMeta, value) => {
+  const {
+    name,
+    argsOption: { default: defaultValue, type, desc, nullable, example, ask }
+  } = argMeta;
+  if (value !== void 0)
+    return value;
+  else if (defaultValue !== void 0)
+    return defaultValue;
+  else if (nullable)
+    return null;
+  const message = ask ? `${ask}: ` : desc ? `${desc}: ` : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+  return await input({ message });
+};
+const getInternalArgumentValue = async (argMeta, value, workspace) => {
   if (argMeta.type === "Workspace")
     return workspace;
   const sysType = argMeta.type.toLowerCase();
@@ -124,6 +148,7 @@ const getArgumentValue = async (argMeta, value, workspace) => {
 const runCommands = async (...commands) => {
   process.on("unhandledRejection", (error) => {
     console.error(chalk.red("[fatal]"), error);
+    process.exit(1);
   });
   const hasPackageJson = fs.existsSync(`${__dirname}/../package.json`);
   const version = hasPackageJson ? JSON.parse(fs.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
@@ -144,6 +169,8 @@ const runCommands = async (...commands) => {
         for (const argMeta of allArgMetas) {
           if (argMeta.type === "Option")
             programCommand = handleOption(programCommand, argMeta);
+          else if (argMeta.type === "Argument")
+            programCommand = handleArgument(programCommand, argMeta);
           else if (argMeta.type === "Workspace")
             continue;
           const sysType = argMeta.type.toLowerCase();
@@ -154,6 +181,7 @@ const runCommands = async (...commands) => {
         }
         programCommand = programCommand.option(`-v, --verbose [boolean]`, `verbose output`);
         programCommand.action(async (...args) => {
+          Logger.rawLog();
           const cmdArgs = args.slice(0, args.length - 2);
           const opt = args[args.length - 2];
           const commandArgs = [];
@@ -161,8 +189,14 @@ const runCommands = async (...commands) => {
           for (const argMeta of allArgMetas) {
             if (argMeta.type === "Option")
               commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt);
+            else if (argMeta.type === "Argument")
+              commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx]);
             else
-              commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
+              commandArgs[argMeta.idx] = await getInternalArgumentValue(
+                argMeta,
+                cmdArgs[argMeta.idx],
+                workspace
+              );
             if (commandArgs[argMeta.idx] instanceof AppExecutor)
               process.env.NEXT_PUBLIC_APP_NAME = commandArgs[argMeta.idx].name;
             if (opt.verbose)
@@ -171,6 +205,7 @@ const runCommands = async (...commands) => {
           const cmd = new command();
           try {
             await cmd[targetMeta.key](...commandArgs);
+            Logger.rawLog();
           } catch (e) {
             const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
             Logger.error(`Command Error: ${chalk.red(errMsg)}`);

package/esm/src/executors.js

@@ -37,13 +37,20 @@ class Executor {
     if (!fs.existsSync(cwdPath))
       fs.mkdirSync(cwdPath, { recursive: true });
   }
+  #stdout(data) {
+    if (Executor.verbose)
+      Logger.raw(chalk.dim(data.toString()));
+  }
+  #stderr(data) {
+    Logger.raw(chalk.red(data.toString()));
+  }
   exec(command, options = {}) {
     const proc = exec(command, { cwd: this.cwdPath, ...options });
     proc.stdout?.on("data", (data) => {
-      Logger.raw(chalk.dim(data.toString()));
+      this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
-      Logger.raw(chalk.dim(data.toString()));
+      this.#stdout(data);
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -57,14 +64,14 @@ class Executor {
   spawn(command, args = [], options = {}) {
     const proc = spawn(command, args, {
       cwd: this.cwdPath,
-      stdio: Executor.verbose ? "inherit" : "ignore",
+      stdio: "inherit",
       ...options
     });
     proc.stdout?.on("data", (data) => {
-      Logger.raw(chalk.dim(data.toString()));
+      this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
-      Logger.raw(chalk.dim(data.toString()));
+      this.#stderr(data);
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -78,14 +85,14 @@ class Executor {
   fork(modulePath, args = [], options = {}) {
     const proc = fork(modulePath, args, {
       cwd: this.cwdPath,
-      stdio: Executor.verbose ? ["ignore", "inherit", "inherit", "ipc"] : ["ignore", "ignore", "ignore", "ipc"],
+      stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
-      Logger.raw(data.toString());
+      this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
-      Logger.raw(data.toString());
+      this.#stderr(data);
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -110,6 +117,20 @@ class Executor {
     const readPath = this.#getPath(filePath);
     return fs.existsSync(readPath);
   }
+  remove(filePath) {
+    const readPath = this.#getPath(filePath);
+    if (fs.existsSync(readPath))
+      fs.unlinkSync(readPath);
+    this.logger.verbose(`Remove file ${readPath}`);
+    return this;
+  }
+  removeDir(dirPath) {
+    const readPath = this.#getPath(dirPath);
+    if (fs.existsSync(readPath))
+      fs.rmSync(readPath, { recursive: true });
+    this.logger.verbose(`Remove directory ${readPath}`);
+    return this;
+  }
   writeFile(filePath, content, { overwrite = true } = {}) {
     const writePath = this.#getPath(filePath);
     const dir = path.dirname(writePath);
@@ -330,23 +351,41 @@ class WorkspaceExecutor extends Executor {
   }
   setTsPaths(type, name) {
     const rootTsConfig = this.readJson("tsconfig.json");
-    if (type === "lib")
+    if (type === "lib" || type === "pkg")
       rootTsConfig.compilerOptions.paths[`@${name}`] = [`${type}s/${name}/index.ts`];
     rootTsConfig.compilerOptions.paths[`@${name}/*`] = [`${type}s/${name}/*`];
+    if (rootTsConfig.references) {
+      if (!rootTsConfig.references.some((ref) => ref.path === `./${type}s/${name}/tsconfig.json`))
+        rootTsConfig.references.push({ path: `./${type}s/${name}/tsconfig.json` });
+    }
+    this.writeJson("tsconfig.json", rootTsConfig);
+    return this;
+  }
+  unsetTsPaths(type, name) {
+    const rootTsConfig = this.readJson("tsconfig.json");
+    const filteredKeys = Object.keys(rootTsConfig.compilerOptions.paths).filter((key) => !key.startsWith(`@${name}`));
+    rootTsConfig.compilerOptions.paths = Object.fromEntries(
+      filteredKeys.map((key) => [key, rootTsConfig.compilerOptions.paths[key]])
+    );
+    if (rootTsConfig.references) {
+      rootTsConfig.references = rootTsConfig.references.filter(
+        (ref) => !ref.path.startsWith(`./${type}s/${name}`)
+      );
+    }
     this.writeJson("tsconfig.json", rootTsConfig);
     return this;
   }
   async getDirInModule(basePath, name) {
-    const AVOID_DIRS = ["__lib", "__scalar", `_${name}`];
+    const AVOID_DIRS = ["__lib", "__scalar", `_`, `_${name}`];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
       const dirs = await fsPromise.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
-          if (AVOID_DIRS.includes(dir))
+          if (dir.includes("_") || AVOID_DIRS.includes(dir))
             return;
           const dirPath = path.join(dirname, dir);
           if (fs.lstatSync(dirPath).isDirectory()) {
-            results.push(`${name}/${prefix}${dir}`);
+            results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
               await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
           }
@@ -393,6 +432,22 @@ class WorkspaceExecutor extends Executor {
     ];
     return scalarConstantExampleFiles;
   }
+  async getConstantFiles() {
+    const [appNames, libNames] = await this.getSyss();
+    const moduleConstantExampleFiles = [
+      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getConstantFiles()))).flat(),
+      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getConstantFiles()))).flat()
+    ];
+    return moduleConstantExampleFiles;
+  }
+  async getDictionaryFiles() {
+    const [appNames, libNames] = await this.getSyss();
+    const moduleDictionaryExampleFiles = [
+      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getDictionaryFiles()))).flat(),
+      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getDictionaryFiles()))).flat()
+    ];
+    return moduleDictionaryExampleFiles;
+  }
   async getViewFiles() {
     const [appNames, libNames] = await this.getSyss();
     const viewExampleFiles = [
@@ -622,9 +677,15 @@ class SysExecutor extends Executor {
   }
   async getScalarDictionaryFiles() {
     const scalarModules = await this.getScalarModules();
-    return scalarModules.map(
-      (scalarModule) => this.getLocalFile(`lib/__scalar/${scalarModule}/${scalarModule}.dictionary.ts`)
-    );
+    return scalarModules.map((scalarModule) => this.getLocalFile(`lib/${scalarModule}/${scalarModule}.dictionary.ts`));
+  }
+  async getConstantFiles() {
+    const modules = await this.getModules();
+    return modules.map((module) => this.getLocalFile(`lib/${module}/${module}.constant.ts`));
+  }
+  async getDictionaryFiles() {
+    const modules = await this.getModules();
+    return modules.map((module) => this.getLocalFile(`lib/${module}/${module}.dictionary.ts`));
   }
   setTsPaths() {
     this.workspace.setTsPaths(this.type, this.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "0.0.139",
+  "version": "0.0.141",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"

package/src/commandDecorators/argMeta.d.ts

@@ -1,7 +1,7 @@
 import "reflect-metadata";
 import type { AppExecutor, Executor, LibExecutor, PkgExecutor, SysExecutor, WorkspaceExecutor } from "../executors";
 import type { Type } from "./types";
-export declare const argTypes: readonly ["Option"];
+export declare const argTypes: readonly ["Argument", "Option"];
 export type ArgType = (typeof argTypes)[number];
 export declare const internalArgTypes: readonly ["Workspace", "App", "Lib", "Sys", "Pkg", "Exec"];
 export type InternalArgType = (typeof internalArgTypes)[number];
@@ -31,6 +31,7 @@ export interface InternalArgMeta {
     };
 }
 export declare const getArgMetas: (command: Type, key: string) => [(ArgMeta | InternalArgMeta)[], ArgMeta[], InternalArgMeta[]];
+export declare const Argument: (name: string, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
 export declare const Option: (name: string, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
 export declare const App: (option?: {
     nullable?: boolean;

package/src/executors.d.ts

@@ -28,6 +28,8 @@ export declare class Executor {
     fork(modulePath: string, args?: string[], options?: ForkOptions): Promise<unknown>;
     mkdir(dirPath: string): this;
     exists(filePath: string): boolean;
+    remove(filePath: string): this;
+    removeDir(dirPath: string): this;
     writeFile(filePath: string, content: string | object, { overwrite }?: {
         overwrite?: boolean;
     }): this;
@@ -71,7 +73,7 @@ export declare class WorkspaceExecutor extends Executor {
     getBaseDevEnv(): {
         repoName: string;
         serveDomain: string;
-        env: "testing" | "local" | "debug" | "develop" | "main";
+        env: "debug" | "testing" | "local" | "develop" | "main";
         name?: string | undefined;
     };
     scan(): Promise<WorkspaceScanResult>;
@@ -80,7 +82,8 @@ export declare class WorkspaceExecutor extends Executor {
     getSyss(): Promise<[string[], string[]]>;
     getPkgs(): Promise<string[]>;
     getExecs(): Promise<[string[], string[], string[]]>;
-    setTsPaths(type: "app" | "lib", name: string): this;
+    setTsPaths(type: "app" | "lib" | "pkg", name: string): this;
+    unsetTsPaths(type: "app" | "lib" | "pkg", name: string): this;
     getDirInModule(basePath: string, name: string): Promise<string[]>;
     commit(message: string, { init, add }?: {
         init?: boolean;
@@ -90,6 +93,14 @@ export declare class WorkspaceExecutor extends Executor {
         filepath: string;
         content: string;
     }[]>;
+    getConstantFiles(): Promise<{
+        filepath: string;
+        content: string;
+    }[]>;
+    getDictionaryFiles(): Promise<{
+        filepath: string;
+        content: string;
+    }[]>;
     getViewFiles(): Promise<{
         filepath: string;
         content: string;
@@ -144,6 +155,14 @@ export declare class SysExecutor extends Executor {
         filepath: string;
         content: string;
     }[]>;
+    getConstantFiles(): Promise<{
+        filepath: string;
+        content: string;
+    }[]>;
+    getDictionaryFiles(): Promise<{
+        filepath: string;
+        content: string;
+    }[]>;
     setTsPaths(): this;
 }
 interface AppExecutorOptions {
@@ -155,7 +174,7 @@ export declare class AppExecutor extends SysExecutor {
     emoji: string;
     constructor({ workspace, name }: AppExecutorOptions);
     static from(executor: SysExecutor | WorkspaceExecutor, name: string): AppExecutor;
-    getEnv(): "testing" | "local" | "debug" | "develop" | "main";
+    getEnv(): "debug" | "testing" | "local" | "develop" | "main";
     getConfig(command?: string): Promise<AppConfigResult>;
     syncAssets(libDeps: string[]): Promise<void>;
 }