@akanjs/devkit 0.0.142 → 0.0.144

package/cjs/src/executors.js

@@ -30,6 +30,7 @@ __export(executors_exports, {
   AppExecutor: () => AppExecutor,
   Executor: () => Executor,
   LibExecutor: () => LibExecutor,
+  ModuleExecutor: () => ModuleExecutor,
   PkgExecutor: () => PkgExecutor,
   SysExecutor: () => SysExecutor,
   WorkspaceExecutor: () => WorkspaceExecutor,
@@ -45,13 +46,16 @@ var import_fs = __toESM(require("fs"));
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
 var import_dependencyScanner = require("./dependencyScanner");
+var import_linter = require("./linter");
 var import_spinner = require("./spinner");
+var import_typeChecker = require("./typeChecker");
 const execEmoji = {
   workspace: "\u{1F3E0}",
   app: "\u{1F680}",
   lib: "\u{1F527}",
   pkg: "\u{1F4E6}",
   dist: "\u{1F4BF}",
+  module: "\u2699\uFE0F",
   default: "\u2708\uFE0F"
   // for sys executor
 };
@@ -64,6 +68,8 @@ class Executor {
   logger;
   cwdPath;
   emoji = execEmoji.default;
+  typeChecker = null;
+  linter = null;
   constructor(name, cwdPath) {
     this.name = name;
     this.logger = new import_common.Logger(name);
@@ -98,28 +104,32 @@ class Executor {
   spawn(command, args = [], options = {}) {
     const proc = (0, import_child_process.spawn)(command, args, {
       cwd: this.cwdPath,
-      stdio: "inherit",
+      // stdio: "inherit",
       ...options
     });
+    let stdout = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data;
+    });
     proc.stdout?.on("data", (data) => {
       this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
-      this.#stderr(data);
+      this.#stdout(data);
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
         if (!!code || signal)
-          reject({ code, signal });
+          reject({ code, signal, stdout });
         else
-          resolve({ code, signal });
+          resolve(stdout);
       });
     });
   }
   fork(modulePath, args = [], options = {}) {
     const proc = (0, import_child_process.fork)(modulePath, args, {
       cwd: this.cwdPath,
-      stdio: ["ignore", "inherit", "inherit", "ipc"],
+      // stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
@@ -137,45 +147,70 @@ class Executor {
       });
     });
   }
-  #getPath(filePath) {
-    return import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+  getPath(filePath) {
+    if (import_path.default.isAbsolute(filePath))
+      return filePath;
+    const baseParts = this.cwdPath.split("/").filter(Boolean);
+    const targetParts = filePath.split("/").filter(Boolean);
+    let overlapLength = 0;
+    for (let i = 1; i <= Math.min(baseParts.length, targetParts.length); i++) {
+      let isOverlap = true;
+      for (let j = 0; j < i; j++)
+        if (baseParts[baseParts.length - i + j] !== targetParts[j]) {
+          isOverlap = false;
+          break;
+        }
+      if (isOverlap)
+        overlapLength = i;
+    }
+    const result = overlapLength > 0 ? `/${[...baseParts, ...targetParts.slice(overlapLength)].join("/")}` : `${this.cwdPath}/${filePath}`;
+    return result.replace(/\/+/g, "/");
   }
   mkdir(dirPath) {
-    const writePath = this.#getPath(dirPath);
+    const writePath = this.getPath(dirPath);
     if (!import_fs.default.existsSync(writePath))
       import_fs.default.mkdirSync(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
+  async readdir(dirPath) {
+    const readPath = this.getPath(dirPath);
+    try {
+      return await import_promises.default.readdir(readPath);
+    } catch (error) {
+      return [];
+    }
+  }
   exists(filePath) {
-    const readPath = this.#getPath(filePath);
+    const readPath = this.getPath(filePath);
     return import_fs.default.existsSync(readPath);
   }
   remove(filePath) {
-    const readPath = this.#getPath(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);
+    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 writePath = this.getPath(filePath);
     const dir = import_path.default.dirname(writePath);
     if (!import_fs.default.existsSync(dir))
       import_fs.default.mkdirSync(dir, { recursive: true });
-    const contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+    let contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
     if (import_fs.default.existsSync(writePath)) {
       const currentContent = import_fs.default.readFileSync(writePath, "utf8");
-      if (currentContent === contentStr || !overwrite)
+      if (currentContent === contentStr || !overwrite) {
         this.logger.verbose(`File ${writePath} is unchanged`);
-      else {
+        contentStr = import_fs.default.readFileSync(writePath, "utf-8");
+      } else {
         import_fs.default.writeFileSync(writePath, contentStr, "utf8");
         this.logger.verbose(`File ${writePath} is changed`);
       }
@@ -183,28 +218,28 @@ class Executor {
       import_fs.default.writeFileSync(writePath, contentStr, "utf8");
       this.logger.verbose(`File ${writePath} is created`);
     }
-    return this;
+    return { filePath: writePath, content: contentStr };
   }
   writeJson(filePath, content) {
     this.writeFile(filePath, JSON.stringify(content, null, 2) + "\n");
     return this;
   }
-  getLocalFile(filePath) {
-    const filepath = import_path.default.isAbsolute(filePath) ? filePath : filePath.replace(this.cwdPath, "");
-    const content = this.readFile(filepath);
-    return { filepath, content };
+  getLocalFile(targetPath) {
+    const filePath = import_path.default.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
+    const content = this.readFile(filePath);
+    return { filePath, content };
   }
   readFile(filePath) {
-    const readPath = this.#getPath(filePath);
+    const readPath = this.getPath(filePath);
     return import_fs.default.readFileSync(readPath, "utf8");
   }
   readJson(filePath) {
-    const readPath = this.#getPath(filePath);
+    const readPath = this.getPath(filePath);
     return JSON.parse(import_fs.default.readFileSync(readPath, "utf8"));
   }
   async cp(srcPath, destPath) {
-    const src = this.#getPath(srcPath);
-    const dest = this.#getPath(destPath);
+    const src = this.getPath(srcPath);
+    const dest = this.getPath(destPath);
     await import_promises.default.cp(src, dest, { recursive: true });
   }
   log(msg) {
@@ -240,7 +275,7 @@ class Executor {
       const getContent = require(templatePath);
       const result = getContent.default(scanResult ?? null, dict);
       if (result === null)
-        return;
+        return null;
       const filename = typeof result === "object" ? result.filename : import_path.default.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
       const dirname = import_path.default.dirname(targetPath);
@@ -249,7 +284,7 @@ class Executor {
         `${dirname}/${filename}`
       );
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
-      this.writeFile(convertedTargetPath, content, { overwrite });
+      return this.writeFile(convertedTargetPath, content, { overwrite });
     } else if (targetPath.endsWith(".template")) {
       const content = await import_promises.default.readFile(templatePath, "utf8");
       const convertedTargetPath = Object.entries(dict).reduce(
@@ -261,10 +296,11 @@ class Executor {
         content
       );
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
-      this.writeFile(convertedTargetPath, convertedContent, { overwrite });
-    }
+      return this.writeFile(convertedTargetPath, convertedContent, { overwrite });
+    } else
+      return null;
   }
-  async applyTemplate({
+  async _applyTemplate({
     basePath,
     template,
     scanResult,
@@ -274,22 +310,24 @@ class Executor {
     const templatePath = `${__dirname}/src/templates${template ? `/${template}` : ""}`.replace(".ts", ".js");
     if (import_fs.default.statSync(templatePath).isFile()) {
       const filename = import_path.default.basename(templatePath);
-      await this.#applyTemplateFile(
+      const fileContent = await this.#applyTemplateFile(
         { templatePath, targetPath: import_path.default.join(basePath, filename), scanResult, overwrite },
         dict
       );
+      return fileContent ? [fileContent] : [];
     } else {
-      const subdirs = await import_promises.default.readdir(templatePath);
-      await Promise.all(
+      const subdirs = await this.readdir(templatePath);
+      const fileContents = (await Promise.all(
         subdirs.map(async (subdir) => {
           const subpath = import_path.default.join(templatePath, subdir);
-          if (import_fs.default.statSync(subpath).isFile())
-            await this.#applyTemplateFile(
+          if (import_fs.default.statSync(subpath).isFile()) {
+            const fileContent = await this.#applyTemplateFile(
               { templatePath: subpath, targetPath: import_path.default.join(basePath, subdir), scanResult, overwrite },
               dict
             );
-          else
-            await this.applyTemplate({
+            return fileContent ? [fileContent] : [];
+          } else
+            return await this._applyTemplate({
               basePath: import_path.default.join(basePath, subdir),
               template: import_path.default.join(template, subdir),
               scanResult,
@@ -297,9 +335,41 @@ class Executor {
               overwrite
             });
         })
-      );
+      )).flat();
+      return fileContents;
     }
   }
+  async applyTemplate(options) {
+    const dict = {
+      ...options.dict ?? {},
+      ...Object.fromEntries(
+        Object.entries(options.dict ?? {}).map(([key, value]) => [(0, import_common.capitalize)(key), (0, import_common.capitalize)(value)])
+      )
+    };
+    return this._applyTemplate({ ...options, dict });
+  }
+  getTypeChecker() {
+    this.typeChecker ??= new import_typeChecker.TypeChecker(this);
+    return this.typeChecker;
+  }
+  typeCheck(filePath) {
+    const path2 = this.getPath(filePath);
+    const typeChecker = this.getTypeChecker();
+    const { diagnostics, errors, warnings } = typeChecker.check(path2);
+    const message = typeChecker.formatDiagnostics(diagnostics);
+    return { diagnostics, errors, warnings, message };
+  }
+  getLinter() {
+    this.linter ??= new import_linter.Linter(this.cwdPath);
+    return this.linter;
+  }
+  async lint(filePath, { fix = false, dryRun = false } = {}) {
+    const path2 = this.getPath(filePath);
+    const linter = this.getLinter();
+    const { results, errors, warnings } = await linter.lint(path2, { fix, dryRun });
+    const message = linter.formatLintResults(results);
+    return { results, message, errors, warnings };
+  }
 }
 class WorkspaceExecutor extends Executor {
   workspaceRoot;
@@ -412,7 +482,7 @@ class WorkspaceExecutor extends Executor {
   async getDirInModule(basePath, name) {
     const AVOID_DIRS = ["__lib", "__scalar", `_`, `_${name}`];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await import_promises.default.readdir(dirname);
+      const dirs = await this.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
           if (dir.includes("_") || AVOID_DIRS.includes(dir))
@@ -439,7 +509,7 @@ class WorkspaceExecutor extends Executor {
   async #getDirHasFile(basePath, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "./next"];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await import_promises.default.readdir(dirname);
+      const dirs = await this.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
           if (AVOID_DIRS.includes(dir))
@@ -537,14 +607,14 @@ class SysExecutor extends Executor {
     if (!import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar`))
       import_fs.default.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
     const files = (0, import_config.getDefaultFileScan)();
-    const dirnames = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter(
+    const dirnames = (await this.readdir("lib")).filter(
       (name) => import_fs.default.lstatSync(`${this.cwdPath}/lib/${name}`).isDirectory()
     );
     const databaseDirs = dirnames.filter((name) => !name.startsWith("_"));
     const serviceDirs = dirnames.filter((name) => name.startsWith("_") && !name.startsWith("__"));
     await Promise.all(
       databaseDirs.map(async (name) => {
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", name));
+        const filenames = await this.readdir(import_path.default.join("lib", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.databases.push(name);
@@ -566,7 +636,7 @@ class SysExecutor extends Executor {
     await Promise.all(
       serviceDirs.map(async (dirname) => {
         const name = dirname.slice(1);
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", dirname));
+        const filenames = await this.readdir(import_path.default.join("lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -581,12 +651,10 @@ class SysExecutor extends Executor {
         });
       })
     );
-    const scalarDirs = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
-      (name) => !name.startsWith("_")
-    );
+    const scalarDirs = (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_"));
     await Promise.all(
       scalarDirs.map(async (name) => {
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib/__scalar", name));
+        const filenames = await this.readdir(import_path.default.join("lib/__scalar", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.scalars.push(name);
@@ -633,11 +701,11 @@ class SysExecutor extends Executor {
       dependencies: [...npmDepSet].filter((dep) => !dep.startsWith("@akanjs")),
       libs: Object.fromEntries(akanConfig.libs.map((libName) => [libName, libScanResults[libName]]))
     };
-    await this.applyTemplate({ basePath: "lib", template: "lib", scanResult });
-    await this.applyTemplate({ basePath: ".", template: "server.ts", scanResult });
-    await this.applyTemplate({ basePath: ".", template: "client.ts", scanResult });
+    await this._applyTemplate({ basePath: "lib", template: "lib", scanResult });
+    await this._applyTemplate({ basePath: ".", template: "server.ts", scanResult });
+    await this._applyTemplate({ basePath: ".", template: "client.ts", scanResult });
     if (this.type === "lib")
-      await this.applyTemplate({ basePath: ".", template: "index.ts", scanResult });
+      await this._applyTemplate({ basePath: ".", template: "index.ts", scanResult });
     this.writeJson(`akan.${this.type}.json`, scanResult);
     if (this.type === "app")
       return scanResult;
@@ -660,33 +728,33 @@ class SysExecutor extends Executor {
     this.writeJson("package.json", libPkgJsonWithDeps);
     return scanResult;
   }
-  getLocalFile(filePath) {
-    const filepath = import_path.default.isAbsolute(filePath) ? filePath : `${this.type}s/${this.name}/${filePath}`;
-    const content = this.workspace.readFile(filepath);
-    return { filepath, content };
+  getLocalFile(targetPath) {
+    const filePath = import_path.default.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
+    const content = this.workspace.readFile(filePath);
+    return { filePath, content };
   }
   async getDatabaseModules() {
-    const databaseModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
+    const databaseModules = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
     return databaseModules;
   }
   async getServiceModules() {
-    const serviceModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
+    const serviceModules = (await this.readdir("lib")).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
     return serviceModules;
   }
   async getScalarModules() {
-    const scalarModules = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
+    const scalarModules = (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
     return scalarModules;
   }
   async getViewComponents() {
-    const viewComponents = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.View.tsx`));
+    const viewComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.View.tsx`));
     return viewComponents;
   }
   async getUnitComponents() {
-    const unitComponents = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`));
+    const unitComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`));
     return unitComponents;
   }
   async getTemplateComponents() {
-    const templateComponents = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`));
+    const templateComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`));
     return templateComponents;
   }
   async getViewsSourceCode() {
@@ -717,10 +785,35 @@ class SysExecutor extends Executor {
     const modules = await this.getModules();
     return modules.map((module2) => this.getLocalFile(`lib/${module2}/${module2}.constant.ts`));
   }
+  async getConstantFilesWithLibs() {
+    const config = await this.getConfig();
+    const sysContantFiles = await this.getConstantFiles();
+    const sysScalarConstantFiles = await this.getScalarConstantFiles();
+    const libConstantFiles = await Promise.all(
+      config.libs.map(async (lib) => [
+        ...await LibExecutor.from(this, lib).getConstantFiles(),
+        ...await LibExecutor.from(this, lib).getScalarConstantFiles()
+      ])
+    );
+    return [...sysContantFiles, ...sysScalarConstantFiles, ...libConstantFiles.flat()];
+  }
   async getDictionaryFiles() {
     const modules = await this.getModules();
     return modules.map((module2) => this.getLocalFile(`lib/${module2}/${module2}.dictionary.ts`));
   }
+  async applyTemplate(options) {
+    const dict = {
+      ...options.dict ?? {},
+      ...Object.fromEntries(
+        Object.entries(options.dict ?? {}).map(([key, value]) => [(0, import_common.capitalize)(key), (0, import_common.capitalize)(value)])
+      )
+    };
+    const akanConfig = await this.getConfig();
+    const scanResult = await this.scan({ akanConfig });
+    const fileContents = await this._applyTemplate({ ...options, scanResult, dict });
+    await this.scan({ akanConfig });
+    return fileContents;
+  }
   setTsPaths() {
     this.workspace.setTsPaths(this.type, this.name);
     return this;
@@ -826,11 +919,23 @@ class PkgExecutor extends Executor {
     return pkgScanResult;
   }
 }
+class ModuleExecutor extends Executor {
+  sys;
+  emoji = execEmoji.module;
+  constructor({ sys, name }) {
+    super(name, `${sys.workspace.workspaceRoot}/${sys.type}s/${sys.name}/lib/${name}`);
+    this.sys = sys;
+  }
+  static from(sysExecutor, name) {
+    return new ModuleExecutor({ sys: sysExecutor, name });
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AppExecutor,
   Executor,
   LibExecutor,
+  ModuleExecutor,
   PkgExecutor,
   SysExecutor,
   WorkspaceExecutor,

package/cjs/src/guideline.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var guideline_exports = {};
+module.exports = __toCommonJS(guideline_exports);

package/cjs/src/index.js

@@ -32,6 +32,8 @@ __reExport(src_exports, require("./commandDecorators"), module.exports);
 __reExport(src_exports, require("./aiEditor"), module.exports);
 __reExport(src_exports, require("./builder"), module.exports);
 __reExport(src_exports, require("./spinner"), module.exports);
+__reExport(src_exports, require("./prompter"), module.exports);
+__reExport(src_exports, require("./guideline"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./createTunnel"),
@@ -51,5 +53,7 @@ __reExport(src_exports, require("./spinner"), module.exports);
   ...require("./commandDecorators"),
   ...require("./aiEditor"),
   ...require("./builder"),
-  ...require("./spinner")
+  ...require("./spinner"),
+  ...require("./prompter"),
+  ...require("./guideline")
 });