@akanjs/devkit 0.0.143 → 0.0.144

package/cjs/src/aiEditor.js

@@ -34,15 +34,18 @@ module.exports = __toCommonJS(aiEditor_exports);
 var import_common = require("@akanjs/common");
 var import_prompts = require("@inquirer/prompts");
 var import_messages = require("@langchain/core/messages");
+var import_deepseek = require("@langchain/deepseek");
 var import_openai = require("@langchain/openai");
 var import_chalk = __toESM(require("chalk"));
+var import_fs = __toESM(require("fs"));
 var import_auth = require("./auth");
 var import_spinner = require("./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) {
@@ -50,18 +53,20 @@ class AiSession {
         import_common.Logger.rawLog(import_chalk.default.dim(`\u{1F916}akan editor uses existing LLM config (${llmConfig2.model})`));
         return this;
       }
-    }
+    } else
+      import_common.Logger.rawLog(import_chalk.default.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 import_openai.ChatOpenAI({
+  static #setChatModel(model, apiKey, { temperature = 0 } = {}) {
+    this.#chat = new import_deepseek.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;
   }
@@ -100,19 +105,44 @@ class AiSession {
       throw error;
     }
   }
+  static clearCache(workspaceRoot) {
+    const cacheDir = `${workspaceRoot}/${this.#cacheDir}`;
+    import_fs.default.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 = (0, import_messages.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, (0, import_messages.mapChatMessagesToStoredMessages)(this.messageHistory));
   }
   async ask(question, {
+    onReasoning = (reasoning) => {
+      import_common.Logger.raw(import_chalk.default.dim(reasoning));
+    },
     onChunk = (chunk) => {
       import_common.Logger.raw(chunk);
     }
   } = {}) {
-    if (!AiSession.#chat) {
-      import_common.Logger.rawLog(import_chalk.default.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 import_spinner.Spinner(`${AiSession.#chat.model} is thinking...`, {
@@ -122,10 +152,21 @@ class AiSession {
       const humanMessage = new import_messages.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;
@@ -142,18 +183,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 (0, import_prompts.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 (0, import_prompts.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 (0, import_prompts.input)({ message: "What do you want to change?" });
       tryCount++;
     }
@@ -164,9 +212,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 import_messages.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 import_spinner.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) => {
+          import_common.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();
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/cjs/src/builder.js

@@ -49,7 +49,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,
@@ -59,7 +58,7 @@ class Builder {
       format,
       outdir: `${this.#distExecutor.cwdPath}/${format}`,
       logLevel: "error",
-      loader: { ".template": "copy" }
+      loader: { ".template": "copy", ".md": "copy" }
     };
   }
   #getAssetBuildOptions() {

package/cjs/src/commandDecorators/command.js

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