agentica 0.1.0 → 0.12.4

package/src/executable/AgenticaStart.ts

@@ -0,0 +1,301 @@
+import chalk from "chalk";
+import cp from "child_process";
+import fs from "fs/promises";
+import inquirer, { QuestionCollection } from "inquirer";
+import path from "path";
+import prettier from "prettier";
+import typia from "typia";
+
+import { Connector } from "../bases/Connector";
+import { Package } from "../bases/Package";
+import { Tsconfig } from "../bases/Tsconfig";
+import { IAgenticaStart } from "../structures/IAgenticaStart";
+import { IAgenticaStartOption } from "../structures/IAgenticaStartOption";
+import { createProjectDirectory } from "../utils/createProjectDirectory";
+import { getNpmPackages } from "../utils/getNpmPackages";
+import { PackageManager } from "../utils/types/PackageManager";
+import { ProjectOptionValue } from "../utils/types/ProjectOption";
+
+export namespace AgenticaStart {
+  /**
+   * Execute `start` command.
+   */
+  export async function execute({
+    projectName,
+    options,
+  }: IAgenticaStart.IExecuteInput) {
+    const projectPath = path.join(process.cwd(), projectName);
+
+    // Check if project already exists
+    if (
+      await fs
+        .access(path.join(process.cwd(), projectName))
+        .then(() => true)
+        .catch(() => false)
+    ) {
+      console.error(
+        `❌ Project ${chalk.redBright(projectName)} already exists`,
+      );
+      return;
+    }
+
+    // Get connector package names from npm and sort alphabetically
+    const availableServices = (await getNpmPackages()).sort((a, b) =>
+      a.name.localeCompare(b.name),
+    );
+
+    const questions = getQuestions({ services: availableServices, options });
+    const config = {
+      ...(await inquirer.prompt<{
+        projectType: ProjectOptionValue;
+        services: string[];
+        packageManager: PackageManager;
+        openAIKey: string;
+      }>(questions)),
+      ...(options.project ? { projectType: options.project } : {}),
+    };
+
+    const validAnswers = typia.assert(config);
+    const { packageManager, openAIKey, projectType, services } = validAnswers;
+
+    await AgenticaStarter.execute(projectType)({
+      projectName,
+      projectPath,
+      openAIKey,
+      services,
+    });
+
+    // Run package installation
+    console.log("📦 Package installation in progress...");
+
+    Package.installPackage(packageManager)({
+      projectPath,
+      services,
+    });
+
+    console.log(`\n🎉 Project ${projectName} created`);
+
+    console.log(
+      `\n⚠️  ${chalk.yellow("Note:")} Please implement constructor values for each controller generated in agent.ts or index.ts`,
+    );
+  }
+
+  /**
+   * Get questions for `start` command.
+   */
+  const getQuestions = (
+    input: IAgenticaStart.IGetQuestionsInput,
+  ): QuestionCollection[] => {
+    const questions = [
+      {
+        type: "list",
+        name: "packageManager",
+        message: "Package Manager",
+        choices: [
+          "npm",
+          "pnpm",
+          {
+            name: `yarn (berry ${chalk.blueBright("is not supported")})`,
+            value: "yarn",
+          },
+        ],
+      },
+      input.options.project
+        ? null
+        : {
+            type: "list",
+            name: "projectType",
+            message: "Project Type",
+            choices: Object.values(AgenticaStarter.PROJECT).map((project) => ({
+              name: project.title,
+              value: project.key,
+            })),
+          },
+      {
+        type: "checkbox",
+        name: "services",
+        message: "Embedded Controllers",
+        choices: input.services,
+      },
+      {
+        type: "input",
+        name: "openAIKey",
+        message: "Please enter your OPENAI_API_KEY:",
+      },
+    ] satisfies (QuestionCollection | null)[];
+
+    return questions.filter((question) => question !== null);
+  };
+}
+
+/**
+ * Methods for Agentica start options.
+ */
+namespace AgenticaStarter {
+  export const execute = (option: ProjectOptionValue) => {
+    const runner = PROJECT[option].runner;
+    if (!runner) {
+      throw new Error(`Not supported project type: ${option}`);
+    }
+
+    return runner;
+  };
+
+  export const PROJECT = {
+    standalone: {
+      title: `Standalone ${chalk.blueBright("Application")}`,
+      key: "standalone",
+      runner: async (input: IAgenticaStartOption.IProject): Promise<void> => {
+        // Create project directory
+        createProjectDirectory({ projectPath: input.projectPath });
+
+        // Create package.json (without dependencies)
+        await Promise.all([
+          // create package.json
+          Package.create({
+            projectName: input.projectName,
+            projectPath: input.projectPath,
+          }),
+          // create tsconfig.json
+          Tsconfig.create({ projectPath: input.projectPath }),
+        ]);
+
+        await fs.mkdir(path.join(input.projectPath, "src"), {
+          recursive: false,
+        });
+
+        // Create Agentica code
+        const agenticaCode = Connector.createAll({ services: input.services });
+
+        await writeTypescriptFile({
+          filePath: path.join(input.projectPath, "src/agent.ts"),
+          taskName: "Agentica code",
+          content: agenticaCode,
+        });
+        await setEnvFiles(input);
+      },
+    },
+
+    nodejs: {
+      title: `NodeJS ${chalk.blueBright("Agent Server")}`,
+      key: "nodejs",
+      runner: async (input: IAgenticaStartOption.IProject): Promise<void> =>
+        nonStandalone("nodejs")(input)(async () => {
+          // Modify index.ts: replace import and controller code
+          const indexFilePath = path.join(input.projectPath, "src/index.ts");
+          const indexFileContent = await fs
+            .readFile(indexFilePath, "utf-8")
+            .then((content) => {
+              if (input.services.length !== 0) {
+                return content
+                  .replace(/import { BbsArticleService }.*;\n/g, "")
+                  .replace(
+                    /controllers:\s*\[[\s\S]*?\],\n/,
+                    "controllers: [/// INSERT CONTROLLER HERE],\n",
+                  );
+              }
+              return content;
+            });
+
+          return { indexFilePath, indexFileContent };
+        }),
+    },
+    nestjs: {
+      title: `NestJS ${chalk.blueBright("Agent Server")}`,
+      key: "nestjs",
+      runner: async (input: IAgenticaStartOption.IProject): Promise<void> =>
+        nonStandalone("nestjs")(input)(async () => {
+          const indexFilePath = path.join(
+            input.projectPath,
+            "src/controllers/chat/ChatController.ts",
+          );
+
+          const indexFileContent = await fs.readFile(indexFilePath, "utf-8");
+          return { indexFilePath, indexFileContent };
+        }),
+    },
+    react: {
+      title: `React ${chalk.blueBright("Client Application")} (Currently not supported)`,
+      key: "react",
+      runner: undefined,
+    },
+  } as const;
+
+  const nonStandalone =
+    (option: "nodejs" | "nestjs") =>
+    (input: IAgenticaStartOption.IProject) =>
+    async (
+      getIndexFileInfo: () => Promise<{
+        indexFilePath: string;
+        indexFileContent: string;
+      }>,
+    ) => {
+      clone(option, input.projectName);
+
+      // Create Agentica code
+      const importCode = Connector.create("import")({
+        services: input.services,
+      });
+
+      const connectorCode = Connector.create("connector")({
+        services: input.services,
+      });
+
+      const { indexFilePath, indexFileContent } = await getIndexFileInfo();
+
+      // Insert importCode and connectorCode
+      const agenticaCode = indexFileContent
+        .replace("/// INSERT IMPORT HERE", importCode)
+        .replace("/// INSERT CONTROLLER HERE", connectorCode);
+
+      await writeTypescriptFile({
+        filePath: indexFilePath,
+        taskName: "Agentica code",
+        content: agenticaCode,
+      });
+      await setEnvFiles(input);
+    };
+
+  const writeTypescriptFile = async (props: {
+    filePath: string;
+    taskName: string;
+    content: string;
+  }): Promise<void> => {
+    const formattedFileContent = await prettier.format(props.content, {
+      parser: "typescript",
+    });
+
+    await fs.writeFile(props.filePath, formattedFileContent);
+    console.log(`✅ ${props.taskName} created`);
+  };
+  /**
+   * Set project .env files
+   */
+  const setEnvFiles = async (
+    input: IAgenticaStartOption.IProject,
+  ): Promise<void> => {
+    // Create .env file
+    const envContent = `OPENAI_API_KEY=${input.openAIKey}\n`;
+    await fs.writeFile(path.join(input.projectPath, ".env"), envContent);
+    console.log("✅ .env created");
+  };
+  /**
+   * Git Clone from template repository.
+   */
+  export const clone = (type: ProjectOptionValue, directory: string): void => {
+    const execute = (command: string): void => {
+      console.log(`\n$ ${command}`);
+      cp.execSync(command, { stdio: "inherit" });
+    };
+
+    // COPY PROJECTS
+    execute(
+      `git clone git@github.com:wrtnlabs/agentica.template.${type} ${directory}`,
+    );
+    process.chdir(directory);
+
+    // REMOVE .GIT DIRECTORY
+    cp.execSync("npx rimraf .git");
+    cp.execSync("npx rimraf .github/dependabot.yml");
+  };
+}

package/src/index.ts

@@ -1,60 +1,39 @@
-#!/usr/bin/env node
-import cp from "child_process";
-import fs from "fs";
-
-const USAGE = `Wrong command has been detected. Use like below:
-
-npx agentica <type> <directory>
-
-  1. npx agentica start <directory>
-  2. npx agentica backend <directory>
-  3. npx agentica client <directory>
-`;
-
-const halt = (desc: string): never => {
-  console.error(desc);
-  process.exit(-1);
-};
-
-const clone = async (type: string, directory: string): Promise<void> => {
-  const execute = (command: string): void => {
-    console.log(`\n$ ${command}`);
-    cp.execSync(command, { stdio: "inherit" });
-  };
-
-  // COPY PROJECTS
-  execute(
-    `git clone https://github.com/wrtnlabs/agentica-template-${type} ${directory}`,
-  );
-  console.log(`cd "${directory}"`);
-  process.chdir(directory);
-
-  // INSTALL DEPENDENCIES
-  execute("npm install");
-
-  // BUILD TYPESCRIPT
-  execute("npm run build");
-
-  // DO TEST
-  execute("npm run test");
-
-  // REMOVE .GIT DIRECTORY
-  cp.execSync("npx rimraf .git");
-  cp.execSync("npx rimraf .github/dependabot.yml");
-};
-
-const main = async (): Promise<void> => {
-  const [_v0, _v1, type, directory] = process.argv;
-  if (
-    ["start", "backend", "client", "standalone"].includes(type) === false ||
-    directory === undefined
-  )
-    halt(USAGE);
-  else if (fs.existsSync(directory) === true)
-    halt("The target directory already exists.");
-  await clone(type, directory);
-};
-main().catch((exp) => {
-  console.log(exp.message);
-  process.exit(-1);
-});
+#!/usr/bin/env node
+import chalk from "chalk";
+import { Command } from "commander";
+
+import { AgenticaStart } from "./executable/AgenticaStart";
+import { IAgenticaStart } from "./structures/IAgenticaStart";
+
+async function main() {
+  const program = new Command();
+
+  program
+    .command("start <directory>")
+    .description("Start a new project")
+    .option(
+      "-p, --project [nodejs|nestjs|react|standalone]",
+      "The project type",
+    )
+    .action(async (directory: string, options: IAgenticaStart.IOptions) => {
+      if ((options.project as any) === true) {
+        console.error(
+          `\n❌ The value of ${chalk.redBright("--project")} is required`,
+        );
+        return;
+      }
+
+      AgenticaStart.execute({ projectName: directory, options });
+    });
+
+  console.log("--------------------------------");
+  console.log(`   🚀 ${"Agentica"} ${chalk.blueBright("Setup Wizard")}`);
+  console.log("--------------------------------");
+
+  program.parse(process.argv);
+}
+
+main().catch((exp) => {
+  console.error(exp.message);
+  process.exit(-1);
+});

package/src/structures/IAgenticaStart.ts

@@ -0,0 +1,35 @@
+import { ProjectOptionValue } from "../utils/types/ProjectOption";
+
+/**
+ * Types about `npx agentica start` command.
+ *
+ * @author Michael
+ */
+export namespace IAgenticaStart {
+  /**
+   * Options for `npx agentica start` command.
+   */
+  export type IOptions = Partial<{
+    project: ProjectOptionValue;
+  }>;
+
+  /**
+   * Parameters for execute `npx agentica start` command.
+   */
+  export interface IExecuteInput {
+    projectName: string;
+    options: IOptions;
+  }
+
+  /**
+   * Input for `getQuestions` function.
+   */
+  export interface IGetQuestionsInput {
+    services: {
+      name: string;
+      value: string;
+    }[];
+
+    options: IOptions;
+  }
+}

package/src/structures/IAgenticaStartOption.ts

@@ -0,0 +1,13 @@
+/**
+ * Types about options for `npx agentica start` command.
+ *
+ * @author Michael
+ */
+export namespace IAgenticaStartOption {
+  export interface IProject {
+    projectName: string;
+    projectPath: string;
+    openAIKey: string;
+    services: string[];
+  }
+}

package/src/utils/capitalize.ts

@@ -0,0 +1,7 @@
+// Convert first letter to uppercase (ex: aws-s3 -> AwsS3)
+export const capitalize = (service: string): string => {
+  return service
+    .split("-")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+};

package/src/utils/createProjectDirectory.ts

@@ -0,0 +1,14 @@
+import fs from "fs";
+import path from "path";
+
+export const createProjectDirectory = (input: {
+  projectPath: string;
+}): void => {
+  if (fs.existsSync(input.projectPath)) {
+    throw new Error(
+      `${path.basename(input.projectPath)} directory already exists.`,
+    );
+  }
+
+  fs.mkdirSync(input.projectPath);
+};

package/src/utils/getNpmPackages.ts

@@ -0,0 +1,45 @@
+import axios from "axios";
+import typia, { tags } from "typia";
+
+export interface INpmPackages {
+  objects: {
+    package: {
+      name: string;
+    };
+  }[];
+  total: number;
+  time: string & tags.Format<"date-time">;
+}
+
+export const getNpmPackages = async (): Promise<
+  { name: string; value: string }[]
+> => {
+  try {
+    const response = await axios.get(
+      "https://registry.npmjs.org/-/v1/search?text=scope:@wrtnlabs&size=10000",
+    );
+    const data = typia.assert<INpmPackages>(response.data);
+
+    return data.objects
+      .map((pkg: any) => pkg.package.name)
+      .filter((name: string) => {
+        // shared is not connector package. This is connector util package.
+        if (name === "@wrtnlabs/connector-shared") {
+          return false;
+        }
+
+        const regex = /^@wrtnlabs\/connector-(?:[a-z0-9-]+)+$/;
+        return regex.test(name);
+      })
+      .map((name: string) => {
+        const serviceName = name.replace("@wrtnlabs/connector-", "");
+        return {
+          name: serviceName.replace("-", " ").toUpperCase(),
+          value: serviceName,
+        };
+      });
+  } catch (error) {
+    console.error("Error occurred while fetching package list:", error);
+    return [];
+  }
+};

package/src/utils/getQuestions.ts

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import { QuestionCollection } from "inquirer";
+
+export interface GetQuestionsInput {
+  services: {
+    name: string;
+    value: string;
+  }[];
+}
+
+export const getQuestions = (
+  input: GetQuestionsInput,
+): QuestionCollection[] => {
+  return [
+    {
+      type: "list",
+      name: "packageManager",
+      message: "Package Manager",
+      choices: [
+        "npm",
+        "pnpm",
+        `yarn (berry ${chalk.blueBright("is not supported")})`,
+      ],
+    },
+    {
+      type: "list",
+      name: "projectType",
+      message: "Project Type",
+      choices: [
+        `NodeJS ${chalk.blueBright("Agent Server")}`,
+        `NestJS ${chalk.blueBright("Agent Server")}`,
+        `React ${chalk.blueBright("Client Application")}`,
+        `Standard ${chalk.blueBright("Application")}`,
+      ],
+    },
+    {
+      type: "checkbox",
+      name: "services",
+      message: "Embedded Controllers",
+      choices: input.services,
+    },
+    {
+      type: "input",
+      name: "openAIKey",
+      message: "Please enter your OPEN_AI_API_KEY:",
+    },
+  ];
+};

package/src/utils/types/PackageManager.ts

@@ -0,0 +1 @@
+export type PackageManager = "npm" | "yarn" | "pnpm";

package/src/utils/types/ProjectOption.ts

@@ -0,0 +1,4 @@
+/**
+ * Value of the `--project` option.
+ */
+export type ProjectOptionValue = "nodejs" | "nestjs" | "react" | "standalone";