@conquest-eth/tools 0.0.0

package/dist/types.js

@@ -0,0 +1,34 @@
+// Helper function to create a tool with automatic type inference
+export function createTool(config) {
+    return config;
+}
+// Convert ToolResult to CallToolResult format
+export function convertToCallToolResult(result) {
+    // Import stringifyWithBigInt to handle BigInt serialization
+    const stringifyWithBigInt = (obj, space) => {
+        return JSON.stringify(obj, (_key, value) => (typeof value === 'bigint' ? value.toString() : value), space);
+    };
+    if (result.success === false) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: stringifyWithBigInt({
+                        error: result.error,
+                        ...(result.stack ? { stack: result.stack } : {}),
+                    }),
+                },
+            ],
+            isError: true,
+        };
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: stringifyWithBigInt(result.result, 2),
+            },
+        ],
+    };
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAsIA,iEAAiE;AACjE,MAAM,UAAU,UAAU,CAA6B,MAItD;IACA,OAAO,MAAM,CAAC;AACf,CAAC;AAED,8CAA8C;AAC9C,MAAM,UAAU,uBAAuB,CAAC,MAAkB;IACzD,4DAA4D;IAC5D,MAAM,mBAAmB,GAAG,CAAC,GAAQ,EAAE,KAAc,EAAU,EAAE;QAChE,OAAO,IAAI,CAAC,SAAS,CACpB,GAAG,EACH,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EACvE,KAAK,CACL,CAAC;IACH,CAAC,CAAC;IAEF,IAAI,MAAM,CAAC,OAAO,KAAK,KAAK,EAAE,CAAC;QAC9B,OAAO;YACN,OAAO,EAAE;gBACR;oBACC,IAAI,EAAE,MAAe;oBACrB,IAAI,EAAE,mBAAmB,CAAC;wBACzB,KAAK,EAAE,MAAM,CAAC,KAAK;wBACnB,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAC,KAAK,EAAE,MAAM,CAAC,KAAK,EAAC,CAAC,CAAC,CAAC,EAAE,CAAC;qBAC9C,CAAC;iBACF;aACD;YACD,OAAO,EAAE,IAAI;SACb,CAAC;IACH,CAAC;IAED,OAAO;QACN,OAAO,EAAE;YACR;gBACC,IAAI,EAAE,MAAe;gBACrB,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;aAC3C;SACD;KACD,CAAC;AACH,CAAC"}

package/dist/util/hashing.d.ts

@@ -0,0 +1,33 @@
+import type { Address } from 'viem';
+/**
+ * Compute the toHash used in fleet commit phase
+ * This hashes the destination planet and secret together
+ *
+ * @param toPlanetId - The destination planet location ID
+ * @param secret - The secret value to commit to
+ * @returns The hash commitment (keccak256 hash)
+ */
+export declare function computeToHash(toPlanetId: bigint, secret: `0x${string}`, options: {
+    gift: boolean;
+    specific: Address;
+    arrivalTimeWanted: bigint;
+}): `0x${string}`;
+/**
+ * Compute the fleet ID from send transaction parameters
+ * The fleet ID is computed from: toHash, from, fleetSender, operator
+ * This matches what the contract emits in the FleetSent event
+ *
+ * @param toHash - The hash commitment to destination and secret
+ * @param fromPlanetId - The source planet location ID
+ * @param fleetSender - The address that owns the fleet
+ * @param operator - The address that committed the transaction
+ * @returns The fleet ID (keccak256 hash)
+ */
+export declare function computeFleetId(toHash: `0x${string}`, fromPlanetId: bigint, fleetSender: Address, operator: Address): `0x${string}`;
+/**
+ * Generate a random secret for fleet commitment
+ *
+ * @returns A cryptographically random 32-byte hex string
+ */
+export declare function generateSecret(): `0x${string}`;
+//# sourceMappingURL=hashing.d.ts.map

package/dist/util/hashing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashing.d.ts","sourceRoot":"","sources":["../../src/util/hashing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAGlC;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,KAAK,MAAM,EAAE,EACrB,OAAO,EAAE;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAC,GACpE,KAAK,MAAM,EAAE,CAQf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,KAAK,MAAM,EAAE,EACrB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,OAAO,EACpB,QAAQ,EAAE,OAAO,GACf,KAAK,MAAM,EAAE,CAOf;AAED;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,KAAK,MAAM,EAAE,CAI9C"}

package/dist/util/hashing.js

@@ -0,0 +1,38 @@
+import { encodePacked, keccak256 } from 'viem';
+/**
+ * Compute the toHash used in fleet commit phase
+ * This hashes the destination planet and secret together
+ *
+ * @param toPlanetId - The destination planet location ID
+ * @param secret - The secret value to commit to
+ * @returns The hash commitment (keccak256 hash)
+ */
+export function computeToHash(toPlanetId, secret, options) {
+    const toHash = keccak256(encodePacked(['bytes32', 'uint256', 'bool', 'address', 'uint256'], [secret, toPlanetId, options.gift, options.specific, options.arrivalTimeWanted]));
+    return toHash;
+}
+/**
+ * Compute the fleet ID from send transaction parameters
+ * The fleet ID is computed from: toHash, from, fleetSender, operator
+ * This matches what the contract emits in the FleetSent event
+ *
+ * @param toHash - The hash commitment to destination and secret
+ * @param fromPlanetId - The source planet location ID
+ * @param fleetSender - The address that owns the fleet
+ * @param operator - The address that committed the transaction
+ * @returns The fleet ID (keccak256 hash)
+ */
+export function computeFleetId(toHash, fromPlanetId, fleetSender, operator) {
+    return keccak256(encodePacked(['bytes32', 'uint256', 'address', 'address'], [toHash, BigInt(fromPlanetId), fleetSender, operator]));
+}
+/**
+ * Generate a random secret for fleet commitment
+ *
+ * @returns A cryptographically random 32-byte hex string
+ */
+export function generateSecret() {
+    const randomBytes = new Uint8Array(32);
+    crypto.getRandomValues(randomBytes);
+    return `0x${Buffer.from(randomBytes).toString('hex')}`;
+}
+//# sourceMappingURL=hashing.js.map

package/dist/util/hashing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashing.js","sourceRoot":"","sources":["../../src/util/hashing.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,YAAY,EAAE,SAAS,EAAc,MAAM,MAAM,CAAC;AAE/E;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAC5B,UAAkB,EAClB,MAAqB,EACrB,OAAsE;IAEtE,MAAM,MAAM,GAAG,SAAS,CACvB,YAAY,CACX,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,EACpD,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAC/E,CACD,CAAC;IACF,OAAO,MAAM,CAAC;AACf,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAC7B,MAAqB,EACrB,YAAoB,EACpB,WAAoB,EACpB,QAAiB;IAEjB,OAAO,SAAS,CACf,YAAY,CACX,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,EAC5C,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,EAAE,WAAW,EAAE,QAAQ,CAAC,CACrD,CACD,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc;IAC7B,MAAM,WAAW,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;IACpC,OAAO,KAAK,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AACxD,CAAC"}

package/dist/util/time.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Get current timestamp in seconds
+ */
+export declare function getCurrentTimestamp(): number;
+/**
+ * Calculate estimated arrival time based on distance and timePerDistance
+ *
+ * @param distance - The distance between planets
+ * @param timePerDistance - Time multiplier from contract config (seconds per distance unit)
+ * @param genesis - Genesis timestamp from contract config
+ * @returns Estimated arrival time in seconds
+ */
+export declare function calculateEstimatedArrivalTime(params: {
+    startTime: bigint;
+    distance: bigint;
+    timePerDistance: bigint;
+}): number;
+/**
+ * Calculate when the resolve window opens
+ * A fleet can be resolved after it arrives and the resolve window has passed
+ *
+ * @param estimatedArrivalTime - When the fleet is estimated to arrive
+ * @param resolveWindow - The resolve window duration in seconds from contract config
+ * @returns The timestamp when the fleet can be resolved
+ */
+export declare function calculateResolveWindowOpen(estimatedArrivalTime: number, resolveWindow: bigint): number;
+/**
+ * Check if a fleet can be resolved now
+ *
+ * @param estimatedArrivalTime - When the fleet was estimated to arrive
+ * @param resolveWindow - The resolve window duration in seconds
+ * @returns True if the fleet can be resolved now
+ */
+export declare function canResolveNow(estimatedArrivalTime: number, resolveWindow: bigint): boolean;
+/**
+ * Format timestamp as ISO string
+ */
+export declare function formatTimestamp(timestamp: number): string;
+/**
+ * Parse ISO string to timestamp
+ */
+export declare function parseTimestamp(isoString: string): number;
+//# sourceMappingURL=time.d.ts.map

package/dist/util/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/util/time.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE;IACrD,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;CACxB,GAAG,MAAM,CAIT;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACzC,oBAAoB,EAAE,MAAM,EAC5B,aAAa,EAAE,MAAM,GACnB,MAAM,CAER;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,oBAAoB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAI1F;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/dist/util/time.js

@@ -0,0 +1,55 @@
+/**
+ * Get current timestamp in seconds
+ */
+export function getCurrentTimestamp() {
+    return Math.floor(Date.now() / 1000);
+}
+/**
+ * Calculate estimated arrival time based on distance and timePerDistance
+ *
+ * @param distance - The distance between planets
+ * @param timePerDistance - Time multiplier from contract config (seconds per distance unit)
+ * @param genesis - Genesis timestamp from contract config
+ * @returns Estimated arrival time in seconds
+ */
+export function calculateEstimatedArrivalTime(params) {
+    const { startTime, distance, timePerDistance } = params;
+    const travelTime = Number(distance) * Number(timePerDistance);
+    return Number(startTime) + travelTime;
+}
+/**
+ * Calculate when the resolve window opens
+ * A fleet can be resolved after it arrives and the resolve window has passed
+ *
+ * @param estimatedArrivalTime - When the fleet is estimated to arrive
+ * @param resolveWindow - The resolve window duration in seconds from contract config
+ * @returns The timestamp when the fleet can be resolved
+ */
+export function calculateResolveWindowOpen(estimatedArrivalTime, resolveWindow) {
+    return estimatedArrivalTime + Number(resolveWindow);
+}
+/**
+ * Check if a fleet can be resolved now
+ *
+ * @param estimatedArrivalTime - When the fleet was estimated to arrive
+ * @param resolveWindow - The resolve window duration in seconds
+ * @returns True if the fleet can be resolved now
+ */
+export function canResolveNow(estimatedArrivalTime, resolveWindow) {
+    const currentTime = getCurrentTimestamp();
+    const resolveWindowOpen = calculateResolveWindowOpen(estimatedArrivalTime, resolveWindow);
+    return currentTime >= resolveWindowOpen;
+}
+/**
+ * Format timestamp as ISO string
+ */
+export function formatTimestamp(timestamp) {
+    return new Date(timestamp * 1000).toISOString();
+}
+/**
+ * Parse ISO string to timestamp
+ */
+export function parseTimestamp(isoString) {
+    return Math.floor(new Date(isoString).getTime() / 1000);
+}
+//# sourceMappingURL=time.js.map

package/dist/util/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","sourceRoot":"","sources":["../../src/util/time.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,UAAU,mBAAmB;IAClC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,6BAA6B,CAAC,MAI7C;IACA,MAAM,EAAC,SAAS,EAAE,QAAQ,EAAE,eAAe,EAAC,GAAG,MAAM,CAAC;IACtD,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;IAC9D,OAAO,MAAM,CAAC,SAAS,CAAC,GAAG,UAAU,CAAC;AACvC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,0BAA0B,CACzC,oBAA4B,EAC5B,aAAqB;IAErB,OAAO,oBAAoB,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,oBAA4B,EAAE,aAAqB;IAChF,MAAM,WAAW,GAAG,mBAAmB,EAAE,CAAC;IAC1C,MAAM,iBAAiB,GAAG,0BAA0B,CAAC,oBAAoB,EAAE,aAAa,CAAC,CAAC;IAC1F,OAAO,WAAW,IAAI,iBAAiB,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,SAAiB;IAChD,OAAO,IAAI,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;AACjD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,SAAiB;IAC/C,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,CAAC;AACzD,CAAC"}

package/package.json

@@ -0,0 +1,78 @@
+{
+	"name": "@conquest-eth/tools",
+	"version": "0.0.0",
+	"description": "Tools for Conquest.eth, including mcp server",
+	"author": "Ronan Sandford",
+	"license": "MIT",
+	"keywords": [
+		"mcp",
+		"ethereum",
+		"tools",
+		"cli",
+		"conquest.eth"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/wighawag/tools-conquest-eth-v0.git"
+	},
+	"homepage": "https://github.com/wighawag/tools-conquest-eth-v0#readme",
+	"bugs": {
+		"url": "https://github.com/wighawag/tools-conquest-eth-v0/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"bin": {
+		"conquest": "dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"sideEffects": false,
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.25.3",
+		"commander": "^14.0.3",
+		"conquest-eth-v0-contracts": "workspace:*",
+		"eip-1193": "^0.6.5",
+		"ldenv": "^0.3.16",
+		"remote-procedure-call": "^0.1.1",
+		"tools-ethereum": "^0.0.1",
+		"viem": "^2.45.1",
+		"zod": "^4.3.6"
+	},
+	"devDependencies": {
+		"@changesets/cli": "^2.29.8",
+		"@modelcontextprotocol/inspector": "^0.19.0",
+		"@types/node": "^25.2.0",
+		"as-soon": "^0.1.5",
+		"prettier": "^3.8.0",
+		"reloaderoo": "^1.1.5",
+		"tsx": "^4.21.0",
+		"typescript": "^5.3.3",
+		"vitest": "^4.0.18"
+	},
+	"scripts": {
+		"prepublishOnly": "pnpm format:check && pnpm build",
+		"release": "pnpm prepublishOnly && git push --all && pnpm changeset publish && git push --tags",
+		"format": "prettier --write .",
+		"format:check": "prettier --check .",
+		"build": "tsc",
+		"dev": "as-soon -w src pnpm build",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"mcp:inspector": "mcp-inspector",
+		"reloaderoo": "reloaderoo",
+		"start": "reloaderoo proxy --log-level debug -- node ./dist/cli.js --rpc-url http://localhost:8545 --game-contract 0x322813fd9a801c5507c9de605d63cea4f2ce6c44 mcp --ethereum"
+	}
+}

package/src/cli-tool-generator.ts

@@ -0,0 +1,287 @@
+import {Command} from 'commander';
+import {z} from 'zod';
+import type {Tool, ToolEnvironment, StorageConfig} from './types.js';
+import {getClients} from 'tools-ethereum/helpers';
+import {getChain} from 'tools-ethereum/helpers';
+import {createSpaceInfo} from './contracts/space-info.js';
+import {JsonFleetStorage} from './storage/json-storage.js';
+import {FleetManager} from './fleet/manager.js';
+import {PlanetManager} from './planet/manager.js';
+import type {ClientsWithOptionalWallet, ContractConfig, GameContract} from './types.js';
+import {SpaceInfo} from 'conquest-eth-v0-contracts';
+import {Abi_IOuterSpace} from 'conquest-eth-v0-contracts/abis/IOuterSpace.js';
+
+/**
+ * CLI configuration parameters
+ */
+export interface CliConfig {
+	chain: any;
+	privateKey?: `0x${string}`;
+	gameContract: `0x${string}`;
+	ethereum?: boolean;
+	storageConfig: StorageConfig;
+}
+
+/**
+ * Convert Zod schema field to commander.js option definition
+ */
+function zodFieldToOption(name: string, field: z.ZodTypeAny): string {
+	if (field instanceof z.ZodBoolean) {
+		return `--${name}`;
+	}
+	return `--${name} <value>`;
+}
+
+/**
+ * Parse option value based on Zod type
+ */
+function parseOptionValue(field: z.ZodTypeAny, value: any): any {
+	if (field instanceof z.ZodArray) {
+		return typeof value === 'string' ? value.split(',').map((v) => v.trim()) : value;
+	}
+	if (field instanceof z.ZodNumber) {
+		return Number(value);
+	}
+	if (field instanceof z.ZodBoolean) {
+		return value === true || value === 'true';
+	}
+	return value;
+}
+
+/**
+ * Extract description from Zod schema field
+ */
+function getFieldDescription(field: z.ZodTypeAny): string {
+	return (field as any).description || 'No description available';
+}
+
+/**
+ * Check if a Zod field is optional
+ */
+function isOptionalField(field: z.ZodTypeAny): boolean {
+	return field instanceof z.ZodOptional || field.isOptional?.();
+}
+
+/**
+ * Create a CLI tool environment for executing tools
+ */
+async function createCliToolEnvironment(config: CliConfig): Promise<ToolEnvironment> {
+	const {gameContract: gameContractAddress, chain, storageConfig} = config;
+
+	// Get clients
+	const clients = getClients({chain, privateKey: config.privateKey}) as ClientsWithOptionalWallet;
+
+	// Initialize game contract
+	const gameContract: GameContract = {
+		address: gameContractAddress,
+		abi: Abi_IOuterSpace,
+	};
+
+	// Initialize SpaceInfo
+	const {spaceInfo, contractConfig} = await createSpaceInfo(clients, gameContract);
+
+	// Initialize storage
+	const storage = new JsonFleetStorage(storageConfig.dataDir || './data');
+
+	// Initialize managers
+	const fleetManager = new FleetManager(clients, gameContract, spaceInfo, contractConfig, storage);
+	const planetManager = new PlanetManager(
+		clients,
+		gameContract,
+		spaceInfo,
+		contractConfig,
+		storage,
+	);
+
+	return {
+		fleetManager,
+		planetManager,
+		sendStatus: async (message: string) => {
+			console.log(`[Status] ${message}`);
+		},
+	};
+}
+
+/**
+ * Parse and validate parameters against Zod schema
+ */
+async function parseAndValidateParams(
+	schema: z.ZodObject<any>,
+	options: Record<string, any>,
+): Promise<any> {
+	try {
+		return await schema.parseAsync(options);
+	} catch (error) {
+		if (error instanceof z.ZodError) {
+			console.error('Parameter validation error:');
+			for (const err of error.issues) {
+				console.error(`  - ${err.path.join('.')}: ${err.message}`);
+			}
+		}
+		throw error;
+	}
+}
+
+/**
+ * Format tool result for CLI output
+ */
+function formatToolResult(result: {
+	success: boolean;
+	result?: any;
+	error?: string;
+	stack?: string;
+}): void {
+	if (result.success) {
+		console.log(JSON.stringify(result.result, null, 2));
+	} else {
+		console.error(
+			JSON.stringify(
+				{error: result.error, ...(result.stack ? {stack: result.stack} : {})},
+				null,
+				2,
+			),
+		);
+		process.exit(1);
+	}
+}
+
+/**
+ * Generate a single tool command from tool definition
+ */
+export function generateToolCommand(
+	program: Command,
+	toolName: string,
+	tool: Tool<z.ZodObject<any>>,
+): void {
+	const shape = tool.schema.shape;
+	const cmd = program.command(toolName).description(tool.description);
+
+	// Add options for each schema field
+	for (const [fieldName, field] of Object.entries(shape)) {
+		const actualField = isOptionalField(field as z.ZodTypeAny)
+			? (field as z.ZodOptional<any>).unwrap()
+			: field;
+
+		// Handle nested objects by flattening them
+		if (actualField instanceof z.ZodObject) {
+			const nestedShape = actualField.shape;
+			for (const [nestedKey, nestedField] of Object.entries(nestedShape)) {
+				const optionName = `${fieldName}-${nestedKey}`;
+				const optionDef = zodFieldToOption(optionName, nestedField);
+				const description = getFieldDescription(nestedField);
+				cmd.option(optionDef, description);
+			}
+		} else {
+			const optionDef = zodFieldToOption(fieldName, actualField);
+			const description = getFieldDescription(actualField);
+
+			if (isOptionalField(field as z.ZodTypeAny)) {
+				cmd.option(optionDef, description);
+			} else {
+				cmd.requiredOption(optionDef, description);
+			}
+		}
+	}
+
+	cmd.action(async (options: Record<string, any>) => {
+		try {
+			const globalOptions = program.opts();
+
+			// Get global options
+			const rpcUrl = options.rpcUrl || globalOptions.rpcUrl || process.env.RPC_URL;
+			const gameContract =
+				options.gameContract || globalOptions.gameContract || process.env.GAME_CONTRACT;
+			const ethereum =
+				options.ethereum ?? globalOptions.ethereum ?? process.env.ETHEREUM_TOOLS === 'true';
+			const privateKey = options.privateKey || globalOptions.privateKey || process.env.PRIVATE_KEY;
+			const storageType =
+				options.storage || globalOptions.storage || process.env.STORAGE_TYPE || 'json';
+			const storagePath =
+				options.storagePath || globalOptions.storagePath || process.env.STORAGE_PATH || './data';
+
+			// Validate required options
+			if (!rpcUrl) {
+				console.error('Error: --rpc-url option or RPC_URL environment variable is required');
+				process.exit(1);
+			}
+			if (!gameContract) {
+				console.error(
+					'Error: --game-contract option or GAME_CONTRACT environment variable is required',
+				);
+				process.exit(1);
+			}
+
+			// Get chain
+			const chain = await getChain(rpcUrl);
+
+			// Parse and validate parameters
+			const params: Record<string, any> = {};
+			for (const [fieldName, field] of Object.entries(shape)) {
+				const actualField = isOptionalField(field as z.ZodTypeAny)
+					? (field as z.ZodOptional<any>).unwrap()
+					: field;
+
+				if (actualField instanceof z.ZodObject) {
+					// Handle nested object - reconstruct from flattened options
+					const nestedResult: Record<string, any> = {};
+					const nestedShape = actualField.shape;
+					for (const [nestedKey, nestedField] of Object.entries(nestedShape)) {
+						const optionName = `${fieldName}-${nestedKey}`;
+						if (options[optionName] !== undefined) {
+							nestedResult[nestedKey] = parseOptionValue(nestedField, options[optionName]);
+						}
+					}
+					params[fieldName] = nestedResult;
+				} else {
+					const value = options[fieldName];
+					if (value !== undefined) {
+						params[fieldName] = parseOptionValue(actualField, value);
+					}
+				}
+			}
+
+			const validatedParams = await parseAndValidateParams(tool.schema, params);
+
+			// Create environment and execute
+			const env = await createCliToolEnvironment({
+				chain,
+				privateKey: privateKey as `0x${string}`,
+				gameContract: gameContract as `0x${string}`,
+				ethereum,
+				storageConfig: {
+					type: storageType as 'json' | 'sqlite',
+					dataDir: storagePath,
+				},
+			});
+
+			const result = await tool.execute(env, validatedParams);
+			formatToolResult(result);
+		} catch (error) {
+			if (error instanceof Error) {
+				console.error(
+					JSON.stringify(
+						{error: error.message, ...(error.stack ? {stack: error.stack} : {})},
+						null,
+						2,
+					),
+				);
+			} else {
+				console.error(JSON.stringify({error: String(error)}, null, 2));
+			}
+			process.exit(1);
+		}
+	});
+}
+
+/**
+ * Register all tool commands from a tools object
+ */
+export function registerAllToolCommands(program: Command, tools: Record<string, Tool>): void {
+	for (const [toolName, tool] of Object.entries(tools)) {
+		// Skip the file that's not a tool
+		if (toolName === 'default') continue;
+
+		// Keep snake_case for CLI command names (1:1 mapping with tool names)
+		generateToolCommand(program, toolName, tool);
+	}
+}