@akanjs/devkit 0.0.142 → 0.0.144

package/esm/src/aiEditor.js

@@ -1,15 +1,23 @@
 import { Logger } from "@akanjs/common";
 import { input, select } from "@inquirer/prompts";
-import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import {
+  AIMessage,
+  HumanMessage,
+  mapChatMessagesToStoredMessages,
+  mapStoredMessagesToChatMessages
+} from "@langchain/core/messages";
+import { ChatDeepSeek } from "@langchain/deepseek";
 import { ChatOpenAI } from "@langchain/openai";
 import chalk from "chalk";
+import fs from "fs";
 import { getAkanGlobalConfig, setAkanGlobalConfig } from "./auth";
 import { Spinner } from "./spinner";
 const MAX_ASK_TRY = 300;
 const supportedLlmModels = ["deepseek-chat", "deepseek-reasoner"];
 class AiSession {
+  static #cacheDir = "node_modules/.cache/akan/aiSession";
   static #chat = null;
-  static async init({ temperature = 0.7, useExisting = true } = {}) {
+  static async init({ temperature = 0, useExisting = true } = {}) {
     if (useExisting) {
       const llmConfig2 = this.getLlmConfig();
       if (llmConfig2) {
@@ -17,18 +25,20 @@ class AiSession {
         Logger.rawLog(chalk.dim(`\u{1F916}akan editor uses existing LLM config (${llmConfig2.model})`));
         return this;
       }
-    }
+    } else
+      Logger.rawLog(chalk.yellow("\u{1F916}akan-editor is not initialized. LLM configuration should be set first."));
     const llmConfig = await this.#requestLlmConfig();
     const { model, apiKey } = llmConfig;
     await this.#validateApiKey(model, apiKey);
     return this.#setChatModel(model, apiKey, { temperature }).setLlmConfig({ model, apiKey });
   }
-  static #setChatModel(model, apiKey, { temperature = 0.7 } = {}) {
-    this.#chat = new ChatOpenAI({
+  static #setChatModel(model, apiKey, { temperature = 0 } = {}) {
+    this.#chat = new ChatDeepSeek({
       modelName: model,
       temperature,
       streaming: true,
-      configuration: { baseURL: "https://api.deepseek.com/v1", apiKey }
+      apiKey
+      // configuration: { baseURL: "https://api.deepseek.com/v1", apiKey },
     });
     return this;
   }
@@ -67,11 +77,38 @@ class AiSession {
       throw error;
     }
   }
+  static clearCache(workspaceRoot) {
+    const cacheDir = `${workspaceRoot}/${this.#cacheDir}`;
+    fs.rmSync(cacheDir, { recursive: true, force: true });
+  }
   messageHistory = [];
-  constructor(messageHistory = []) {
-    this.messageHistory = messageHistory;
+  sessionKey;
+  isCacheLoaded;
+  workspace;
+  constructor(type, { workspace, cacheKey, isContinued }) {
+    this.workspace = workspace;
+    this.sessionKey = `${type}${cacheKey ? `-${cacheKey}` : ""}`;
+    if (isContinued)
+      this.#loadCache();
+  }
+  #loadCache() {
+    const cacheFile = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
+    const isCacheExists = this.workspace.exists(cacheFile);
+    if (isCacheExists)
+      this.messageHistory = mapStoredMessagesToChatMessages(this.workspace.readJson(cacheFile));
+    else
+      this.messageHistory = [];
+    this.isCacheLoaded = isCacheExists;
+    return isCacheExists;
+  }
+  #saveCache() {
+    const cacheFilePath = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
+    this.workspace.writeJson(cacheFilePath, mapChatMessagesToStoredMessages(this.messageHistory));
   }
   async ask(question, {
+    onReasoning = (reasoning) => {
+      Logger.raw(chalk.dim(reasoning));
+    },
     onChunk = (chunk) => {
       Logger.raw(chunk);
     }
@@ -87,10 +124,21 @@ class AiSession {
       const humanMessage = new HumanMessage(question);
       this.messageHistory.push(humanMessage);
       const stream = await AiSession.#chat.stream(this.messageHistory);
-      let fullResponse = "", tokenIdx = 0;
+      let reasoningResponse = "", fullResponse = "", tokenIdx = 0;
       for await (const chunk of stream) {
-        if (loader.isSpinning() && chunk.content.length)
+        if (loader.isSpinning())
           loader.succeed(`${AiSession.#chat.model} responded`);
+        if (!fullResponse.length) {
+          const reasoningContent = chunk.additional_kwargs.reasoning_content ?? "";
+          if (reasoningContent.length) {
+            reasoningResponse += reasoningContent;
+            onReasoning(reasoningContent);
+            continue;
+          } else if (chunk.content.length) {
+            reasoningResponse += "\n";
+            onReasoning(reasoningResponse);
+          }
+        }
         const content = chunk.content;
         if (typeof content === "string") {
           fullResponse += content;
@@ -107,18 +155,25 @@ class AiSession {
       throw new Error("Failed to stream response");
     }
   }
-  async edit(question, { onChunk, maxTry = MAX_ASK_TRY } = {}) {
+  async edit(question, { onChunk, onReasoning, maxTry = MAX_ASK_TRY, validate, approve } = {}) {
     for (let tryCount = 0; tryCount < maxTry; tryCount++) {
-      const response = await this.ask(question, { onChunk });
-      const isConfirmed = await select({
+      let response = await this.ask(question, { onChunk, onReasoning });
+      if (validate?.length && tryCount === 0) {
+        const validateQuestion = `Double check if the response meets the requirements and conditions, and follow the instructions. If not, rewrite it.
+${validate.map((v) => `- ${v}`).join("\n")}`;
+        response = await this.ask(validateQuestion, { onChunk, onReasoning });
+      }
+      const isConfirmed = approve ? true : await select({
         message: "Do you want to edit the response?",
         choices: [
           { name: "\u2705 Yes, confirm and apply this result", value: true },
           { name: "\u{1F504} No, I want to edit it more", value: false }
         ]
       });
-      if (isConfirmed)
+      if (isConfirmed) {
+        this.#saveCache();
         return response.content;
+      }
       question = await input({ message: "What do you want to change?" });
       tryCount++;
     }
@@ -129,9 +184,97 @@ class AiSession {
     return this.#getTypescriptCode(content);
   }
   #getTypescriptCode(content) {
+    //! will be deprecated
     const code = /```(typescript|tsx)([\s\S]*?)```/.exec(content);
     return code ? code[2] : content;
   }
+  addToolMessgaes(messages) {
+    const toolMessages = messages.map((message) => new HumanMessage(message.content));
+    this.messageHistory.push(...toolMessages);
+    return this;
+  }
+  async writeTypescripts(question, executor, options = {}) {
+    const content = await this.edit(question, options);
+    const writes = this.#getTypescriptCodes(content);
+    for (const write of writes)
+      executor.writeFile(write.filePath, write.content);
+    return await this.#tryFixTypescripts(writes, executor, options);
+  }
+  async #editTypescripts(question, options = {}) {
+    const content = await this.edit(question, options);
+    return this.#getTypescriptCodes(content);
+  }
+  async #tryFixTypescripts(writes, executor, options = {}) {
+    const MAX_EDIT_TRY = 5;
+    for (let tryCount = 0; tryCount < MAX_EDIT_TRY; tryCount++) {
+      const loader = new Spinner(`Type checking and linting...`, { prefix: `\u{1F916}akan-editor` }).start();
+      const fileChecks = await Promise.all(
+        writes.map(async ({ filePath }) => {
+          const typeCheckResult = executor.typeCheck(filePath);
+          const lintResult = await executor.lint(filePath);
+          const needFix2 = !!typeCheckResult.errors.length || !!lintResult.errors.length;
+          return { filePath, typeCheckResult, lintResult, needFix: needFix2 };
+        })
+      );
+      const needFix = fileChecks.some((fileCheck) => fileCheck.needFix);
+      if (needFix) {
+        loader.fail("Type checking and linting has some errors, try to fix them");
+        fileChecks.forEach((fileCheck) => {
+          Logger.rawLog(
+            `TypeCheck Result 
+${fileCheck.typeCheckResult.message}
+Lint Result 
+${fileCheck.lintResult.message}`
+          );
+          this.addToolMessgaes([
+            { type: "typescript", content: fileCheck.typeCheckResult.message },
+            { type: "eslint", content: fileCheck.lintResult.message }
+          ]);
+        });
+        writes = await this.#editTypescripts("Fix the typescript and eslint errors", {
+          ...options,
+          validate: void 0,
+          approve: true
+        });
+        for (const write of writes)
+          executor.writeFile(write.filePath, write.content);
+      } else {
+        loader.succeed("Type checking and linting has no errors");
+        return writes;
+      }
+    }
+    throw new Error("Failed to create scalar");
+  }
+  #getTypescriptCodes(text) {
+    const codes = text.match(/```typescript([\s\S]*?)```/g);
+    if (!codes)
+      return [];
+    const result = codes.map((code) => {
+      const content = /```(typescript|tsx)([\s\S]*?)```/.exec(code)?.[2];
+      if (!content)
+        return null;
+      const filePath = /\/\/ File: (.*?)(?:\n|$)/.exec(content)?.[1]?.trim();
+      if (!filePath)
+        return null;
+      const contentWithoutFilepath = content.replace(`// File: ${filePath}
+`, "").trim();
+      return { filePath, content: contentWithoutFilepath };
+    });
+    return result.filter((code) => code !== null);
+  }
+  async editMarkdown(request, options = {}) {
+    const content = await this.edit(request, options);
+    return this.#getMarkdownContent(content);
+  }
+  #getMarkdownContent(text) {
+    const searchText = "```markdown";
+    const firstIndex = text.indexOf("```markdown");
+    const lastIndex = text.lastIndexOf("```");
+    if (firstIndex === -1)
+      return text;
+    else
+      return text.slice(firstIndex + searchText.length, lastIndex).trim();
+  }
 }
 export {
   AiSession,

package/esm/src/builder.js

@@ -17,7 +17,6 @@ class Builder {
     return {
       entryPoints: [
         ...bundle ? [`${this.#executor.cwdPath}/index.ts`] : [`${this.#executor.cwdPath}/**/*.ts`, `${this.#executor.cwdPath}/**/*.tsx`],
-        `${this.#executor.cwdPath}/**/*.template`,
         ...additionalEntryPoints
       ],
       bundle,
@@ -27,7 +26,7 @@ class Builder {
       format,
       outdir: `${this.#distExecutor.cwdPath}/${format}`,
       logLevel: "error",
-      loader: { ".template": "copy" }
+      loader: { ".template": "copy", ".md": "copy" }
     };
   }
   #getAssetBuildOptions() {

package/esm/src/commandDecorators/argMeta.js

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 const argTypes = ["Argument", "Option"];
-const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg", "Exec"];
+const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg", "Module", "Exec"];
 const getArgMetas = (command, key) => {
   const allArgMetas = getArgMetasOnPrototype(command.prototype, key);
   const argMetas = allArgMetas.filter((argMeta) => argMeta.type === "Option");
@@ -36,12 +36,14 @@ const Lib = createArgMetaDecorator("Lib");
 const Sys = createArgMetaDecorator("Sys");
 const Exec = createArgMetaDecorator("Exec");
 const Pkg = createArgMetaDecorator("Pkg");
+const Module = createArgMetaDecorator("Module");
 const Workspace = createArgMetaDecorator("Workspace");
 export {
   App,
   Argument,
   Exec,
   Lib,
+  Module,
   Option,
   Pkg,
   Sys,

package/esm/src/commandDecorators/command.js

@@ -3,7 +3,7 @@ import { confirm, input, select } from "@inquirer/prompts";
 import chalk from "chalk";
 import { program } from "commander";
 import fs from "fs";
-import { AppExecutor, Executor, LibExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
+import { AppExecutor, Executor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
 import { getArgMetas } from "./argMeta";
 import { getTargetMetas } from "./targetMeta";
 const camelToKebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
@@ -142,12 +142,43 @@ const getInternalArgumentValue = async (argMeta, value, workspace) => {
       return PkgExecutor.from(workspace, value);
     const pkgName = await select({ message: `Select the ${sysType} name`, choices: pkgs });
     return PkgExecutor.from(workspace, pkgName);
+  } else if (sysType === "module") {
+    if (value) {
+      const [sysName, moduleName2] = value.split(":");
+      if (appNames.includes(sysName)) {
+        const app = AppExecutor.from(workspace, sysName);
+        const modules2 = await app.getModules();
+        if (modules2.includes(moduleName2))
+          return ModuleExecutor.from(app, moduleName2);
+        else
+          throw new Error(`Invalid module name: ${moduleName2}`);
+      } else if (libNames.includes(sysName)) {
+        const lib = LibExecutor.from(workspace, sysName);
+        const modules2 = await lib.getModules();
+        if (modules2.includes(moduleName2))
+          return ModuleExecutor.from(lib, moduleName2);
+      } else
+        throw new Error(`Invalid system name: ${sysName}`);
+    }
+    const { type, name } = await select({
+      message: `select the App or Lib name`,
+      choices: [
+        ...appNames.map((name2) => ({ name: name2, value: { type: "app", name: name2 } })),
+        ...libNames.map((name2) => ({ name: name2, value: { type: "lib", name: name2 } }))
+      ]
+    });
+    const executor = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
+    const modules = await executor.getModules();
+    const moduleName = await select({
+      message: `Select the module name`,
+      choices: modules.map((name2) => ({ name: `${executor.name}:${name2}`, value: name2 }))
+    });
+    return ModuleExecutor.from(executor, moduleName);
   } else
     throw new Error(`Invalid system type: ${argMeta.type}`);
 };
 const runCommands = async (...commands) => {
   process.on("unhandledRejection", (error) => {
-    console.error(chalk.red("[fatal]"), error);
     process.exit(1);
   });
   const hasPackageJson = fs.existsSync(`${__dirname}/../package.json`);
@@ -173,11 +204,18 @@ const runCommands = async (...commands) => {
             programCommand = handleArgument(programCommand, argMeta);
           else if (argMeta.type === "Workspace")
             continue;
-          const sysType = argMeta.type.toLowerCase();
-          programCommand = programCommand.argument(
-            `[${sysType}]`,
-            `${sysType} in this workspace ${sysType}s/<${sysType}Name>`
-          );
+          else if (argMeta.type === "Module") {
+            programCommand = programCommand.argument(
+              `[sys-name:module-name]`,
+              `${argMeta.type} in this workspace (apps|libs)/<sys-name>/lib/<module-name>`
+            );
+          } else {
+            const sysType = argMeta.type.toLowerCase();
+            programCommand = programCommand.argument(
+              `[${sysType}]`,
+              `${sysType} in this workspace ${sysType}s/<${sysType}Name>`
+            );
+          }
         }
         programCommand = programCommand.option(`-v, --verbose [boolean]`, `verbose output`);
         programCommand.action(async (...args) => {