@akanjs/devkit 0.0.143 → 0.0.145

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.143",
+  "version": "0.0.145",
   "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/executors.d.ts

@@ -1,8 +1,10 @@
 import { Logger } from "@akanjs/common";
 import { type AppConfigResult, AppScanResult, type LibConfigResult, LibScanResult, PkgScanResult, WorkspaceScanResult } from "@akanjs/config";
 import { type ExecOptions, type ForkOptions, type SpawnOptions } from "child_process";
+import { Linter } from "./linter";
 import { Spinner } from "./spinner";
-import type { PackageJson, TsConfigJson } from "./types";
+import { TypeChecker } from "./typeChecker";
+import type { FileContent, PackageJson, TsConfigJson } from "./types";
 export declare const execEmoji: {
     workspace: string;
     app: string;
@@ -20,23 +22,24 @@ export declare class Executor {
     logger: Logger;
     cwdPath: string;
     emoji: string;
+    typeChecker: TypeChecker | null;
+    linter: Linter | null;
     constructor(name: string, cwdPath: string);
     exec(command: string, options?: ExecOptions): Promise<unknown>;
-    spawn(command: string, args?: string[], options?: SpawnOptions): Promise<{
-        code: number | null;
-        signal: string | null;
-    }>;
+    spawn(command: string, args?: string[], options?: SpawnOptions): Promise<string>;
     fork(modulePath: string, args?: string[], options?: ForkOptions): Promise<unknown>;
+    getPath(filePath: string): string;
     mkdir(dirPath: string): this;
+    readdir(dirPath: string): Promise<string[]>;
     exists(filePath: string): boolean;
     remove(filePath: string): this;
     removeDir(dirPath: string): this;
     writeFile(filePath: string, content: string | object, { overwrite }?: {
         overwrite?: boolean;
-    }): this;
+    }): FileContent;
     writeJson(filePath: string, content: object): this;
-    getLocalFile(filePath: string): {
-        filepath: string;
+    getLocalFile(targetPath: string): {
+        filePath: string;
         content: string;
     };
     readFile(filePath: string): string;
@@ -50,7 +53,7 @@ export declare class Executor {
         enableSpin?: boolean | undefined;
     }): Spinner;
     getTsConfig(pathname?: string): TsConfigJson;
-    applyTemplate({ basePath, template, scanResult, dict, overwrite, }: {
+    _applyTemplate({ basePath, template, scanResult, dict, overwrite, }: {
         basePath: string;
         template: string;
         scanResult?: AppScanResult | LibScanResult | null;
@@ -58,7 +61,32 @@ export declare class Executor {
             [key: string]: string;
         };
         overwrite?: boolean;
-    }): Promise<void>;
+    }): Promise<FileContent[]>;
+    applyTemplate(options: {
+        basePath: string;
+        template: string;
+        dict?: {
+            [key: string]: string;
+        };
+        overwrite?: boolean;
+    }): Promise<FileContent[]>;
+    getTypeChecker(): TypeChecker;
+    typeCheck(filePath: string): {
+        diagnostics: import("typescript").Diagnostic[];
+        errors: import("typescript").Diagnostic[];
+        warnings: import("typescript").Diagnostic[];
+        message: string;
+    };
+    getLinter(): Linter;
+    lint(filePath: string, { fix, dryRun }?: {
+        fix?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        results: import("eslint").ESLint.LintResult[];
+        message: string;
+        errors: import("eslint").Linter.LintMessage[];
+        warnings: import("eslint").Linter.LintMessage[];
+    }>;
 }
 interface ExecutorOptions {
     workspaceRoot: string;
@@ -91,19 +119,19 @@ export declare class WorkspaceExecutor extends Executor {
         add?: boolean;
     }): Promise<void>;
     getScalarConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getDictionaryFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getViewFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
 }
@@ -126,8 +154,8 @@ export declare class SysExecutor extends Executor {
     }, libScanResults?: {
         [key: string]: LibScanResult;
     }): Promise<AppScanResult | LibScanResult>;
-    getLocalFile(filePath: string): {
-        filepath: string;
+    getLocalFile(targetPath: string): {
+        filePath: string;
         content: string;
     };
     getDatabaseModules(): Promise<string[]>;
@@ -137,33 +165,45 @@ export declare class SysExecutor extends Executor {
     getUnitComponents(): Promise<string[]>;
     getTemplateComponents(): Promise<string[]>;
     getViewsSourceCode(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getUnitsSourceCode(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getTemplatesSourceCode(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getScalarConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getScalarDictionaryFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
     getConstantFiles(): Promise<{
-        filepath: string;
+        filePath: string;
+        content: string;
+    }[]>;
+    getConstantFilesWithLibs(): Promise<{
+        filePath: string;
         content: string;
     }[]>;
     getDictionaryFiles(): Promise<{
-        filepath: string;
+        filePath: string;
         content: string;
     }[]>;
+    applyTemplate(options: {
+        basePath: string;
+        template: string;
+        dict?: {
+            [key: string]: string;
+        };
+        overwrite?: boolean;
+    }): Promise<FileContent[]>;
     setTsPaths(): this;
 }
 interface AppExecutorOptions {

package/src/guideline.d.ts

@@ -0,0 +1,19 @@
+export interface GuideScan {
+    type: "example" | "source" | "usage" | (string & {});
+    description: string;
+    path: string;
+    filterText?: string;
+    sample?: number;
+}
+export interface GuideUpdate {
+    filePath: string;
+    contents: string[];
+    rules: string[];
+}
+export interface GuideGenerateJson {
+    title: string;
+    description: string;
+    scans: GuideScan[];
+    update: GuideUpdate;
+    page: string;
+}

package/src/index.d.ts

@@ -16,3 +16,5 @@ export * from "./commandDecorators";
 export * from "./aiEditor";
 export * from "./builder";
 export * from "./spinner";
+export * from "./prompter";
+export * from "./guideline";