@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/README.ko.md

@@ -0,0 +1,65 @@
+# @akanjs/devkit
+
+[문서](https://akanjs.com/docs) | [npm](https://www.npmjs.com/package/@akanjs/devkit) | [런타임](https://www.npmjs.com/package/akanjs)
+
+Akan.js를 위한 development tooling primitive입니다.
+
+`@akanjs/devkit`은 Akan CLI와 프레임워크 수준 tooling에서 사용하는 build runner, workspace
+executor, config loader, dependency scanner, frontend artifact builder, command decorator, prompt,
+release helper를 담고 있습니다. 애플리케이션 런타임 코드가 아니라 tooling과 package author를 위한
+패키지입니다.
+
+## 설치
+
+대부분의 사용자는 devkit 대신 CLI를 설치하면 됩니다.
+
+```bash
+bun install -g @akanjs/cli@latest
+```
+
+Akan-aware tooling을 직접 만들 때만 `@akanjs/devkit`을 설치하세요.
+
+```bash
+bun add -d @akanjs/devkit
+```
+
+## 사용 예시
+
+```ts
+import { ApplicationBuildRunner, WorkspaceExecutor } from "@akanjs/devkit";
+
+const workspace = WorkspaceExecutor.fromRoot();
+const app = await workspace.getApp("my-app");
+const runner = new ApplicationBuildRunner(app);
+
+await runner.build();
+```
+
+## 제공하는 것
+
+- Workspace, app, library, package, module executor.
+- `akan.config.ts` 로딩과 정규화.
+- Application build, typecheck, SSR, CSR, release runner.
+- Dependency scanning과 package metadata 생성 helper.
+- Frontend build transform과 RSC/SSR artifact builder.
+- `@akanjs/cli`가 사용하는 command/script decorator.
+- AI prompt, guideline, code-generation 지원 utility.
+- Capacitor와 mobile release helper.
+
+## 패키지 경계
+
+- 런타임 코드는 `akanjs`에서 import해야 합니다. `AppConfig`, `LibConfig`, `AppInfo`, `LibInfo` 같은
+  공유 config 타입도 `akanjs`에서 가져옵니다.
+- CLI 사용자는 `@akanjs/cli`를 설치하면 됩니다. published CLI는 이 devkit을 내부에 번들링합니다.
+- Tooling author는 Akan workspace introspection이나 build API가 필요할 때 `@akanjs/devkit`을 직접
+  import할 수 있습니다.
+
+## 요구사항
+
+- [Bun](https://bun.sh) `>=1.3.13`
+- TypeScript
+- Optional peer는 Capacitor integration처럼 해당 기능을 사용할 때만 필요합니다.
+
+## 라이선스
+
+MIT

package/README.md

@@ -1,7 +1,63 @@
-> 🎉 **Akanjs v2 has been released!**
->
-> This package is under maintenance for existing users, but we recommend using Akanjs v2 for new projects.
->
-> For the unified and latest version package, please visit [akanjs](https://www.npmjs.com/package/akanjs).
+# @akanjs/devkit
 
-This package is a sub-library of akanjs. For more information, please refer to [@akanjs/cli](https://www.npmjs.com/package/@akanjs/cli) and the [Akan.js Github](https://github.com/akan-team/akanjs).
+[Docs](https://akanjs.com/docs) | [npm](https://www.npmjs.com/package/@akanjs/devkit) | [Runtime](https://www.npmjs.com/package/akanjs)
+
+Development tooling primitives for Akan.js.
+
+`@akanjs/devkit` contains the build runners, workspace executors, config loaders, dependency scanners,
+frontend artifact builders, command decorators, prompts, and release helpers used by the Akan CLI and by
+framework-level tooling. It is intended for tools and package authors, not for application runtime code.
+
+## Install
+
+Most users should install the CLI instead:
+
+```bash
+bun install -g @akanjs/cli@latest
+```
+
+Install `@akanjs/devkit` directly only when building Akan-aware tooling:
+
+```bash
+bun add -d @akanjs/devkit
+```
+
+## Usage
+
+```ts
+import { ApplicationBuildRunner, WorkspaceExecutor } from "@akanjs/devkit";
+
+const workspace = WorkspaceExecutor.fromRoot();
+const app = await workspace.getApp("my-app");
+const runner = new ApplicationBuildRunner(app);
+
+await runner.build();
+```
+
+## What It Provides
+
+- Workspace, app, library, package, and module executors.
+- `akan.config.ts` loading and normalization.
+- Application build, typecheck, SSR, CSR, and release runners.
+- Dependency scanning and package metadata generation helpers.
+- Frontend build transforms and RSC/SSR artifact builders.
+- Command/script decorators used by `@akanjs/cli`.
+- AI prompt, guideline, and code-generation support utilities.
+- Capacitor and mobile release helpers.
+
+## Package Boundary
+
+- Runtime code should import from `akanjs`, including shared config types such as `AppConfig`, `LibConfig`,
+  `AppInfo`, and `LibInfo`.
+- CLI users should install `@akanjs/cli`; the published CLI bundles this devkit internally.
+- Tooling authors can import `@akanjs/devkit` directly when they need Akan workspace introspection or build APIs.
+
+## Requirements
+
+- [Bun](https://bun.sh) `>=1.3.13`
+- TypeScript
+- Optional peers are only needed for the features that use them, such as Capacitor integration.
+
+## License
+
+MIT

package/aiEditor.ts

@@ -0,0 +1,304 @@
+import { input, select } from "@inquirer/prompts";
+import {
+  AIMessage,
+  type BaseMessage,
+  HumanMessage,
+  mapChatMessagesToStoredMessages,
+  mapStoredMessagesToChatMessages,
+  type StoredMessage,
+} from "@langchain/core/messages";
+import { ChatDeepSeek } from "@langchain/deepseek";
+import { ChatOpenAI } from "@langchain/openai";
+import { Logger } from "akanjs/common";
+import chalk from "chalk";
+
+import { getAkanGlobalConfig, setAkanGlobalConfig } from "./auth";
+import type { Executor, WorkspaceExecutor } from "./executors";
+import { Spinner } from "./spinner";
+import type { FileContent } from "./types";
+
+const MAX_ASK_TRY = 300;
+
+export const supportedLlmModels = ["deepseek-chat", "deepseek-reasoner"] as const;
+export type SupportedLlmModel = (typeof supportedLlmModels)[number];
+
+interface EditOptions {
+  onReasoning?: (reasoning: string) => void;
+  onChunk?: (chunk: string) => void;
+  maxTry?: number;
+  validate?: string[];
+  approve?: boolean;
+}
+
+export class AiSession {
+  static #cacheDir = "node_modules/.cache/akan/aiSession";
+  static #chat: ChatDeepSeek | ChatOpenAI | null = null;
+  static async init({ temperature = 0, useExisting = true }: { temperature?: number; useExisting?: boolean } = {}) {
+    if (useExisting) {
+      const llmConfig = await AiSession.getLlmConfig();
+      if (llmConfig) {
+        AiSession.#setChatModel(llmConfig.model, llmConfig.apiKey);
+        Logger.rawLog(chalk.dim(`🤖akan editor uses existing LLM config (${llmConfig.model})`));
+        return AiSession;
+      }
+    } else Logger.rawLog(chalk.yellow("🤖akan-editor is not initialized. LLM configuration should be set first."));
+
+    const llmConfig = await AiSession.#requestLlmConfig();
+    const { model, apiKey } = llmConfig;
+
+    await AiSession.#validateApiKey(model, apiKey);
+    const session = AiSession.#setChatModel(model, apiKey, { temperature });
+    await session.setLlmConfig({ model, apiKey });
+    return session;
+  }
+  static #setChatModel(model: SupportedLlmModel, apiKey: string, { temperature = 0 }: { temperature?: number } = {}) {
+    AiSession.#chat = new ChatDeepSeek({
+      modelName: model,
+      temperature,
+      streaming: true,
+      apiKey,
+      // configuration: { baseURL: "https://api.deepseek.com/v1", apiKey },
+    });
+    return AiSession;
+  }
+  static async getLlmConfig() {
+    const akanConfig = await getAkanGlobalConfig();
+    return akanConfig.llm ?? null;
+  }
+  static async setLlmConfig(llmConfig: { model: SupportedLlmModel; apiKey: string } | null) {
+    const akanConfig = await getAkanGlobalConfig();
+    akanConfig.llm = llmConfig;
+    await setAkanGlobalConfig(akanConfig);
+    return AiSession;
+  }
+  static async #requestLlmConfig() {
+    const model = await select<SupportedLlmModel>({ message: "Select a LLM model", choices: supportedLlmModels });
+    const apiKey = await input({ message: "Enter your API key" });
+    return { model, apiKey };
+  }
+  static async #validateApiKey(modelName: SupportedLlmModel, apiKey: string) {
+    const spinner = new Spinner("Validating LLM API key...", { prefix: `🤖akan-editor` }).start();
+    const chat = new ChatOpenAI({
+      modelName,
+      temperature: 0,
+      configuration: { baseURL: "https://api.deepseek.com/v1", apiKey },
+    });
+    try {
+      await chat.invoke("Hi, and just say 'ok'");
+      spinner.succeed("LLM API key is valid");
+      return true;
+    } catch (error) {
+      spinner.fail(
+        chalk.red(
+          `LLM API key is invalid. Please check your API key and try again. You can set it again by running "akan set-llm" or reset by running "akan reset-llm"`,
+        ),
+      );
+      throw error;
+    }
+  }
+  static async clearCache(workspaceRoot: string) {
+    const cacheDir = `${workspaceRoot}/${AiSession.#cacheDir}`;
+    await Bun.$`rm -rf ${cacheDir}`;
+  }
+
+  messageHistory: BaseMessage[] = [];
+  readonly sessionKey: string;
+  isCacheLoaded: boolean = false;
+  workspace: WorkspaceExecutor;
+  constructor(
+    type: string,
+    { workspace, cacheKey, isContinued }: { workspace: WorkspaceExecutor; cacheKey?: string; isContinued?: boolean },
+  ) {
+    this.workspace = workspace;
+    this.sessionKey = `${type}${cacheKey ? `-${cacheKey}` : ""}`;
+    if (isContinued) this.#cacheLoadPromise = this.#loadCache();
+  }
+  #cacheLoadPromise: Promise<void> | null = null;
+  async #loadCache() {
+    const cacheFile = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
+    const isCacheExists = await this.workspace.exists(cacheFile);
+    if (isCacheExists)
+      this.messageHistory = mapStoredMessagesToChatMessages(
+        (await this.workspace.readJson(cacheFile)) as StoredMessage[],
+      );
+    else this.messageHistory = [];
+    this.isCacheLoaded = isCacheExists;
+  }
+  async #saveCache() {
+    const cacheFilePath = `${AiSession.#cacheDir}/${this.sessionKey}.json`;
+    await this.workspace.writeJson(cacheFilePath, mapChatMessagesToStoredMessages(this.messageHistory));
+  }
+  async ask(
+    question: string,
+    {
+      onReasoning = (reasoning: string) => {
+        Logger.raw(chalk.dim(reasoning));
+      },
+      onChunk = (chunk: string) => {
+        Logger.raw(chunk);
+      },
+    }: EditOptions = {},
+  ): Promise<{ content: string; messageHistory: BaseMessage[] }> {
+    if (!AiSession.#chat) await AiSession.init();
+    if (this.#cacheLoadPromise) await this.#cacheLoadPromise;
+
+    if (!AiSession.#chat) throw new Error("Failed to initialize the AI session");
+    const loader = new Spinner(`${AiSession.#chat.model} is thinking...`, {
+      prefix: `🤖akan-editor`,
+    }).start();
+    try {
+      const humanMessage = new HumanMessage(question);
+      this.messageHistory.push(humanMessage);
+      const stream = await AiSession.#chat.stream(this.messageHistory);
+      let reasoningResponse = "",
+        fullResponse = "",
+        tokenIdx = 0;
+      for await (const chunk of stream) {
+        if (loader.isSpinning()) loader.succeed(`${AiSession.#chat.model} responded`);
+
+        if (!fullResponse.length) {
+          const reasoningContent = (chunk.additional_kwargs as { reasoning_content?: string }).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;
+          onChunk(content); // Send individual chunks to callback
+        }
+        tokenIdx++;
+      }
+      fullResponse += "\n";
+      onChunk("\n");
+      this.messageHistory.push(new AIMessage(fullResponse));
+      return { content: fullResponse, messageHistory: this.messageHistory };
+    } catch (error) {
+      loader.fail(`${AiSession.#chat.model} failed to respond`);
+      throw new Error("Failed to stream response");
+    }
+  }
+  async edit(question: string, { onChunk, onReasoning, maxTry = MAX_ASK_TRY, validate, approve }: EditOptions = {}) {
+    for (let tryCount = 0; tryCount < maxTry; tryCount++) {
+      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: "✅ Yes, confirm and apply this result", value: true },
+              { name: "🔄 No, I want to edit it more", value: false },
+            ],
+          });
+      if (isConfirmed) {
+        await this.#saveCache();
+        return response.content;
+      }
+      question = await input({ message: "What do you want to change?" });
+      tryCount++;
+    }
+    throw new Error("Failed to edit");
+  }
+  async editTypescript(question: string, options: EditOptions = {}) {
+    const content = await this.edit(question, options);
+    return this.#getTypescriptCode(content);
+  }
+  #getTypescriptCode(content: string) {
+    //! will be deprecated
+    const code = /```(typescript|tsx)([\s\S]*?)```/.exec(content);
+    // 2번째로 해야 반환되는데 모르겟음 아무튼 일단 이렇게 함.
+
+    return code?.[2] ?? content;
+    // return code ? code[1] : content;
+  }
+  addToolMessgaes(messages: { type: string; content: string }[]) {
+    // const toolMessages = messages.map(
+    //   (message) => new ToolMessage({ content: message.content, tool_call_id: message.type })
+    // );
+    const toolMessages = messages.map((message) => new HumanMessage(message.content));
+    this.messageHistory.push(...toolMessages);
+    return this;
+  }
+  async writeTypescripts(question: string, executor: Executor, options: EditOptions = {}) {
+    const content = await this.edit(question, options);
+    const writes = this.#getTypescriptCodes(content);
+    for (const write of writes) await executor.writeFile(write.filePath, write.content);
+    return await this.#tryFixTypescripts(writes, executor, options);
+  }
+  async #editTypescripts(question: string, options: EditOptions = {}) {
+    const content = await this.edit(question, options);
+    return this.#getTypescriptCodes(content);
+  }
+  async #tryFixTypescripts(writes: FileContent[], executor: Executor, options: EditOptions = {}) {
+    const MAX_EDIT_TRY = 5;
+    for (let tryCount = 0; tryCount < MAX_EDIT_TRY; tryCount++) {
+      const loader = new Spinner(`Type checking and linting...`, { prefix: `🤖akan-editor` }).start();
+      const fileChecks = await Promise.all(
+        writes.map(async ({ filePath }) => {
+          const typeCheckResult = executor.typeCheck(filePath);
+          const lintResult = await executor.lint(filePath);
+          const needFix = !!typeCheckResult.fileErrors.length || !!lintResult.errors.length;
+          return { filePath, typeCheckResult, lintResult, needFix };
+        }),
+      );
+      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 \n${fileCheck.typeCheckResult.message}\nLint Result \n${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: undefined,
+          approve: true,
+        });
+        for (const write of writes) await 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: string): FileContent[] {
+    const codes = text.match(/```(typescript|tsx)([\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}\n`, "").trim();
+      return { filePath, content: contentWithoutFilepath };
+    });
+    return result.filter((code) => code !== null) as FileContent[];
+  }
+  async editMarkdown(request: string, options: EditOptions = {}) {
+    const content = await this.edit(request, options);
+    return this.#getMarkdownContent(content);
+  }
+  #getMarkdownContent(text: string) {
+    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();
+  }
+}