@akanjs/devkit 0.0.142 → 0.0.144

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
+};

package/esm/src/prompter.js

@@ -0,0 +1,45 @@
+import { select } from "@inquirer/prompts";
+import fsPromise from "fs/promises";
+class Prompter {
+  static async selectGuideline() {
+    const guideNames = (await fsPromise.readdir(`${__dirname}/src/guidelines`)).filter((name) => !name.startsWith("_"));
+    return await select({ message: "Select a guideline", choices: guideNames.map((name) => ({ name, value: name })) });
+  }
+  static async getGuideJson(guideName) {
+    const filePath = `${__dirname}/src/guidelines/${guideName}/${guideName}.generate.json`;
+    const guideJson = await fsPromise.readFile(filePath, "utf-8");
+    return JSON.parse(guideJson);
+  }
+  static async getInstruction(guideName) {
+    const filePath = `${__dirname}/src/guidelines/${guideName}/${guideName}.instruction.md`;
+    const content = await fsPromise.readFile(filePath, "utf-8");
+    return content;
+  }
+  async makeTsFileUpdatePrompt({ context, request }) {
+    return `You are a senior developer writing TypeScript-based programs using Akan.js, an in-house framework. Here's an overview of the Akan.js framework:
+${await this.getDocumentation("framework")}
+Please understand the following background information, write code that meets the requirements, verify that it satisfies the validation conditions, and return the result.
+
+# Background Information
+\`\`\`markdown
+${context}
+\`\`\`
+
+# Requirements
+\`\`\`markdown
+${request}
+\`\`\`
+`;
+  }
+  async getDocumentation(guideName) {
+    const filePath = `${__dirname}/src/guidelines/${guideName}/${guideName}.instruction.md`;
+    const document = await fsPromise.readFile(filePath, "utf-8");
+    return `\`\`\`markdown
+${document}
+\`\`\`
+`;
+  }
+}
+export {
+  Prompter
+};

package/esm/src/typeChecker.js

@@ -0,0 +1,170 @@
+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(),
+      ...program.getDeclarationDiagnostics()
+    ];
+    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
+    return { diagnostics, errors, warnings };
+  }
+  /**
+   * 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/esm/src/uploadRelease.js

@@ -1,49 +1,75 @@
+import { Logger } from "@akanjs/common";
 import axios from "axios";
 import FormData from "form-data";
 import fs from "fs";
-const uploadRelease = async (projectName, {
+import { Spinner } from "./spinner";
+const spinning = (message) => {
+  const spinner = new Spinner(message, { prefix: message, enableSpin: true }).start();
+  return spinner;
+};
+const uploadRelease = async (appName, {
   workspaceRoot,
   environment,
   buildNum,
   platformVersion,
   local
 }) => {
+  const logger = new Logger("uploadRelease");
   const basePath = local ? "http://localhost:8080/backend" : "https://akasys.akamir.com/backend";
-  const buildPath = `${workspaceRoot}/releases/builds/${projectName}-release.tar.gz`;
-  const appBuildPath = `${workspaceRoot}/releases/builds/${projectName}-appBuild.zip`;
-  const sourcePath = `${workspaceRoot}/releases/sources/${projectName}-source.tar.gz`;
-  const formData = new FormData();
-  const build = fs.readFileSync(buildPath);
-  const source = fs.readFileSync(sourcePath);
-  const appBuild = fs.readFileSync(appBuildPath);
-  const buildStat = fs.statSync(buildPath);
-  const sourceStat = fs.statSync(sourcePath);
-  const appBuildStat = fs.statSync(appBuildPath);
-  formData.append("files", build, `${projectName}-release.tar.gz`);
-  formData.append("files", source, `${projectName}-source.tar.gz`);
-  formData.append("files", appBuild, `${projectName}-appBuild.zip`);
-  formData.append(
-    "metas",
-    JSON.stringify([
-      { lastModifiedAt: buildStat.mtime, size: buildStat.size },
-      { lastModifiedAt: sourceStat.mtime, size: sourceStat.size },
-      { lastModifiedAt: appBuildStat.mtime, size: appBuildStat.size }
-    ])
-  );
-  formData.append("type", "release");
+  const buildPath = `${workspaceRoot}/releases/builds/${appName}-release.tar.gz`;
+  const appBuildPath = `${workspaceRoot}/releases/builds/${appName}-appBuild.zip`;
+  const sourcePath = `${workspaceRoot}/releases/sources/${appName}-source.tar.gz`;
+  const readingFilesSpinner = spinning("Reading files...");
   try {
-    const [buildFile, sourceFile, appBuildFile] = (await axios.post(`${basePath}/file/addFilesRestApi`, formData)).data;
-    const major = platformVersion ? parseInt(platformVersion.split(".")[0]) : 1;
-    const minor = platformVersion ? parseInt(platformVersion.split(".")[1]) : 0;
-    const patch = platformVersion ? parseInt(platformVersion.split(".")[2]) : 0;
-    const latestRelease = await axios.get(
-      `${basePath}/release/findVersionRelease?appName=${projectName}&branch=${environment}&major=${major}&minor=${minor}`
+    const build = fs.readFileSync(buildPath);
+    const source = fs.readFileSync(sourcePath);
+    const appBuild = fs.readFileSync(appBuildPath);
+    const buildStat = fs.statSync(buildPath);
+    const sourceStat = fs.statSync(sourcePath);
+    const appBuildStat = fs.statSync(appBuildPath);
+    readingFilesSpinner.succeed("Reading files... done");
+    const preparingFormSpinner = spinning("Preparing form data...");
+    const formData = new FormData();
+    formData.append("files", build, `${appName}-release.tar.gz`);
+    formData.append("files", source, `${appName}-source.tar.gz`);
+    formData.append("files", appBuild, `${appName}-appBuild.zip`);
+    formData.append(
+      "metas",
+      JSON.stringify([
+        { lastModifiedAt: buildStat.mtime, size: buildStat.size },
+        { lastModifiedAt: sourceStat.mtime, size: sourceStat.size },
+        { lastModifiedAt: appBuildStat.mtime, size: appBuildStat.size }
+      ])
     );
-    const release = (await axios.post(
-      `${basePath}/release/pushRelease/${projectName}/${environment}/${major}/${minor}/${sourceFile.id}/${buildFile.id}/${appBuildFile.id}`
-    )).data;
-    return release;
+    formData.append("type", "release");
+    preparingFormSpinner.succeed("Preparing form data... done");
+    try {
+      const uploadingFilesSpinner = spinning("Uploading files to server...");
+      const [buildFile, sourceFile, appBuildFile] = (await axios.post(`${basePath}/file/addFilesRestApi`, formData)).data;
+      uploadingFilesSpinner.succeed("Uploading files to server... done");
+      const fetchingAppSpinner = spinning(`Fetching dev app information for ${appName}...`);
+      const major = platformVersion ? parseInt(platformVersion.split(".")[0]) : 1;
+      const minor = platformVersion ? parseInt(platformVersion.split(".")[1]) : 0;
+      const patch = platformVersion ? parseInt(platformVersion.split(".")[2]) : 0;
+      const devApp = (await axios.get(`${basePath}/devApp/devAppInName/${appName}`)).data;
+      fetchingAppSpinner.succeed(`Fetching dev app information for ${appName}... done`);
+      const pushingReleaseSpinner = spinning(`Pushing release to ${environment} environment...`);
+      const release = (await axios.post(
+        `${basePath}/release/pushRelease/${devApp.id}/${environment}/${major}/${minor}/${sourceFile.id}/${buildFile.id}/${appBuildFile.id}`
+      )).data;
+      pushingReleaseSpinner.succeed(`Pushing release to ${environment} environment... done`);
+      new Spinner(`Successfully pushed release to ${appName}-${environment} server. `, {
+        prefix: `Successfully pushed release to ${appName}-${environment} server. `,
+        enableSpin: false
+      }).succeed(`Successfully pushed release to ${appName}-${environment} server. `);
+      return release;
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : "Unknown error";
+      return null;
+    }
   } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : "Unknown error";
+    readingFilesSpinner.fail(`Reading files failed: ${errorMessage}`);
     return null;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "0.0.142",
+  "version": "0.0.144",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"
@@ -17,6 +17,7 @@
   "dependencies": {
     "@inquirer/prompts": "^7.2.1",
     "@langchain/core": "^0.3.56",
+    "@langchain/deepseek": "^0.0.1",
     "@langchain/openai": "^0.5.10",
     "@trapezedev/project": "^7.1.3",
     "axios": "^1.7.9",
@@ -25,6 +26,7 @@
     "dotenv": "^16.4.7",
     "esbuild": "^0.19.2",
     "esbuild-plugin-d.ts": "^1.3.1",
+    "eslint": "^9.19.0",
     "form-data": "^4.0.1",
     "js-yaml": "^4.1.0",
     "ora": "^3.4.0",

package/src/aiEditor.d.ts

@@ -1,9 +1,14 @@
 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;
@@ -19,13 +24,27 @@ export declare class AiSession {
         model: SupportedLlmModel;
         apiKey: string;
     } | null): typeof AiSession;
-    readonly messageHistory: BaseMessage[];
-    constructor(messageHistory?: BaseMessage[]);
-    ask(question: string, { onChunk, }?: EditOptions): Promise<{
+    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, maxTry }?: EditOptions): Promise<string>;
+    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 {};

package/src/commandDecorators/argMeta.d.ts

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