@akanjs/devkit 0.0.143 → 0.0.145

package/esm/src/executors.js

@@ -1,4 +1,4 @@
-import { Logger } from "@akanjs/common";
+import { capitalize, Logger } from "@akanjs/common";
 import {
   getAppConfig,
   getDefaultFileScan,
@@ -11,7 +11,9 @@ 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}",
@@ -31,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);
@@ -65,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) => {
@@ -104,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`);
       }
@@ -150,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) {
@@ -207,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);
@@ -216,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(
@@ -228,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,
@@ -241,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,
@@ -264,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;
@@ -379,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))
@@ -406,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))
@@ -504,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);
@@ -533,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);
@@ -548,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);
@@ -600,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;
@@ -627,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() {
@@ -684,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;

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";

package/esm/src/linter.js

@@ -0,0 +1,205 @@
+import { Logger } from "@akanjs/common";
+import chalk from "chalk";
+import { ESLint } from "eslint";
+import * as fs from "fs";
+import * as path from "path";
+class Linter {
+  #logger = new Logger("Linter");
+  #eslint;
+  lintRoot;
+  constructor(cwdPath) {
+    this.lintRoot = this.#findEslintRootPath(cwdPath);
+    this.#eslint = new ESLint({ cwd: this.lintRoot, errorOnUnmatchedPattern: false });
+  }
+  #findEslintRootPath(dir) {
+    const configPath = path.join(dir, "eslint.config.ts");
+    if (fs.existsSync(configPath))
+      return dir;
+    const parentDir = path.dirname(dir);
+    return this.#findEslintRootPath(parentDir);
+  }
+  async lint(filePath, { fix = false, dryRun = false } = {}) {
+    if (fix)
+      return await this.fixFile(filePath, dryRun);
+    return await this.lintFile(filePath);
+  }
+  /**
+   * Lint a single file using ESLint
+   * @param filePath - Path to the file to lint
+   * @returns Array of ESLint results
+   */
+  async lintFile(filePath) {
+    if (!fs.existsSync(filePath))
+      throw new Error(`File not found: ${filePath}`);
+    const isIgnored = await this.#eslint.isPathIgnored(filePath);
+    if (isIgnored) {
+      this.#logger.warn(`File ${filePath} is ignored by ESLint configuration`);
+      return { fixed: false, results: [], errors: [], warnings: [] };
+    }
+    const results = await this.#eslint.lintFiles([filePath]);
+    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    return { fixed: false, results, errors, warnings };
+  }
+  /**
+   * Format lint results for console output
+   * @param results - Array of ESLint results
+   * @returns Formatted string
+   */
+  formatLintResults(results) {
+    if (results.length === 0)
+      return "No files to lint";
+    const output = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    results.forEach((result) => {
+      totalErrors += result.errorCount;
+      totalWarnings += result.warningCount;
+      if (result.messages.length > 0) {
+        output.push(`
+${chalk.cyan(result.filePath)}`);
+        let sourceLines = [];
+        if (fs.existsSync(result.filePath)) {
+          try {
+            const sourceContent = fs.readFileSync(result.filePath, "utf8");
+            sourceLines = sourceContent.split("\n");
+          } catch (error) {
+          }
+        }
+        result.messages.forEach((message) => {
+          const type = message.severity === 2 ? "error" : "warning";
+          const typeColor = message.severity === 2 ? chalk.red : chalk.yellow;
+          const icon = message.severity === 2 ? "\u274C" : "\u26A0\uFE0F";
+          const ruleInfo = message.ruleId ? chalk.dim(` (${message.ruleId})`) : "";
+          output.push(`
+  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
+          output.push(`     ${chalk.gray("at")} ${result.filePath}:${chalk.bold(`${message.line}:${message.column}`)}`);
+          if (sourceLines.length > 0 && message.line <= sourceLines.length) {
+            const sourceLine = sourceLines[message.line - 1];
+            const lineNumber = message.line.toString().padStart(5, " ");
+            output.push(`
+${chalk.dim(lineNumber + " |")} ${sourceLine}`);
+            const underlinePrefix = " ".repeat(message.column - 1);
+            const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
+            const underline = "^".repeat(Math.max(1, underlineLength));
+            output.push(`${chalk.dim(" ".repeat(lineNumber.length) + " |")} ${underlinePrefix}${typeColor(underline)}`);
+          }
+        });
+      }
+    });
+    if (totalErrors === 0 && totalWarnings === 0)
+      return chalk.bold("\u2705 No ESLint errors or warnings found");
+    const errorText = totalErrors > 0 ? chalk.red(`${totalErrors} error(s)`) : "0 errors";
+    const warningText = totalWarnings > 0 ? chalk.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
+    const summary = [`
+${errorText}, ${warningText} found`];
+    return summary.concat(output).join("\n");
+  }
+  /**
+   * Get detailed lint information
+   * @param filePath - Path to the file to lint
+   * @returns Object containing detailed lint information
+   */
+  async getDetailedLintInfo(filePath) {
+    const { results } = await this.lintFile(filePath);
+    const details = results.flatMap(
+      (result) => result.messages.map((message) => ({
+        line: message.line,
+        column: message.column,
+        message: message.message,
+        ruleId: message.ruleId,
+        severity: message.severity === 2 ? "error" : "warning",
+        fix: message.fix,
+        suggestions: message.suggestions
+      }))
+    );
+    const stats = results.reduce(
+      (acc, result) => ({
+        errorCount: acc.errorCount + result.errorCount,
+        warningCount: acc.warningCount + result.warningCount,
+        fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
+        fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount
+      }),
+      { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 }
+    );
+    return { results, details, stats };
+  }
+  /**
+   * Check if a file has lint errors
+   * @param filePath - Path to the file to check
+   * @returns true if there are no errors, false otherwise
+   */
+  async hasNoLintErrors(filePath) {
+    try {
+      const { results } = await this.lintFile(filePath);
+      return results.every((result) => result.errorCount === 0);
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Get only error messages (excluding warnings)
+   * @param filePath - Path to the file to lint
+   * @returns Array of error messages
+   */
+  async getErrors(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+  }
+  /**
+   * Get only warning messages
+   * @param filePath - Path to the file to lint
+   * @returns Array of warning messages
+   */
+  async getWarnings(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+  }
+  /**
+   * Fix lint errors automatically
+   * @param filePath - Path to the file to fix
+   * @param dryRun - If true, returns the fixed content without writing to file
+   * @returns Fixed content and remaining issues
+   */
+  async fixFile(filePath, dryRun = false) {
+    if (!fs.existsSync(filePath))
+      throw new Error(`File not found: ${filePath}`);
+    const eslint = new ESLint({ cwd: this.lintRoot, fix: true });
+    const results = await eslint.lintFiles([filePath]);
+    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    if (!dryRun)
+      await ESLint.outputFixes(results);
+    const fixedResult = results[0];
+    return { fixed: fixedResult.output !== void 0, output: fixedResult.output, results, errors, warnings };
+  }
+  /**
+   * Get ESLint configuration for a file
+   * @param filePath - Path to the file
+   * @returns ESLint configuration object
+   */
+  async getConfigForFile(filePath) {
+    const eslint = new ESLint();
+    const config = await eslint.calculateConfigForFile(filePath);
+    return config;
+  }
+  /**
+   * Get rules that are causing errors in a file
+   * @param filePath - Path to the file to check
+   * @returns Object mapping rule IDs to their error counts
+   */
+  async getProblematicRules(filePath) {
+    const { results } = await this.lintFile(filePath);
+    const ruleCounts = {};
+    results.forEach((result) => {
+      result.messages.forEach((message) => {
+        if (message.ruleId)
+          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
+      });
+    });
+    return ruleCounts;
+  }
+}
+export {
+  Linter
+};