@moltium/world-cli 0.1.0

package/README.md

@@ -0,0 +1,205 @@
+# @moltium/world-cli
+
+CLI tool for creating and managing Moltium World SDK projects on the Monad blockchain.
+
+## Installation
+
+```bash
+npm install -g @moltium/world-cli
+```
+
+## Quick Start
+
+```bash
+# Create a new world project
+moltium-world init my-world
+
+# Navigate to project
+cd my-world
+
+# Install dependencies
+npm install
+
+# Deploy smart contracts
+npm run deploy:contracts
+
+# Start your world
+npm run dev
+```
+
+## Commands
+
+### `moltium-world init [name]`
+
+Initialize a new world project with interactive prompts.
+
+**Options:**
+- `-d, --directory <path>` - Output directory
+
+**Example:**
+```bash
+moltium-world init my-awesome-world
+```
+
+### `moltium-world token deploy`
+
+Deploy a custom ERC20 token for your world.
+
+**Options:**
+- `-c, --config <path>` - Token config file (default: `./token.config.json`)
+- `-r, --rpc-url <url>` - RPC URL (overrides .env)
+- `-s, --silent` - No interactive prompts
+
+**Example:**
+```bash
+moltium-world token deploy
+```
+
+### `moltium-world token verify`
+
+Verify your token contract on Sourcify.
+
+**Options:**
+- `-a, --address <address>` - Token contract address
+
+**Example:**
+```bash
+moltium-world token verify --address 0x...
+```
+
+### `moltium-world deploy`
+
+Deploy AgentRegistry and WorldMembership contracts.
+
+**Options:**
+- `-r, --rpc-url <url>` - RPC URL (overrides .env)
+
+**Example:**
+```bash
+moltium-world deploy
+```
+
+### `moltium-world start`
+
+Start the world server.
+
+**Options:**
+- `-p, --port <port>` - Server port (default: 4000)
+- `--dev` - Development mode with auto-reload
+
+**Example:**
+```bash
+moltium-world start --dev
+```
+
+## Token Options
+
+During project initialization, you can choose between two token types:
+
+### Default Token (MON)
+
+Use Monad's native currency for all world transactions.
+
+- ✅ No deployment needed
+- ✅ Instant liquidity
+- ✅ Lower gas costs
+
+### Custom ERC20
+
+Deploy your own world token with custom tokenomics.
+
+- ✅ Branded currency
+- ✅ Custom economics
+- ✅ Full control over supply
+
+## Project Structure
+
+After running `init`, your project will have:
+
+```
+my-world/
+├── src/
+│   └── index.ts          # World entry point
+├── world.config.json     # World configuration
+├── token.config.json     # Token config (if custom)
+├── .env                  # Environment variables
+├── package.json
+└── README.md
+```
+
+## Configuration
+
+### world.config.json
+
+Main configuration file for your world:
+
+```json
+{
+  "name": "MyWorld",
+  "description": "An AI agent world",
+  "type": "generic",
+  "server": {
+    "port": 4000,
+    "host": "localhost"
+  },
+  "admission": {
+    "maxAgents": 100,
+    "entryFee": 0.1
+  },
+  "persistence": {
+    "type": "sqlite"
+  },
+  "blockchain": {
+    "rpcUrl": "https://rpc-testnet.monadinfra.com",
+    "chainId": 10143
+  }
+}
+```
+
+### token.config.json
+
+Token configuration (for custom tokens):
+
+```json
+{
+  "type": "custom",
+  "name": "MyWorld Token",
+  "symbol": "MWT",
+  "decimals": 18,
+  "initialSupply": "1000000",
+  "maxSupply": "10000000",
+  "mintable": true,
+  "burnable": true
+}
+```
+
+### .env
+
+Environment variables:
+
+```bash
+MONAD_RPC_URL=https://rpc-testnet.monadinfra.com
+DEPLOYER_PRIVATE_KEY=0x...
+AGENT_REGISTRY_ADDRESS=
+WORLD_MEMBERSHIP_ADDRESS=
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build CLI
+npm run build
+
+# Run in development mode
+npm run dev
+
+# Test
+npm test
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,805 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import inquirer from "inquirer";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs/promises";
+import path from "path";
+
+// src/lib/config-generator.ts
+function generateWorldConfig(options) {
+  return {
+    name: options.name,
+    description: options.description,
+    type: options.worldType,
+    server: {
+      port: 4e3,
+      host: "localhost"
+    },
+    admission: {
+      maxAgents: 100,
+      entryFee: parseFloat(options.entryFee),
+      requiredSkills: [],
+      requiredTags: []
+    },
+    simulation: {
+      tickIntervalMs: 5e3,
+      autoStart: false
+    },
+    persistence: {
+      type: options.persistenceType,
+      ...options.persistenceType === "sqlite" && {
+        sqlite: {
+          filename: "./data/world.db"
+        }
+      }
+    },
+    blockchain: {
+      rpcUrl: process.env.MONAD_RPC_URL || "https://rpc-testnet.monadinfra.com",
+      chainId: 10143,
+      requireMembership: true,
+      enforceOnChainValidation: false,
+      ...options.tokenType === "custom" && {
+        useCustomToken: true
+      }
+    },
+    logging: {
+      level: "info",
+      format: "json"
+    }
+  };
+}
+function generateTokenConfig(tokenConfig) {
+  return {
+    type: "custom",
+    name: tokenConfig.tokenName,
+    symbol: tokenConfig.tokenSymbol,
+    decimals: 18,
+    initialSupply: tokenConfig.initialSupply,
+    maxSupply: tokenConfig.maxSupply || null,
+    mintable: tokenConfig.mintable !== false,
+    burnable: tokenConfig.burnable !== false,
+    metadata: {
+      description: `Official token for ${tokenConfig.tokenName}`
+    }
+  };
+}
+function generateEnvFile(options) {
+  return `# Monad Network Configuration
+MONAD_RPC_URL=https://rpc-testnet.monadinfra.com
+
+# Deployer Wallet
+# IMPORTANT: Keep this secret! Never commit to version control
+DEPLOYER_PRIVATE_KEY=
+
+# Deployed Contract Addresses (populated after deployment)
+AGENT_REGISTRY_ADDRESS=
+WORLD_MEMBERSHIP_ADDRESS=
+${options.tokenType === "custom" ? "WORLD_TOKEN_ADDRESS=\n" : ""}
+# Optional: Monad Block Explorer API Key
+# MONAD_ETHERSCAN_KEY=
+`;
+}
+
+// src/templates/world-template.ts
+function generateWorldTemplate(config) {
+  const files = {};
+  files["src/index.ts"] = `import { World } from '@moltium/world-core';
+import { loadWorldConfig } from '@moltium/world-core/config';
+import { startWorldServer } from '@moltium/world-core/server';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+async function main() {
+  // Load configuration
+  const config = await loadWorldConfig('./world.config.json');
+  
+  // Create world instance
+  const world = new World(config);
+  
+  // Initialize world (restore state, discover agents)
+  await world.init();
+  
+  // Start HTTP server
+  await startWorldServer(world);
+  
+  console.log(\`\u{1F30D} ${config.name} is running!\`);
+  console.log(\`   Server: http://\${config.server.host}:\${config.server.port}\`);
+  console.log(\`   Agents: \${world.getAgents().length}/\${config.admission.maxAgents}\`);
+  
+  // Graceful shutdown
+  process.on('SIGINT', async () => {
+    console.log('\\n\\n\u{1F6D1} Shutting down...');
+    await world.stop();
+    process.exit(0);
+  });
+}
+
+main().catch((error) => {
+  console.error('Failed to start world:', error);
+  process.exit(1);
+});
+`;
+  if (config.worldType === "game") {
+    files["src/game-logic.ts"] = generateGameLogic();
+  } else if (config.worldType === "marketplace") {
+    files["src/marketplace-logic.ts"] = generateMarketplaceLogic();
+  }
+  return files;
+}
+function generateGameLogic() {
+  return `/**
+ * Game-specific world logic
+ */
+
+export interface GameState {
+  round: number;
+  turn: number;
+  currentPlayer?: string;
+  scores: Record<string, number>;
+}
+
+export function initGameState(): GameState {
+  return {
+    round: 0,
+    turn: 0,
+    scores: {},
+  };
+}
+
+export function processTurn(state: GameState, agentUrl: string, action: any): GameState {
+  // Implement your game logic here
+  return {
+    ...state,
+    turn: state.turn + 1,
+    scores: {
+      ...state.scores,
+      [agentUrl]: (state.scores[agentUrl] || 0) + 1,
+    },
+  };
+}
+`;
+}
+function generateMarketplaceLogic() {
+  return `/**
+ * Marketplace-specific world logic
+ */
+
+export interface MarketplaceListing {
+  id: string;
+  seller: string;
+  item: string;
+  price: number;
+  timestamp: number;
+}
+
+export interface MarketplaceState {
+  listings: MarketplaceListing[];
+  transactions: any[];
+}
+
+export function initMarketplaceState(): MarketplaceState
+
+ {
+  return {
+    listings: [],
+    transactions: [],
+  };
+}
+
+export function createListing(
+  state: MarketplaceState,
+  seller: string,
+  item: string,
+  price: number
+): MarketplaceState {
+  const listing: MarketplaceListing = {
+    id: crypto.randomUUID(),
+    seller,
+    item,
+    price,
+    timestamp: Date.now(),
+  };
+
+  return {
+    ...state,
+    listings: [...state.listings, listing],
+  };
+}
+`;
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Initialize a new world project").argument("[name]", "World name").option("-d, --directory <path>", "Output directory").action(async (name, options) => {
+  console.log(chalk.bold.cyan("\n\u{1F30D} Moltium World SDK - Project Initialization\n"));
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "World name:",
+      default: name || "my-world",
+      validate: (input) => input.length > 0 || "Name is required"
+    },
+    {
+      type: "input",
+      name: "description",
+      message: "Description:",
+      default: "An AI agent world"
+    },
+    {
+      type: "list",
+      name: "worldType",
+      message: "World type:",
+      choices: [
+        { name: "Generic - Open-ended multi-agent environment", value: "generic" },
+        { name: "Game - Turn-based game world", value: "game" },
+        { name: "Marketplace - Agent trading and commerce", value: "marketplace" },
+        { name: "Simulation - Custom simulation environment", value: "simulation" }
+      ],
+      default: "generic"
+    },
+    {
+      type: "list",
+      name: "tokenType",
+      message: "Token type:",
+      choices: [
+        {
+          name: "Default (MON) - Use Monad's native currency",
+          value: "native",
+          short: "MON"
+        },
+        {
+          name: "Custom ERC20 - Deploy your own world token",
+          value: "custom",
+          short: "Custom"
+        }
+      ],
+      default: "native"
+    }
+  ]);
+  let tokenConfig = null;
+  if (answers.tokenType === "custom") {
+    const tokenAnswers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "tokenName",
+        message: "Token name:",
+        default: `${answers.name} Token`
+      },
+      {
+        type: "input",
+        name: "tokenSymbol",
+        message: "Token symbol (3-5 characters):",
+        default: answers.name.substring(0, 3).toUpperCase(),
+        validate: (input) => input.length >= 3 && input.length <= 5 || "Symbol must be 3-5 characters"
+      },
+      {
+        type: "input",
+        name: "initialSupply",
+        message: "Initial supply:",
+        default: "1000000",
+        validate: (input) => !isNaN(Number(input)) || "Must be a number"
+      },
+      {
+        type: "confirm",
+        name: "advancedTokenomics",
+        message: "Configure advanced tokenomics?",
+        default: false
+      }
+    ]);
+    let advancedConfig = {};
+    if (tokenAnswers.advancedTokenomics) {
+      const advanced = await inquirer.prompt([
+        {
+          type: "input",
+          name: "maxSupply",
+          message: "Maximum supply (leave empty for unlimited):",
+          default: ""
+        },
+        {
+          type: "confirm",
+          name: "mintable",
+          message: "Allow minting new tokens?",
+          default: true
+        },
+        {
+          type: "confirm",
+          name: "burnable",
+          message: "Allow burning tokens?",
+          default: true
+        }
+      ]);
+      advancedConfig = advanced;
+    }
+    tokenConfig = { ...tokenAnswers, ...advancedConfig };
+  }
+  const persistenceAnswers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "persistenceType",
+      message: "Persistence backend:",
+      choices: [
+        { name: "SQLite - Zero-config file database (recommended)", value: "sqlite" },
+        { name: "Memory - In-memory only (development)", value: "memory" },
+        { name: "PostgreSQL - Production-grade SQL", value: "postgres" },
+        { name: "Redis - High-speed in-memory", value: "redis" },
+        { name: "MongoDB - Document database", value: "mongo" },
+        { name: "LevelDB - Embedded key-value", value: "leveldb" }
+      ],
+      default: "sqlite"
+    }
+  ]);
+  const entryFeeAnswers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "entryFee",
+      message: answers.tokenType === "native" ? "Entry fee (in MON):" : "Entry fee (in tokens):",
+      default: "0.1",
+      validate: (input) => !isNaN(Number(input)) || "Must be a number"
+    }
+  ]);
+  const spinner = ora("Creating world project...").start();
+  try {
+    const projectDir = options.directory || path.join(process.cwd(), answers.name);
+    await fs.mkdir(projectDir, { recursive: true });
+    await fs.mkdir(path.join(projectDir, "src"), { recursive: true });
+    await fs.mkdir(path.join(projectDir, "scripts"), { recursive: true });
+    const worldConfig = generateWorldConfig({
+      ...answers,
+      ...persistenceAnswers,
+      ...entryFeeAnswers
+    });
+    await fs.writeFile(
+      path.join(projectDir, "world.config.json"),
+      JSON.stringify(worldConfig, null, 2)
+    );
+    if (tokenConfig) {
+      const tokenConfigContent = generateTokenConfig(tokenConfig);
+      await fs.writeFile(
+        path.join(projectDir, "token.config.json"),
+        JSON.stringify(tokenConfigContent, null, 2)
+      );
+    }
+    const envContent = generateEnvFile({ tokenType: answers.tokenType });
+    await fs.writeFile(path.join(projectDir, ".env"), envContent);
+    await fs.writeFile(
+      path.join(projectDir, ".gitignore"),
+      "node_modules\n.env\n.env.local\n*.log\ndata/\n*.db\n.DS_Store\n"
+    );
+    const templateFiles = generateWorldTemplate({
+      name: answers.name,
+      worldType: answers.worldType,
+      tokenType: answers.tokenType
+    });
+    for (const [filename, content] of Object.entries(templateFiles)) {
+      await fs.writeFile(path.join(projectDir, filename), content);
+    }
+    const packageJson = {
+      name: answers.name,
+      version: "0.1.0",
+      description: answers.description,
+      type: "module",
+      scripts: {
+        dev: "tsx src/index.ts",
+        start: "node dist/index.js",
+        build: "tsup",
+        "token:deploy": "moltium-world token deploy",
+        "token:verify": "moltium-world token verify",
+        "deploy:contracts": "moltium-world deploy"
+      },
+      dependencies: {
+        "@moltium/world-core": "^0.1.0",
+        dotenv: "^16.4.0"
+      },
+      devDependencies: {
+        "@types/node": "^22.0.0",
+        tsup: "^8.3.0",
+        tsx: "^4.7.0",
+        typescript: "^5.3.0"
+      }
+    };
+    await fs.writeFile(
+      path.join(projectDir, "package.json"),
+      JSON.stringify(packageJson, null, 2)
+    );
+    const tsConfig = {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        esModuleInterop: true,
+        strict: true,
+        skipLibCheck: true,
+        outDir: "./dist",
+        rootDir: "./src"
+      },
+      include: ["src/**/*"],
+      exclude: ["node_modules", "dist"]
+    };
+    await fs.writeFile(
+      path.join(projectDir, "tsconfig.json"),
+      JSON.stringify(tsConfig, null, 2)
+    );
+    const readme = generateReadme({
+      name: answers.name,
+      description: answers.description,
+      tokenType: answers.tokenType,
+      hasCustomToken: tokenConfig !== null
+    });
+    await fs.writeFile(path.join(projectDir, "README.md"), readme);
+    spinner.succeed(chalk.green("World project created successfully!"));
+    console.log(chalk.bold("\n\u2728 Next steps:\n"));
+    console.log(chalk.gray(`  cd ${answers.name}`));
+    console.log(chalk.gray("  npm install"));
+    if (tokenConfig) {
+      console.log(chalk.gray("  npm run token:deploy     # Deploy your custom token"));
+    }
+    console.log(chalk.gray("  npm run deploy:contracts # Deploy AgentRegistry & WorldMembership"));
+    console.log(chalk.gray("  npm run dev              # Start your world\n"));
+    if (tokenConfig) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Remember to configure DEPLOYER_PRIVATE_KEY in .env before deploying contracts\n"));
+    }
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to create project"));
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+});
+function generateReadme(config) {
+  return `# ${config.name}
+
+${config.description}
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+${config.hasCustomToken ? "# Deploy custom token\nnpm run token:deploy\n" : ""}# Deploy smart contracts
+npm run deploy:contracts
+
+# Start world server
+npm run dev
+\`\`\`
+
+## Configuration
+
+- **World config:** \`world.config.json\`
+${config.hasCustomToken ? "- **Token config:** `token.config.json`\n" : ""}- **Environment:** \`.env\`
+
+## Token Type
+
+${config.tokenType === "native" ? "**Native (MON)** - This world uses Monad's native currency for transactions." : "**Custom ERC20** - This world has its own custom token. Deploy it using `npm run token:deploy`."}
+
+## Commands
+
+- \`npm run dev\` - Start world in development mode
+- \`npm run build\` - Build for production
+- \`npm run start\` - Start production server
+- \`npm run deploy:contracts\` - Deploy smart contracts to Monad
+${config.hasCustomToken ? "- `npm run token:deploy` - Deploy custom token\n- `npm run token:verify` - Verify token contract\n" : ""}
+## Documentation
+
+For more information, visit: https://moltium.world/docs
+`;
+}
+
+// src/commands/token.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+import ora2 from "ora";
+import fs3 from "fs/promises";
+import path3 from "path";
+import { execSync } from "child_process";
+
+// src/lib/config-loader.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+async function loadTokenConfig(configPath = "./token.config.json") {
+  try {
+    const fullPath = path2.resolve(configPath);
+    const content = await fs2.readFile(fullPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to load token config: ${error.message}`);
+  }
+}
+async function loadWorldConfig(configPath = "./world.config.json") {
+  try {
+    const fullPath = path2.resolve(configPath);
+    const content = await fs2.readFile(fullPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to load world config: ${error.message}`);
+  }
+}
+
+// src/lib/blockchain.ts
+import { ethers } from "ethers";
+async function checkWalletBalance(privateKey, rpcUrl) {
+  try {
+    const provider = new ethers.JsonRpcProvider(rpcUrl);
+    const wallet = new ethers.Wallet(privateKey, provider);
+    const balance = await provider.getBalance(wallet.address);
+    return parseFloat(ethers.formatEther(balance));
+  } catch (error) {
+    throw new Error(`Failed to check wallet balance: ${error.message}`);
+  }
+}
+async function estimateGas(contractType) {
+  const estimates = {
+    token: 3e-3,
+    // ~3M gas
+    world: 0.31
+    // ~3M gas for both contracts
+  };
+  return estimates[contractType];
+}
+
+// src/commands/token.ts
+var tokenCommand = new Command2("token").description("Manage world token deployment and operations");
+tokenCommand.command("deploy").description("Deploy custom ERC20 token").option("-c, --config <path>", "Token config file", "./token.config.json").option("-r, --rpc-url <url>", "RPC URL (overrides .env)").option("-s, --silent", "No interactive prompts").action(async (options) => {
+  console.log(chalk2.bold.cyan("\n\u{1FA99} Deploying Custom Token\n"));
+  try {
+    const spinner = ora2("Loading configuration...").start();
+    const tokenConfig = await loadTokenConfig(options.config);
+    spinner.text = "Checking environment...";
+    const privateKey = process.env.DEPLOYER_PRIVATE_KEY;
+    if (!privateKey) {
+      spinner.fail();
+      console.error(chalk2.red("\u274C DEPLOYER_PRIVATE_KEY not found in .env file"));
+      console.log(chalk2.yellow("\\nPlease add your private key to .env:"));
+      console.log(chalk2.gray("DEPLOYER_PRIVATE_KEY=0x...\\n"));
+      process.exit(1);
+    }
+    const rpcUrl = options.rpcUrl || process.env.MONAD_RPC_URL || "https://rpc-testnet.monadinfra.com";
+    spinner.text = "Checking wallet balance...";
+    const balance = await checkWalletBalance(privateKey, rpcUrl);
+    spinner.text = "Estimating gas costs...";
+    const gasEstimate = await estimateGas("token");
+    spinner.succeed();
+    console.log(chalk2.bold("\\n\u{1F4CB} Deployment Details\\n"));
+    console.log(`  ${chalk2.gray("Token Name:")} ${tokenConfig.name}`);
+    console.log(`  ${chalk2.gray("Symbol:")} ${tokenConfig.symbol}`);
+    console.log(`  ${chalk2.gray("Initial Supply:")} ${tokenConfig.initialSupply.toLocaleString()}`);
+    if (tokenConfig.maxSupply) {
+      console.log(`  ${chalk2.gray("Max Supply:")} ${tokenConfig.maxSupply.toLocaleString()}`);
+    }
+    console.log(`\\n  ${chalk2.gray("RPC URL:")} ${rpcUrl}`);
+    console.log(`  ${chalk2.gray("Wallet Balance:")} ${balance} MON`);
+    console.log(`  ${chalk2.gray("Estimated Gas:")} ~${gasEstimate} MON\\n`);
+    if (balance < gasEstimate) {
+      console.error(chalk2.red("\u274C Insufficient balance for deployment"));
+      console.log(chalk2.yellow(`\\n  Need at least ${gasEstimate} MON, but have ${balance} MON\\n`));
+      process.exit(1);
+    }
+    const deploySpinner = ora2("Deploying token contract...").start();
+    try {
+      const env = {
+        ...process.env,
+        MONAD_RPC_URL: rpcUrl,
+        DEPLOYER_PRIVATE_KEY: privateKey,
+        TOKEN_NAME: tokenConfig.name,
+        TOKEN_SYMBOL: tokenConfig.symbol,
+        TOKEN_INITIAL_SUPPLY: tokenConfig.initialSupply.toString(),
+        TOKEN_MAX_SUPPLY: tokenConfig.maxSupply?.toString() || "0",
+        TOKEN_DECIMALS: tokenConfig.decimals?.toString() || "18"
+      };
+      const worldCorePath = path3.join(process.cwd(), "../world-core");
+      const command = `forge script script/DeployToken.s.sol:DeployTokenScript --rpc-url monad --broadcast -vvv`;
+      const output = execSync(command, {
+        cwd: worldCorePath,
+        env,
+        encoding: "utf-8"
+      });
+      const addressMatch = output.match(/Token deployed: (0x[a-fA-F0-9]{40})/);
+      const txMatch = output.match(/Transaction: (0x[a-fA-F0-9]{64})/);
+      if (!addressMatch) {
+        throw new Error("Could not parse deployed contract address");
+      }
+      const tokenAddress = addressMatch[1];
+      const txHash = txMatch?.[1];
+      deploySpinner.succeed(chalk2.green("Token deployed successfully!"));
+      console.log(chalk2.bold("\\n\u2705 Deployment Complete\\n"));
+      console.log(`  ${chalk2.gray("Contract:")} ${chalk2.green(tokenAddress)}`);
+      if (txHash) {
+        console.log(`  ${chalk2.gray("Transaction:")} ${txHash}`);
+      }
+      const updateSpinner = ora2("Updating world.config.json...").start();
+      try {
+        const worldConfigPath = path3.join(process.cwd(), "world.config.json");
+        const worldConfig = await loadWorldConfig(worldConfigPath);
+        worldConfig.blockchain = worldConfig.blockchain || {};
+        worldConfig.blockchain.worldTokenAddress = tokenAddress;
+        await fs3.writeFile(
+          worldConfigPath,
+          JSON.stringify(worldConfig, null, 2)
+        );
+        updateSpinner.succeed(chalk2.green("Configuration updated"));
+      } catch (error) {
+        updateSpinner.warn(chalk2.yellow("Could not update world.config.json"));
+      }
+      console.log(chalk2.bold("\\n\u{1F4DD} Next Steps:\\n"));
+      console.log(chalk2.gray("  1. Verify contract: npm run token:verify"));
+      console.log(chalk2.gray("  2. Start world: npm run dev\\n"));
+    } catch (error) {
+      deploySpinner.fail(chalk2.red("Deployment failed"));
+      console.error(chalk2.red("\\nError:"), error.message);
+      if (error.message.includes("insufficient funds")) {
+        console.log(chalk2.yellow("\\n\u2139\uFE0F  You need more MON for gas fees\\n"));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk2.red("Error:"), error.message);
+    process.exit(1);
+  }
+});
+tokenCommand.command("verify").description("Verify token contract on Sourcify").option("-a, --address <address>", "Token contract address").action(async (options) => {
+  console.log(chalk2.bold.cyan("\\n\u{1F50D} Verifying Token Contract\\n"));
+  try {
+    let tokenAddress = options.address;
+    if (!tokenAddress) {
+      const spinner2 = ora2("Loading configuration...").start();
+      const worldConfig = await loadWorldConfig();
+      tokenAddress = worldConfig.blockchain?.worldTokenAddress;
+      spinner2.stop();
+      if (!tokenAddress) {
+        console.error(chalk2.red("\u274C No token address found"));
+        console.log(chalk2.yellow("\\nProvide address with --address or deploy token first\\n"));
+        process.exit(1);
+      }
+    }
+    console.log(`  ${chalk2.gray("Contract:")} ${tokenAddress}\\n`);
+    const spinner = ora2("Verifying on Sourcify...").start();
+    try {
+      const worldCorePath = path3.join(process.cwd(), "../world-core");
+      const command = `MONAD_ETHERSCAN_KEY="" forge verify-contract ${tokenAddress} contracts/WorldToken.sol:WorldToken --chain 10143 --verifier sourcify --verifier-url https://sourcify-api-monad.blockvision.org/`;
+      execSync(command, {
+        cwd: worldCorePath,
+        stdio: "pipe"
+      });
+      spinner.succeed(chalk2.green("Contract verified successfully!"));
+      console.log(chalk2.gray("\\n  Contract is now publicly verified on Sourcify\\n"));
+    } catch (error) {
+      spinner.fail(chalk2.red("Verification failed"));
+      console.error(chalk2.red("\\nError:"), error.message);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk2.red("Error:"), error.message);
+    process.exit(1);
+  }
+});
+tokenCommand.command("mint").description("Mint additional tokens").argument("<amount>", "Amount to mint").option("--to <address>", "Recipient address (defaults to deployer)").action(async (amount, options) => {
+  console.log(chalk2.bold.cyan("\\n\u{1FA99} Minting Tokens\\n"));
+  console.log(chalk2.yellow("\u26A0\uFE0F  Token minting not yet implemented"));
+  console.log(chalk2.gray("\\n  You can mint tokens by calling the contract directly\\n"));
+});
+
+// src/commands/start.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { execSync as execSync2 } from "child_process";
+var startCommand = new Command3("start").description("Start the world server").option("-p, --port <port>", "Server port", "4000").option("--dev", "Development mode with auto-reload").action(async (options) => {
+  console.log(chalk3.bold.cyan("\\n\u{1F30D} Starting World Server\\n"));
+  try {
+    const command = options.dev ? "npm run dev" : "npm start";
+    const spinner = ora3("Starting server...").start();
+    spinner.stop();
+    console.log(chalk3.gray(`  Running: ${command}\\n`));
+    execSync2(command, {
+      cwd: process.cwd(),
+      stdio: "inherit"
+    });
+  } catch (error) {
+    console.error(chalk3.red("\\nError starting server:"), error.message);
+    process.exit(1);
+  }
+});
+
+// src/commands/deploy.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+import ora4 from "ora";
+import { execSync as execSync3 } from "child_process";
+import path4 from "path";
+var deployCommand = new Command4("deploy").description("Deploy smart contracts to Monad").option("-r, --rpc-url <url>", "RPC URL (overrides .env)").action(async (options) => {
+  console.log(chalk4.bold.cyan("\\n\u{1F680} Deploying Smart Contracts\\n"));
+  try {
+    const spinner = ora4("Checking environment...").start();
+    const privateKey = process.env.DEPLOYER_PRIVATE_KEY;
+    if (!privateKey) {
+      spinner.fail();
+      console.error(chalk4.red("\u274C DEPLOYER_PRIVATE_KEY not found in .env file"));
+      console.log(chalk4.yellow("\\nPlease add your private key to .env:"));
+      console.log(chalk4.gray("DEPLOYER_PRIVATE_KEY=0x...\\n"));
+      process.exit(1);
+    }
+    const rpcUrl = options.rpcUrl || process.env.MONAD_RPC_URL || "https://rpc-testnet.monadinfra.com";
+    spinner.text = "Loading configuration...";
+    const worldConfig = await loadWorldConfig();
+    spinner.succeed();
+    console.log(chalk4.bold("\u{1F4CB} Deployment Details\\n"));
+    console.log(`  ${chalk4.gray("World Name:")} ${worldConfig.name}`);
+    console.log(`  ${chalk4.gray("Entry Fee:")} ${worldConfig.admission?.entryFee || 0} MON`);
+    console.log(`  ${chalk4.gray("RPC URL:")} ${rpcUrl}\\n`);
+    const deploySpinner = ora4("Deploying AgentRegistry...").start();
+    try {
+      const worldCorePath = path4.join(process.cwd(), "../world-core");
+      const env = {
+        ...process.env,
+        MONAD_RPC_URL: rpcUrl,
+        DEPLOYER_PRIVATE_KEY: privateKey,
+        WORLD_NAME: worldConfig.name,
+        ENTRY_FEE_MON: (worldConfig.admission?.entryFee || 0).toString()
+      };
+      const command = `forge script script/Deploy.s.sol:DeployScript --rpc-url monad --broadcast -vvv`;
+      const output = execSync3(command, {
+        cwd: worldCorePath,
+        env,
+        encoding: "utf-8"
+      });
+      const agentRegistryMatch = output.match(/AgentRegistry deployed to: (0x[a-fA-F0-9]{40})/);
+      const membershipMatch = output.match(/WorldMembership deployed to: (0x[a-fA-F0-9]{40})/);
+      if (!agentRegistryMatch || !membershipMatch) {
+        throw new Error("Could not parse deployed contract addresses");
+      }
+      const agentRegistryAddress = agentRegistryMatch[1];
+      const membershipAddress = membershipMatch[1];
+      deploySpinner.succeed(chalk4.green("Contracts deployed successfully!"));
+      console.log(chalk4.bold("\\n\u2705 Deployment Complete\\n"));
+      console.log(`  ${chalk4.gray("AgentRegistry:")} ${chalk4.green(agentRegistryAddress)}`);
+      console.log(`  ${chalk4.gray("WorldMembership:")} ${chalk4.green(membershipAddress)}`);
+      const updateSpinner = ora4("\\nUpdating world.config.json...").start();
+      const fs4 = await import("fs/promises");
+      worldConfig.blockchain = worldConfig.blockchain || {};
+      worldConfig.blockchain.agentRegistryAddress = agentRegistryAddress;
+      worldConfig.blockchain.membershipContractAddress = membershipAddress;
+      await fs4.writeFile(
+        path4.join(process.cwd(), "world.config.json"),
+        JSON.stringify(worldConfig, null, 2)
+      );
+      updateSpinner.succeed(chalk4.green("Configuration updated"));
+      console.log(chalk4.bold("\\n\u{1F4DD} Next Steps:\\n"));
+      console.log(chalk4.gray("  1. Add contract addresses to .env:"));
+      console.log(chalk4.gray(`     AGENT_REGISTRY_ADDRESS=${agentRegistryAddress}`));
+      console.log(chalk4.gray(`     WORLD_MEMBERSHIP_ADDRESS=${membershipAddress}`));
+      console.log(chalk4.gray("  2. Start world: npm run dev\\n"));
+    } catch (error) {
+      deploySpinner.fail(chalk4.red("Deployment failed"));
+      console.error(chalk4.red("\\nError:"), error.message);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk4.red("Error:"), error.message);
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command5();
+program.name("moltium-world").description("CLI tool for creating and managing Moltium World SDK projects").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(tokenCommand);
+program.addCommand(startCommand);
+program.addCommand(deployCommand);
+program.exitOverride();
+try {
+  await program.parseAsync(process.argv);
+} catch (error) {
+  if (error.code !== "commander.help" && error.code !== "commander.version") {
+    console.error(chalk5.red("Error:"), error.message);
+    process.exit(1);
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "@moltium/world-cli",
+    "version": "0.1.0",
+    "description": "CLI tool for creating and managing Moltium World SDK projects",
+    "license": "MIT",
+    "keywords": [
+        "ai",
+        "agent",
+        "world",
+        "simulation",
+        "cli",
+        "moltium",
+        "monad",
+        "blockchain"
+    ],
+    "type": "module",
+    "bin": {
+        "moltium-world": "dist/index.js"
+    },
+    "main": "./dist/index.js",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch",
+        "test": "vitest run --passWithNoTests",
+        "test:watch": "vitest",
+        "clean": "rm -rf dist"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "@moltium/world-core": "^0.1.0",
+        "chalk": "^5.3.0",
+        "commander": "^12.1.0",
+        "dotenv": "^16.4.0",
+        "ethers": "^6.13.0",
+        "inquirer": "^12.2.0",
+        "ora": "^8.1.0",
+        "zod": "^3.24.0"
+    },
+    "devDependencies": {
+        "@types/inquirer": "^9.0.0",
+        "@types/node": "^22.0.0",
+        "tsup": "^8.3.0",
+        "typescript": "^5.3.0",
+        "vitest": "^2.1.0"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}