@akanjs/devkit 0.0.143 → 0.0.145

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,19 +77,44 @@ 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);
     }
   } = {}) {
-    if (!AiSession.#chat) {
-      Logger.rawLog(chalk.yellow("\u{1F916}akan-editor is not initialized. LLM configuration should be set first."));
+    if (!AiSession.#chat)
       await AiSession.init();
-    }
     if (!AiSession.#chat)
       throw new Error("Failed to initialize the AI session");
     const loader = new Spinner(`${AiSession.#chat.model} is thinking...`, {
@@ -89,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;
@@ -109,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++;
     }
@@ -131,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/command.js

@@ -179,7 +179,6 @@ const getInternalArgumentValue = async (argMeta, value, workspace) => {
 };
 const runCommands = async (...commands) => {
   process.on("unhandledRejection", (error) => {
-    console.error(chalk.red("[fatal]"), error);
     process.exit(1);
   });
   const hasPackageJson = fs.existsSync(`${__dirname}/../package.json`);