@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/esm/src/scanInfo.js

@@ -1,455 +0,0 @@
-import path from "path";
-import { TypeScriptDependencyScanner } from "./dependencyScanner";
-import { AppExecutor, LibExecutor, PkgExecutor } from "./executors";
-const scalarFileTypes = ["constant", "dictionary", "document", "template", "unit", "util", "view", "zone"];
-const serviceFileTypes = [
-  "dictionary",
-  "service",
-  "signal",
-  "store",
-  "template",
-  "unit",
-  "util",
-  "view",
-  "zone"
-];
-const databaseFileTypes = [
-  "constant",
-  "dictionary",
-  "document",
-  "service",
-  "signal",
-  "store",
-  "template",
-  "unit",
-  "util",
-  "view",
-  "zone"
-];
-class ScanInfo {
-  scanResult;
-  name;
-  scalar = /* @__PURE__ */ new Map();
-  service = /* @__PURE__ */ new Map();
-  database = /* @__PURE__ */ new Map();
-  file = Object.fromEntries(
-    databaseFileTypes.map((type) => [
-      type,
-      { all: /* @__PURE__ */ new Set(), databases: /* @__PURE__ */ new Set(), services: /* @__PURE__ */ new Set(), scalars: /* @__PURE__ */ new Set() }
-    ])
-  );
-  static async getScanResult(exec) {
-    const akanConfig = await exec.getConfig();
-    const tsconfig = exec.getTsConfig();
-    const rootPackageJson = exec.workspace.getPackageJson();
-    const gitignorePatterns = exec.workspace.getGitignorePatterns();
-    const scanner = new TypeScriptDependencyScanner(exec.cwdPath, {
-      workspaceRoot: exec.workspace.cwdPath,
-      tsconfig,
-      rootPackageJson,
-      gitignorePatterns
-    });
-    const { pkgDeps, libDeps, npmDeps } = await scanner.getMonorepoDependencies(exec.name);
-    const files = {
-      constant: { databases: [], scalars: [] },
-      dictionary: { databases: [], services: [], scalars: [] },
-      document: { databases: [], scalars: [] },
-      service: { databases: [], services: [] },
-      signal: { databases: [], services: [] },
-      store: { databases: [], services: [] },
-      template: { databases: [], services: [], scalars: [] },
-      unit: { databases: [], services: [], scalars: [] },
-      util: { databases: [], services: [], scalars: [] },
-      view: { databases: [], services: [], scalars: [] },
-      zone: { databases: [], services: [], scalars: [] }
-    };
-    const [{ dirs: dirnames }, scalarDirs] = await Promise.all([
-      exec.getFilesAndDirs("lib"),
-      exec.readdir("lib/__scalar")
-    ]);
-    const databaseDirs = [];
-    const serviceDirs = [];
-    dirnames.forEach((name) => {
-      if (name.startsWith("_")) {
-        if (name.startsWith("__"))
-          return;
-        else
-          serviceDirs.push(name);
-      } else
-        databaseDirs.push(name);
-    });
-    await Promise.all([
-      ...databaseDirs.map(async (name) => {
-        const filenames = await exec.readdir(path.join("lib", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constant.databases.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.databases.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.document.databases.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.service.databases.push(name);
-          else if (filename.endsWith(".signal.ts"))
-            files.signal.databases.push(name);
-          else if (filename.endsWith(".store.ts"))
-            files.store.databases.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.databases.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.databases.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.databases.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.databases.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.databases.push(name);
-        });
-      }),
-      ...serviceDirs.map(async (dirname) => {
-        const name = dirname.slice(1);
-        const filenames = await exec.readdir(path.join("lib", dirname));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.services.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.service.services.push(name);
-          else if (filename.endsWith(".signal.ts"))
-            files.signal.services.push(name);
-          else if (filename.endsWith(".store.ts"))
-            files.store.services.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.services.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.services.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.services.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.services.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.services.push(name);
-        });
-      }),
-      ...scalarDirs.map(async (name) => {
-        const filenames = await exec.readdir(path.join("lib/__scalar", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constant.scalars.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.scalars.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.document.scalars.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.scalars.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.scalars.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.scalars.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.scalars.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.scalars.push(name);
-        });
-      })
-    ]);
-    const scanResult = {
-      name: exec.name,
-      type: exec.type,
-      repoName: exec.workspace.repoName,
-      serveDomain: exec.workspace.getBaseDevEnv().serveDomain,
-      akanConfig,
-      files,
-      libDeps,
-      pkgDeps,
-      dependencies: npmDeps.filter((dep) => !dep.startsWith("@akanjs"))
-    };
-    return scanResult;
-  }
-  constructor(scanResult) {
-    this.name = scanResult.name;
-    this.scanResult = scanResult;
-    Object.entries(scanResult.files).forEach(([_key, value]) => {
-      const key = _key;
-      const { databases, services, scalars } = value;
-      databases.forEach((modelName) => {
-        const model = this.database.get(modelName) ?? /* @__PURE__ */ new Set();
-        model.add(key);
-        this.database.set(modelName, model);
-        this.file[key].all.add(modelName);
-        this.file[key].databases.add(modelName);
-      });
-      services?.forEach((serviceName) => {
-        const service = this.service.get(serviceName) ?? /* @__PURE__ */ new Set();
-        service.add(key);
-        this.service.set(serviceName, service);
-        this.file[key].all.add(serviceName);
-        this.file[key].services.add(serviceName);
-      });
-      scalars?.forEach((scalarName) => {
-        const scalar = this.scalar.get(scalarName) ?? /* @__PURE__ */ new Set();
-        scalar.add(key);
-        this.scalar.set(scalarName, scalar);
-        this.file[key].all.add(scalarName);
-        this.file[key].scalars.add(scalarName);
-      });
-    });
-  }
-  getScanResult() {
-    return this.scanResult;
-  }
-  getDatabaseModules() {
-    return [...this.database.keys()];
-  }
-  getServiceModules() {
-    return [...this.service.keys()];
-  }
-  getScalarModules() {
-    return [...this.scalar.keys()];
-  }
-}
-class AppInfo extends ScanInfo {
-  type = "app";
-  exec;
-  akanConfig;
-  libDeps;
-  static appInfos = /* @__PURE__ */ new Map();
-  static async fromExecutor(exec, options = {}) {
-    const existingAppInfo = this.appInfos.get(exec.name);
-    if (existingAppInfo && !options.refresh)
-      return existingAppInfo;
-    const scanResult = await super.getScanResult(exec);
-    await Promise.all(
-      scanResult.libDeps.map(async (libName) => {
-        LibInfo.loadedLibs.add(libName);
-        const libExecutor = LibExecutor.from(exec, libName);
-        LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
-      })
-    );
-    const libDeps = await this.#getAllLibDeps(exec, scanResult.libDeps);
-    const appInfo = new AppInfo(exec, scanResult, libDeps);
-    this.appInfos.set(exec.name, appInfo);
-    return appInfo;
-  }
-  constructor(exec, scanResult, libDeps) {
-    super(scanResult);
-    this.exec = exec;
-    this.akanConfig = scanResult.akanConfig;
-    this.libDeps = libDeps;
-  }
-  getScanResult() {
-    return this.scanResult;
-  }
-  static async #getAllLibDeps(exec, libDeps, libSet = /* @__PURE__ */ new Set()) {
-    await Promise.all(
-      libDeps.map(async (libName) => {
-        if (libSet.has(libName))
-          return;
-        libSet.add(libName);
-        const libExecutor = LibExecutor.from(exec, libName);
-        const libInfo = await LibInfo.fromExecutor(libExecutor);
-        const libScanResult = libInfo.getScanResult();
-        if (libScanResult.libDeps.length > 0)
-          await this.#getAllLibDeps(exec, libScanResult.libDeps, libSet);
-      })
-    );
-    return [...libSet];
-  }
-  #sortedLibs = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs)
-      return this.#sortedLibs;
-    const libIndices = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libIndices.get(libNameA);
-      const indexB = libIndices.get(libNameB);
-      if (indexA === void 0 || indexB === void 0)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
-  getLibs() {
-    return this.#getSortedLibs();
-  }
-  getLibInfos() {
-    return new Map(
-      this.#getSortedLibs().map((libName) => {
-        const libInfo = LibInfo.libInfos.get(libName);
-        if (!libInfo)
-          throw new Error(`LibInfo not found: ${libName}`);
-        return [libName, libInfo];
-      })
-    );
-  }
-}
-class LibInfo extends ScanInfo {
-  type = "lib";
-  exec;
-  akanConfig;
-  static loadedLibs = /* @__PURE__ */ new Set();
-  static libInfos = /* @__PURE__ */ new Map();
-  static #sortedLibIndices = null;
-  static getSortedLibIndices() {
-    if (this.#sortedLibIndices)
-      return this.#sortedLibIndices;
-    this.#sortedLibIndices = new Map(
-      [...this.libInfos.entries()].sort(([_, libInfoA], [__, libInfoB]) => libInfoA.getScanResult().libDeps.includes(libInfoB.name) ? 1 : -1).map(([libName], index) => [libName, index])
-    );
-    return this.#sortedLibIndices;
-  }
-  static async fromExecutor(exec, { refresh } = {}) {
-    const existingLibInfo = this.libInfos.get(exec.name);
-    if (existingLibInfo && !refresh)
-      return existingLibInfo;
-    const scanResult = await super.getScanResult(exec);
-    await Promise.all(
-      scanResult.libDeps.filter((libName) => !this.loadedLibs.has(libName)).map(async (libName) => {
-        this.loadedLibs.add(libName);
-        const libExecutor = LibExecutor.from(exec, libName);
-        this.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
-      })
-    );
-    const libInfo = new LibInfo(exec, scanResult);
-    this.libInfos.set(exec.name, libInfo);
-    this.#sortedLibIndices = null;
-    return libInfo;
-  }
-  constructor(exec, scanResult) {
-    super(scanResult);
-    this.exec = exec;
-    this.akanConfig = scanResult.akanConfig;
-  }
-  getScanResult() {
-    return this.scanResult;
-  }
-  #sortedLibs = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs)
-      return this.#sortedLibs;
-    const libs = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.scanResult.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libs.get(libNameA);
-      const indexB = libs.get(libNameB);
-      if (indexA === void 0 || indexB === void 0)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
-  getLibs() {
-    return this.#getSortedLibs();
-  }
-  getLibInfo(libName) {
-    if (!this.getScanResult().libDeps.includes(libName))
-      return void 0;
-    const libSet = new Set(this.#getSortedLibs());
-    if (!libSet.has(libName))
-      throw new Error(`LibInfo is invalid: ${libName}`);
-    return LibInfo.libInfos.get(libName);
-  }
-  getLibInfos() {
-    return new Map(
-      this.#getSortedLibs().map((libName) => {
-        const libInfo = LibInfo.libInfos.get(libName);
-        if (!libInfo)
-          throw new Error(`LibInfo not found: ${libName}`);
-        return [libName, libInfo];
-      })
-    );
-  }
-}
-class PkgInfo {
-  exec;
-  name;
-  scanResult;
-  static async getScanResult(exec) {
-    const tsconfig = exec.getTsConfig();
-    const rootPackageJson = exec.workspace.getPackageJson();
-    const gitignorePatterns = exec.workspace.getGitignorePatterns();
-    const scanner = new TypeScriptDependencyScanner(exec.cwdPath, {
-      workspaceRoot: exec.workspace.cwdPath,
-      tsconfig,
-      rootPackageJson,
-      gitignorePatterns
-    });
-    const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
-    const pkgPathSet = new Set(
-      Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path2) => tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
-    );
-    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
-    const pkgDeps = [...pkgPathDepSet].map((path2) => {
-      const pathSplitLength = path2.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
-    }).filter((pkg) => pkg !== this.name);
-    const pkgScanResult = {
-      name: this.name,
-      pkgDeps,
-      dependencies: [...npmDepSet]
-    };
-    return pkgScanResult;
-  }
-  static #pkgInfos = /* @__PURE__ */ new Map();
-  static async fromExecutor(exec, options = {}) {
-    const existingPkgInfo = this.#pkgInfos.get(exec.name);
-    if (existingPkgInfo && !options.refresh)
-      return existingPkgInfo;
-    const scanResult = await this.getScanResult(exec);
-    const pkgInfo = new PkgInfo(exec, scanResult);
-    this.#pkgInfos.set(exec.name, pkgInfo);
-    return pkgInfo;
-  }
-  constructor(exec, scanResult) {
-    this.exec = exec;
-    this.name = exec.name;
-    this.scanResult = scanResult;
-  }
-  getScanResult() {
-    return this.scanResult;
-  }
-}
-class WorkspaceInfo {
-  constructor(appInfos = /* @__PURE__ */ new Map(), libInfos = /* @__PURE__ */ new Map(), pkgInfos = /* @__PURE__ */ new Map()) {
-    this.appInfos = appInfos;
-    this.libInfos = libInfos;
-    this.pkgInfos = pkgInfos;
-  }
-  static #workspaceInfos = /* @__PURE__ */ new Map();
-  static async fromExecutor(exec, options = {}) {
-    const existingWorkspaceInfo = this.#workspaceInfos.get(exec.name);
-    if (existingWorkspaceInfo && !options.refresh)
-      return existingWorkspaceInfo;
-    const [appNames, libNames, pkgNames] = await Promise.all([exec.getApps(), exec.getLibs(), exec.getPkgs()]);
-    const [appInfos, libInfos, pkgInfos] = await Promise.all([
-      Promise.all(
-        appNames.map(async (appName) => {
-          const app = AppExecutor.from(exec, appName);
-          return await app.scan();
-        })
-      ),
-      Promise.all(
-        libNames.map(async (libName) => {
-          const lib = LibExecutor.from(exec, libName);
-          return await lib.scan();
-        })
-      ),
-      Promise.all(
-        pkgNames.map(async (pkgName) => {
-          return await PkgExecutor.from(exec, pkgName).scan();
-        })
-      )
-    ]);
-    const workspaceInfo = new WorkspaceInfo(
-      new Map(appInfos.map((app) => [app.exec.name, app])),
-      new Map(libInfos.map((lib) => [lib.exec.name, lib])),
-      new Map(pkgInfos.map((pkg) => [pkg.exec.name, pkg]))
-    );
-    this.#workspaceInfos.set(exec.name, workspaceInfo);
-    return workspaceInfo;
-  }
-}
-export {
-  AppInfo,
-  LibInfo,
-  PkgInfo,
-  WorkspaceInfo
-};

package/esm/src/selectModel.js

@@ -1,13 +0,0 @@
-import { select } from "@inquirer/prompts";
-import fs from "fs";
-const selectModel = async (modulePath) => {
-  const modelNames = fs.readdirSync(`${modulePath}/lib`).filter((dir) => !dir.includes(".") && !dir.startsWith("_"));
-  const modelName = await select({
-    message: "Select the model to create the unit for",
-    choices: modelNames.map((name) => ({ name, value: name }))
-  });
-  return modelName;
-};
-export {
-  selectModel
-};

package/esm/src/typeChecker.js

@@ -1,174 +0,0 @@
-import chalk from "chalk";
-import * as fs from "fs";
-import * as path from "path";
-import * as ts from "typescript";
-class TypeChecker {
-  configPath;
-  configFile;
-  config;
-  constructor(executor) {
-    const configPath = this.#findConfigFile(executor.cwdPath);
-    if (!configPath)
-      throw new Error("No tsconfig.json found in the project");
-    this.configPath = configPath;
-    this.configFile = ts.readConfigFile(this.configPath, (fileName) => ts.sys.readFile(fileName));
-    const parsedConfig = ts.parseJsonConfigFileContent(
-      this.configFile.config,
-      ts.sys,
-      path.dirname(this.configPath),
-      void 0,
-      this.configPath
-    );
-    if (parsedConfig.errors.length > 0) {
-      const errorMessages = parsedConfig.errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n");
-      throw new Error(`Error parsing tsconfig.json:
-${errorMessages}`);
-    }
-    this.config = parsedConfig;
-  }
-  /**
-   * Find tsconfig.json by walking up the directory tree
-   */
-  #findConfigFile(searchPath) {
-    return ts.findConfigFile(searchPath, (fileName) => ts.sys.fileExists(fileName), "tsconfig.json");
-  }
-  /**
-   * Type-check a single TypeScript file
-   * @param filePath - Path to the TypeScript file to check
-   * @returns Array of diagnostic messages
-   */
-  check(filePath) {
-    const program = ts.createProgram([filePath], this.config.options);
-    const diagnostics = [
-      ...program.getSemanticDiagnostics(),
-      ...program.getSyntacticDiagnostics(),
-      // Only check declaration diagnostics when declaration emit is enabled
-      ...this.config.options.declaration ? program.getDeclarationDiagnostics() : []
-    ];
-    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    const fileDiagnostics = diagnostics.filter((diagnostic) => diagnostic.file?.fileName === filePath);
-    const fileErrors = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const fileWarnings = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    return { diagnostics, errors, warnings, fileDiagnostics, fileErrors, fileWarnings };
-  }
-  /**
-   * Format diagnostics for console output
-   * @param diagnostics - Array of TypeScript diagnostics
-   * @returns Formatted string
-   */
-  formatDiagnostics(diagnostics) {
-    if (diagnostics.length === 0)
-      return chalk.bold("\u2705 No type errors found");
-    const output = [];
-    let errorCount = 0;
-    let warningCount = 0;
-    let suggestionCount = 0;
-    const diagnosticsByFile = /* @__PURE__ */ new Map();
-    diagnostics.forEach((diagnostic) => {
-      if (diagnostic.category === ts.DiagnosticCategory.Error)
-        errorCount++;
-      else if (diagnostic.category === ts.DiagnosticCategory.Warning)
-        warningCount++;
-      else if (diagnostic.category === ts.DiagnosticCategory.Suggestion)
-        suggestionCount++;
-      if (diagnostic.file) {
-        const fileName = diagnostic.file.fileName;
-        if (!diagnosticsByFile.has(fileName))
-          diagnosticsByFile.set(fileName, []);
-        const fileDiagnostics = diagnosticsByFile.get(fileName);
-        if (fileDiagnostics)
-          fileDiagnostics.push(diagnostic);
-      } else {
-        if (!diagnosticsByFile.has(""))
-          diagnosticsByFile.set("", []);
-        const fileDiagnostics = diagnosticsByFile.get("");
-        if (fileDiagnostics)
-          fileDiagnostics.push(diagnostic);
-      }
-    });
-    diagnosticsByFile.forEach((fileDiagnostics, fileName) => {
-      if (fileName)
-        output.push(`
-${chalk.cyan(fileName)}`);
-      fileDiagnostics.forEach((diagnostic) => {
-        const categoryText = diagnostic.category === ts.DiagnosticCategory.Error ? "error" : diagnostic.category === ts.DiagnosticCategory.Warning ? "warning" : "suggestion";
-        const categoryColor = diagnostic.category === ts.DiagnosticCategory.Error ? chalk.red : diagnostic.category === ts.DiagnosticCategory.Warning ? chalk.yellow : chalk.blue;
-        const icon = diagnostic.category === ts.DiagnosticCategory.Error ? "\u274C" : diagnostic.category === ts.DiagnosticCategory.Warning ? "\u26A0\uFE0F" : "\u{1F4A1}";
-        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-        const tsCode = chalk.dim(`(TS${diagnostic.code})`);
-        if (diagnostic.file && diagnostic.start !== void 0) {
-          const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-          output.push(`
-  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
-          output.push(`     ${chalk.gray("at")} ${fileName}:${chalk.bold(`${line + 1}:${character + 1}`)}`);
-          const sourceLines = diagnostic.file.text.split("\n");
-          if (line < sourceLines.length) {
-            const sourceLine = sourceLines[line];
-            const lineNumber = (line + 1).toString().padStart(5, " ");
-            output.push(`
-${chalk.dim(lineNumber + " |")} ${sourceLine}`);
-            const underlinePrefix = " ".repeat(character);
-            const length = diagnostic.length ?? 1;
-            const underline = "~".repeat(Math.max(1, length));
-            output.push(
-              `${chalk.dim(" ".repeat(lineNumber.length) + " |")} ${underlinePrefix}${categoryColor(underline)}`
-            );
-          }
-        } else
-          output.push(`
-  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
-      });
-    });
-    const summary = [];
-    if (errorCount > 0)
-      summary.push(chalk.red(`${errorCount} error(s)`));
-    if (warningCount > 0)
-      summary.push(chalk.yellow(`${warningCount} warning(s)`));
-    if (suggestionCount > 0)
-      summary.push(chalk.blue(`${suggestionCount} suggestion(s)`));
-    return `
-${summary.join(", ")} found` + output.join("\n");
-  }
-  /**
-   * Get detailed diagnostic information with code snippet
-   * @param filePath - Path to the TypeScript file to check
-   * @returns Object containing diagnostics and detailed information
-   */
-  getDetailedDiagnostics(filePath) {
-    const { diagnostics } = this.check(filePath);
-    const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true);
-    const details = diagnostics.map((diagnostic) => {
-      if (diagnostic.file && diagnostic.start !== void 0) {
-        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-        const lines = sourceFile.text.split("\n");
-        const codeSnippet = line < lines.length ? lines[line] : void 0;
-        return { line: line + 1, column: character + 1, message, code: diagnostic.code, codeSnippet };
-      }
-      return {
-        line: 0,
-        column: 0,
-        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
-        code: diagnostic.code
-      };
-    });
-    return { diagnostics, details };
-  }
-  /**
-   * Check if a file has type errors
-   * @param filePath - Path to the TypeScript file to check
-   * @returns true if there are no type errors, false otherwise
-   */
-  hasNoTypeErrors(filePath) {
-    try {
-      const { diagnostics } = this.check(filePath);
-      return diagnostics.length === 0;
-    } catch (error) {
-      return false;
-    }
-  }
-}
-export {
-  TypeChecker
-};

package/index.d.ts

@@ -1 +0,0 @@
-export * from "./src";

package/src/aiEditor.d.ts

@@ -1,50 +0,0 @@
-import { BaseMessage } from "@langchain/core/messages";
-import type { Executor, WorkspaceExecutor } from "./executors";
-import type { FileContent } from "./types";
-export declare const supportedLlmModels: readonly ["deepseek-chat", "deepseek-reasoner"];
-export type SupportedLlmModel = (typeof supportedLlmModels)[number];
-interface EditOptions {
-    onReasoning?: (reasoning: string) => void;
-    onChunk?: (chunk: string) => void;
-    maxTry?: number;
-    validate?: string[];
-    approve?: boolean;
-}
-export declare class AiSession {
-    #private;
-    static init({ temperature, useExisting }?: {
-        temperature?: number;
-        useExisting?: boolean;
-    }): Promise<typeof AiSession>;
-    static getLlmConfig(): {
-        model: SupportedLlmModel;
-        apiKey: string;
-    } | null;
-    static setLlmConfig(llmConfig: {
-        model: SupportedLlmModel;
-        apiKey: string;
-    } | null): typeof AiSession;
-    static clearCache(workspaceRoot: string): void;
-    messageHistory: BaseMessage[];
-    readonly sessionKey: string;
-    isCacheLoaded: boolean;
-    workspace: WorkspaceExecutor;
-    constructor(type: string, { workspace, cacheKey, isContinued }: {
-        workspace: WorkspaceExecutor;
-        cacheKey?: string;
-        isContinued?: boolean;
-    });
-    ask(question: string, { onReasoning, onChunk, }?: EditOptions): Promise<{
-        content: string;
-        messageHistory: BaseMessage[];
-    }>;
-    edit(question: string, { onChunk, onReasoning, maxTry, validate, approve }?: EditOptions): Promise<string>;
-    editTypescript(question: string, options?: EditOptions): Promise<string>;
-    addToolMessgaes(messages: {
-        type: string;
-        content: string;
-    }[]): this;
-    writeTypescripts(question: string, executor: Executor, options?: EditOptions): Promise<FileContent[]>;
-    editMarkdown(request: string, options?: EditOptions): Promise<string>;
-}
-export {};