create-eliza/cli/chunk-BRTSLL5H.js

Initialize an Eliza project

import { createRequire } from 'module';
const require = createRequire(import.meta.url);

import {
  AgentRuntime,
  logger,
  v4_default
} from "./chunk-4OHLWYX4.js";

// src/project.ts
import { resolve } from "node:path";
import * as fs from "node:fs";
async function loadProject(path) {
  try {
    const projectPath = resolve(path);
    logger.info(`Loading project from ${projectPath}`);
    let projectConfig;
    const packageJsonPath = resolve(projectPath, "package.json");
    if (fs.existsSync(packageJsonPath)) {
      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
      const isProject = packageJson.eliza?.type === "project" || packageJson.description?.toLowerCase().includes("project");
      if (isProject) {
        const srcIndexPaths = [
          resolve(projectPath, "src", "index.ts"),
          resolve(projectPath, "src", "index.js"),
          resolve(projectPath, "dist", "index.js")
        ];
        for (const indexPath of srcIndexPaths) {
          if (fs.existsSync(indexPath)) {
            try {
              logger.info(`Trying to load project from ${indexPath}`);
              const importedModule = await import(`file://${indexPath}`);
              if (importedModule.default?.agents || importedModule.project?.agents) {
                projectConfig = importedModule.default || importedModule.project;
                logger.info(`Successfully loaded project with ${projectConfig.agents.length} agents`);
                break;
              }
            } catch (importError) {
              logger.warn(`Error importing ${indexPath}: ${importError}`);
            }
          }
        }
        if (!projectConfig && packageJson.main) {
          const mainPath = resolve(projectPath, packageJson.main);
          if (fs.existsSync(mainPath)) {
            try {
              const importedModule = await import(`file://${mainPath}`);
              if (importedModule.default?.agents || importedModule.project?.agents) {
                projectConfig = importedModule.default || importedModule.project;
              }
            } catch (importError) {
              logger.warn(`Error importing main entry: ${importError}`);
            }
          }
        }
      }
    }
    if (!projectConfig) {
      const projectFiles = ["project.json", "eliza.json", "agents.json"];
      for (const file of projectFiles) {
        const filePath = resolve(projectPath, file);
        if (fs.existsSync(filePath)) {
          try {
            const fileContent = fs.readFileSync(filePath, "utf-8");
            const projectData = JSON.parse(fileContent);
            if (projectData.agents) {
              projectConfig = projectData;
              break;
            }
          } catch (error) {
            logger.warn(`Error reading possible project file ${file}: ${error}`);
          }
        }
      }
    }
    if (!projectConfig) {
      logger.warn("No project configuration found, using default test configuration");
      projectConfig = {
        agents: [{
          character: {
            name: "Test Agent",
            bio: ["A test agent for running automated tests"],
            templates: {},
            settings: {},
            system: "You are a test agent for running automated tests.",
            messageExamples: []
          }
        }]
      };
    }
    const agents = projectConfig.agents;
    if (!agents || agents.length === 0) {
      logger.error("No agents defined in project configuration");
      throw new Error("No agents defined in project configuration");
    }
    logger.info(`Found ${agents.length} agents in project`);
    const runtimes = [];
    for (const agent of agents) {
      logger.info(`Creating runtime for agent: ${agent.character.name}`);
      const runtime = new AgentRuntime({
        agentId: v4_default(),
        character: agent.character,
        plugins: agent.plugins || []
      });
      if (agent.init) {
        await agent.init(runtime);
      }
      runtimes.push(runtime);
    }
    return {
      runtimes,
      path: projectPath,
      agents
    };
  } catch (error) {
    logger.error("Failed to load project:", error);
    throw error;
  }
}

export {
  loadProject
};
//# sourceMappingURL=chunk-BRTSLL5H.js.map