@akanjs/devkit 0.0.142 → 0.0.144

package/esm/src/executors.js

@@ -1,4 +1,4 @@
-import { Logger } from "@akanjs/common";
+import { capitalize, Logger } from "@akanjs/common";
 import {
   getAppConfig,
   getDefaultFileScan,
@@ -11,13 +11,16 @@ import fs from "fs";
 import fsPromise from "fs/promises";
 import path from "path";
 import { TypeScriptDependencyScanner } from "./dependencyScanner";
+import { Linter } from "./linter";
 import { Spinner } from "./spinner";
+import { TypeChecker } from "./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
 };
@@ -30,6 +33,8 @@ class Executor {
   logger;
   cwdPath;
   emoji = execEmoji.default;
+  typeChecker = null;
+  linter = null;
   constructor(name, cwdPath) {
     this.name = name;
     this.logger = new Logger(name);
@@ -64,28 +69,32 @@ class Executor {
   spawn(command, args = [], options = {}) {
     const proc = 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 = fork(modulePath, args, {
       cwd: this.cwdPath,
-      stdio: ["ignore", "inherit", "inherit", "ipc"],
+      // stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
@@ -103,45 +112,70 @@ class Executor {
       });
     });
   }
-  #getPath(filePath) {
-    return path.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+  getPath(filePath) {
+    if (path.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 (!fs.existsSync(writePath))
       fs.mkdirSync(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
+  async readdir(dirPath) {
+    const readPath = this.getPath(dirPath);
+    try {
+      return await fsPromise.readdir(readPath);
+    } catch (error) {
+      return [];
+    }
+  }
   exists(filePath) {
-    const readPath = this.#getPath(filePath);
+    const readPath = this.getPath(filePath);
     return fs.existsSync(readPath);
   }
   remove(filePath) {
-    const readPath = this.#getPath(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);
+    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 writePath = this.getPath(filePath);
     const dir = path.dirname(writePath);
     if (!fs.existsSync(dir))
       fs.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 (fs.existsSync(writePath)) {
       const currentContent = fs.readFileSync(writePath, "utf8");
-      if (currentContent === contentStr || !overwrite)
+      if (currentContent === contentStr || !overwrite) {
         this.logger.verbose(`File ${writePath} is unchanged`);
-      else {
+        contentStr = fs.readFileSync(writePath, "utf-8");
+      } else {
         fs.writeFileSync(writePath, contentStr, "utf8");
         this.logger.verbose(`File ${writePath} is changed`);
       }
@@ -149,28 +183,28 @@ class Executor {
       fs.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 = path.isAbsolute(filePath) ? filePath : filePath.replace(this.cwdPath, "");
-    const content = this.readFile(filepath);
-    return { filepath, content };
+  getLocalFile(targetPath) {
+    const filePath = path.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 fs.readFileSync(readPath, "utf8");
   }
   readJson(filePath) {
-    const readPath = this.#getPath(filePath);
+    const readPath = this.getPath(filePath);
     return JSON.parse(fs.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 fsPromise.cp(src, dest, { recursive: true });
   }
   log(msg) {
@@ -206,7 +240,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 : path.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
       const dirname = path.dirname(targetPath);
@@ -215,7 +249,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 fsPromise.readFile(templatePath, "utf8");
       const convertedTargetPath = Object.entries(dict).reduce(
@@ -227,10 +261,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,
@@ -240,22 +275,24 @@ class Executor {
     const templatePath = `${__dirname}/src/templates${template ? `/${template}` : ""}`.replace(".ts", ".js");
     if (fs.statSync(templatePath).isFile()) {
       const filename = path.basename(templatePath);
-      await this.#applyTemplateFile(
+      const fileContent = await this.#applyTemplateFile(
         { templatePath, targetPath: path.join(basePath, filename), scanResult, overwrite },
         dict
       );
+      return fileContent ? [fileContent] : [];
     } else {
-      const subdirs = await fsPromise.readdir(templatePath);
-      await Promise.all(
+      const subdirs = await this.readdir(templatePath);
+      const fileContents = (await Promise.all(
         subdirs.map(async (subdir) => {
           const subpath = path.join(templatePath, subdir);
-          if (fs.statSync(subpath).isFile())
-            await this.#applyTemplateFile(
+          if (fs.statSync(subpath).isFile()) {
+            const fileContent = await this.#applyTemplateFile(
               { templatePath: subpath, targetPath: path.join(basePath, subdir), scanResult, overwrite },
               dict
             );
-          else
-            await this.applyTemplate({
+            return fileContent ? [fileContent] : [];
+          } else
+            return await this._applyTemplate({
               basePath: path.join(basePath, subdir),
               template: path.join(template, subdir),
               scanResult,
@@ -263,9 +300,41 @@ class Executor {
               overwrite
             });
         })
-      );
+      )).flat();
+      return fileContents;
     }
   }
+  async applyTemplate(options) {
+    const dict = {
+      ...options.dict ?? {},
+      ...Object.fromEntries(
+        Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)])
+      )
+    };
+    return this._applyTemplate({ ...options, dict });
+  }
+  getTypeChecker() {
+    this.typeChecker ??= new 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 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;
@@ -378,7 +447,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 fsPromise.readdir(dirname);
+      const dirs = await this.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
           if (dir.includes("_") || AVOID_DIRS.includes(dir))
@@ -405,7 +474,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 fsPromise.readdir(dirname);
+      const dirs = await this.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
           if (AVOID_DIRS.includes(dir))
@@ -503,14 +572,14 @@ class SysExecutor extends Executor {
     if (!fs.existsSync(`${this.cwdPath}/lib/__scalar`))
       fs.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
     const files = getDefaultFileScan();
-    const dirnames = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter(
+    const dirnames = (await this.readdir("lib")).filter(
       (name) => fs.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 fsPromise.readdir(path.join(this.cwdPath, "lib", name));
+        const filenames = await this.readdir(path.join("lib", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.databases.push(name);
@@ -532,7 +601,7 @@ class SysExecutor extends Executor {
     await Promise.all(
       serviceDirs.map(async (dirname) => {
         const name = dirname.slice(1);
-        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib", dirname));
+        const filenames = await this.readdir(path.join("lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -547,12 +616,10 @@ class SysExecutor extends Executor {
         });
       })
     );
-    const scalarDirs = (await fsPromise.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 fsPromise.readdir(path.join(this.cwdPath, "lib/__scalar", name));
+        const filenames = await this.readdir(path.join("lib/__scalar", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.scalars.push(name);
@@ -599,11 +666,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;
@@ -626,33 +693,33 @@ class SysExecutor extends Executor {
     this.writeJson("package.json", libPkgJsonWithDeps);
     return scanResult;
   }
-  getLocalFile(filePath) {
-    const filepath = path.isAbsolute(filePath) ? filePath : `${this.type}s/${this.name}/${filePath}`;
-    const content = this.workspace.readFile(filepath);
-    return { filepath, content };
+  getLocalFile(targetPath) {
+    const filePath = path.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
+    const content = this.workspace.readFile(filePath);
+    return { filePath, content };
   }
   async getDatabaseModules() {
-    const databaseModules = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => fs.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) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
     return databaseModules;
   }
   async getServiceModules() {
-    const serviceModules = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
+    const serviceModules = (await this.readdir("lib")).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
     return serviceModules;
   }
   async getScalarModules() {
-    const scalarModules = (await fsPromise.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
+    const scalarModules = (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
     return scalarModules;
   }
   async getViewComponents() {
-    const viewComponents = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => fs.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) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.View.tsx`));
     return viewComponents;
   }
   async getUnitComponents() {
-    const unitComponents = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => fs.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) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`));
     return unitComponents;
   }
   async getTemplateComponents() {
-    const templateComponents = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => fs.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) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`));
     return templateComponents;
   }
   async getViewsSourceCode() {
@@ -683,10 +750,35 @@ class SysExecutor extends Executor {
     const modules = await this.getModules();
     return modules.map((module) => this.getLocalFile(`lib/${module}/${module}.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((module) => this.getLocalFile(`lib/${module}/${module}.dictionary.ts`));
   }
+  async applyTemplate(options) {
+    const dict = {
+      ...options.dict ?? {},
+      ...Object.fromEntries(
+        Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), 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;
@@ -792,10 +884,22 @@ 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 });
+  }
+}
 export {
   AppExecutor,
   Executor,
   LibExecutor,
+  ModuleExecutor,
   PkgExecutor,
   SysExecutor,
   WorkspaceExecutor,

package/esm/src/index.js

@@ -16,3 +16,5 @@ export * from "./commandDecorators";
 export * from "./aiEditor";
 export * from "./builder";
 export * from "./spinner";
+export * from "./prompter";
+export * from "./guideline";