mindcraft 0.1.4-0

package/src/agent/commands/index.js

@@ -0,0 +1,259 @@
+import { getBlockId, getItemId } from "../../utils/mcdata.js";
+import { actionsList } from './actions.js';
+import { queryList } from './queries.js';
+
+let suppressNoDomainWarning = true;
+
+const commandList = queryList.concat(actionsList);
+const commandMap = {};
+for (let command of commandList) {
+    commandMap[command.name] = command;
+}
+
+export function getCommand(name) {
+    return commandMap[name];
+}
+
+export function blacklistCommands(commands) {
+    const unblockable = ['!stop', '!stats', '!inventory', '!goal'];
+    for (let command_name of commands) {
+        if (unblockable.includes(command_name)){
+            console.warn(`Command ${command_name} is unblockable`);
+            continue;
+        }
+        delete commandMap[command_name];
+        delete commandList.find(command => command.name === command_name);
+    }
+}
+
+const commandRegex = /!(\w+)(?:\(((?:-?\d+(?:\.\d+)?|true|false|"[^"]*")(?:\s*,\s*(?:-?\d+(?:\.\d+)?|true|false|"[^"]*"))*)\))?/
+const argRegex = /-?\d+(?:\.\d+)?|true|false|"[^"]*"/g;
+
+export function containsCommand(message) {
+    const commandMatch = message.match(commandRegex);
+    if (commandMatch)
+        return "!" + commandMatch[1];
+    return null;
+}
+
+export function commandExists(commandName) {
+    if (!commandName.startsWith("!"))
+        commandName = "!" + commandName;
+    return commandMap[commandName] !== undefined;
+}
+
+/**
+ * Converts a string into a boolean.
+ * @param {string} input
+ * @returns {boolean | null} the boolean or `null` if it could not be parsed.
+ * */
+function parseBoolean(input) {
+    switch(input.toLowerCase()) {
+        case 'false': //These are interpreted as flase;
+        case 'f':
+        case '0':
+        case 'off':
+            return false;
+        case 'true': //These are interpreted as true;
+        case 't':
+        case '1':
+        case 'on':
+            return true;
+        default:
+            return null;
+    }
+}
+
+/**
+ * @param {number} value - the value to check
+ * @param {number} lowerBound
+ * @param {number} upperBound
+ * @param {string} endpointType - The type of the endpoints represented as a two character string. `'[)'` `'()'` 
+ */
+function checkInInterval(number, lowerBound, upperBound, endpointType) {
+    switch (endpointType) {
+        case '[)':
+            return lowerBound <= number && number < upperBound;
+        case '()':
+            return lowerBound < number && number < upperBound;
+        case '(]':
+            return lowerBound < number && number <= upperBound;
+        case '[]':
+            return lowerBound <= number && number <= upperBound;
+        default:
+            throw new Error('Unknown endpoint type:', endpointType)
+    }
+}
+
+
+
+// todo: handle arrays?
+/**
+ * Returns an object containing the command, the command name, and the comand parameters.
+ * If parsing unsuccessful, returns an error message as a string.
+ * @param {string} message - A message from a player or language model containing a command.
+ * @returns {string | Object}
+ */
+export function parseCommandMessage(message) {
+    const commandMatch = message.match(commandRegex);
+    if (!commandMatch) return `Command is incorrectly formatted`;
+
+    const commandName = "!"+commandMatch[1];
+
+    let args;
+    if (commandMatch[2]) args = commandMatch[2].match(argRegex);
+    else args = [];
+
+    const command = getCommand(commandName);
+    if(!command) return `${commandName} is not a command.`
+
+    const params = commandParams(command);
+    const paramNames = commandParamNames(command);
+    
+    if (args.length !== params.length)
+        return `Command ${command.name} was given ${args.length} args, but requires ${params.length} args.`;
+
+    
+    for (let i = 0; i < args.length; i++) {
+        const param = params[i];
+        //Remove any extra characters
+        let arg = args[i].trim();
+        if ((arg.startsWith('"') && arg.endsWith('"')) || (arg.startsWith("'") && arg.endsWith("'"))) {
+            arg = arg.substring(1, arg.length-1);
+        }
+        
+        //Convert to the correct type
+        switch(param.type) {
+            case 'int':
+                arg = Number.parseInt(arg); break;
+            case 'float':
+                arg = Number.parseFloat(arg); break;
+            case 'boolean':
+                arg = parseBoolean(arg); break;
+            case 'BlockName':
+            case 'BlockOrItemName':
+            case 'ItemName':
+                if (arg.endsWith('plank') || arg.endsWith('seed'))
+                    arg += 's'; // add 's' to for common mistakes like "oak_plank" or "wheat_seed"
+            case 'string':
+                break;
+            default:
+                throw new Error(`Command '${commandName}' parameter '${paramNames[i]}' has an unknown type: ${param.type}`);
+        }
+        if(arg === null || Number.isNaN(arg))
+            return `Error: Param '${paramNames[i]}' must be of type ${param.type}.`
+
+        if(typeof arg === 'number') { //Check the domain of numbers
+            const domain = param.domain;
+            if(domain) {
+                /**
+                 * Javascript has a built in object for sets but not intervals.
+                 * Currently the interval (lowerbound,upperbound] is represented as an Array: `[lowerbound, upperbound, '(]']`
+                 */
+                if (!domain[2]) domain[2] = '[)'; //By default, lower bound is included. Upper is not.
+
+                if(!checkInInterval(arg, ...domain)) {
+                    return `Error: Param '${paramNames[i]}' must be an element of ${domain[2][0]}${domain[0]}, ${domain[1]}${domain[2][1]}.`;
+                    //Alternatively arg could be set to the nearest value in the domain.
+                }
+            } else if (!suppressNoDomainWarning) {
+                console.warn(`Command '${commandName}' parameter '${paramNames[i]}' has no domain set. Expect any value [-Infinity, Infinity].`)
+                suppressNoDomainWarning = true; //Don't spam console. Only give the warning once.
+            }
+        } else if(param.type === 'BlockName') { //Check that there is a block with this name
+            if(getBlockId(arg) == null) return  `Invalid block type: ${arg}.`
+        } else if(param.type === 'ItemName') { //Check that there is an item with this name
+            if(getItemId(arg) == null) return `Invalid item type: ${arg}.`
+        } else if(param.type === 'BlockOrItemName') {
+            if(getBlockId(arg) == null && getItemId(arg) == null) return  `Invalid block or item type: ${arg}.`
+        }
+        args[i] = arg;
+    }
+    
+    return { commandName, args };
+}
+
+export function truncCommandMessage(message) {
+    const commandMatch = message.match(commandRegex);
+    if (commandMatch) {
+        return message.substring(0, commandMatch.index + commandMatch[0].length);
+    }
+    return message;
+}
+
+export function isAction(name) {
+    return actionsList.find(action => action.name === name) !== undefined;
+}
+
+/**
+ * @param {Object} command
+ * @returns {Object[]} The command's parameters.
+ */
+function commandParams(command) {
+    if (!command.params)
+        return [];
+    return Object.values(command.params);
+}
+
+/**
+ * @param {Object} command
+ * @returns {string[]} The names of the command's parameters.
+ */
+function commandParamNames(command) {
+    if (!command.params)
+        return [];
+    return Object.keys(command.params);
+}
+
+function numParams(command) {
+    return commandParams(command).length;
+}
+
+export async function executeCommand(agent, message) {
+    let parsed = parseCommandMessage(message);
+    if (typeof parsed === 'string')
+        return parsed; //The command was incorrectly formatted or an invalid input was given.
+    else {
+        console.log('parsed command:', parsed);
+        const command = getCommand(parsed.commandName);
+        let numArgs = 0;
+        if (parsed.args) {
+            numArgs = parsed.args.length;
+        }
+        if (numArgs !== numParams(command))
+            return `Command ${command.name} was given ${numArgs} args, but requires ${numParams(command)} args.`;
+        else {
+            const result = await command.perform(agent, ...parsed.args);
+            return result;
+        }
+    }
+}
+
+export function getCommandDocs(agent) {
+    const typeTranslations = {
+        //This was added to keep the prompt the same as before type checks were implemented.
+        //If the language model is giving invalid inputs changing this might help.
+        'float':             'number',
+        'int':               'number',
+        'BlockName':         'string',
+        'ItemName':          'string',
+        'BlockOrItemName':   'string',
+        'boolean':           'bool'
+    }
+    let docs = `\n*COMMAND DOCS\n You can use the following commands to perform actions and get information about the world. 
+    Use the commands with the syntax: !commandName or !commandName("arg1", 1.2, ...) if the command takes arguments.\n
+    Do not use codeblocks. Use double quotes for strings. Only use one command in each response, trailing commands and comments will be ignored.\n`;
+    for (let command of commandList) {
+        if (agent.blocked_actions.includes(command.name)) {
+            continue;
+        }
+        docs += command.name + ': ' + command.description + '\n';
+        if (command.params) {
+            docs += 'Params:\n';
+            for (let param in command.params) {
+                docs += `${param}: (${typeTranslations[command.params[param].type]??command.params[param].type}) ${command.params[param].description}\n`;
+            }
+        }
+    }
+    return docs + '*\n';
+}

package/src/agent/commands/queries.js

@@ -0,0 +1,347 @@
+import * as world from '../library/world.js';
+import * as mc from '../../utils/mcdata.js';
+import { getCommandDocs } from './index.js';
+import convoManager from '../conversation.js';
+import { checkLevelBlueprint, checkBlueprint } from '../tasks/construction_tasks.js';
+import { load } from 'cheerio';
+
+const pad = (str) => {
+    return '\n' + str + '\n';
+}
+
+// queries are commands that just return strings and don't affect anything in the world
+export const queryList = [
+    {
+        name: "!stats",
+        description: "Get your bot's location, health, hunger, and time of day.", 
+        perform: function (agent) {
+            let bot = agent.bot;
+            let res = 'STATS';
+            let pos = bot.entity.position;
+            // display position to 2 decimal places
+            res += `\n- Position: x: ${pos.x.toFixed(2)}, y: ${pos.y.toFixed(2)}, z: ${pos.z.toFixed(2)}`;
+            // Gameplay
+            res += `\n- Gamemode: ${bot.game.gameMode}`;
+            res += `\n- Health: ${Math.round(bot.health)} / 20`;
+            res += `\n- Hunger: ${Math.round(bot.food)} / 20`;
+            res += `\n- Biome: ${world.getBiomeName(bot)}`;
+            let weather = "Clear";
+            if (bot.rainState > 0)
+                weather = "Rain";
+            if (bot.thunderState > 0)
+                weather = "Thunderstorm";
+            res += `\n- Weather: ${weather}`;
+            // let block = bot.blockAt(pos);
+            // res += `\n- Artficial light: ${block.skyLight}`;
+            // res += `\n- Sky light: ${block.light}`;
+            // light properties are bugged, they are not accurate
+
+
+            if (bot.time.timeOfDay < 6000) {
+                res += '\n- Time: Morning';
+            } else if (bot.time.timeOfDay < 12000) {
+                res += '\n- Time: Afternoon';
+            } else {
+                res += '\n- Time: Night';
+            }
+
+            // get the bot's current action
+            let action = agent.actions.currentActionLabel;
+            if (agent.isIdle())
+                action = 'Idle';
+            res += `\- Current Action: ${action}`;
+
+
+            let players = world.getNearbyPlayerNames(bot);
+            let bots = convoManager.getInGameAgents().filter(b => b !== agent.name);
+            players = players.filter(p => !bots.includes(p));
+
+            res += '\n- Nearby Human Players: ' + (players.length > 0 ? players.join(', ') : 'None.');
+            res += '\n- Nearby Bot Players: ' + (bots.length > 0 ? bots.join(', ') : 'None.');
+
+            res += '\n' + agent.bot.modes.getMiniDocs() + '\n';
+            return pad(res);
+        }
+    },
+    {
+        name: "!inventory",
+        description: "Get your bot's inventory.",
+        perform: function (agent) {
+            let bot = agent.bot;
+            let inventory = world.getInventoryCounts(bot);
+            let res = 'INVENTORY';
+            for (const item in inventory) {
+                if (inventory[item] && inventory[item] > 0)
+                    res += `\n- ${item}: ${inventory[item]}`;
+            }
+            if (res === 'INVENTORY') {
+                res += ': Nothing';
+            }
+            else if (agent.bot.game.gameMode === 'creative') {
+                res += '\n(You have infinite items in creative mode. You do not need to gather resources!!)';
+            }
+
+            let helmet = bot.inventory.slots[5];
+            let chestplate = bot.inventory.slots[6];
+            let leggings = bot.inventory.slots[7];
+            let boots = bot.inventory.slots[8];
+            res += '\nWEARING: ';
+            if (helmet)
+                res += `\nHead: ${helmet.name}`;
+            if (chestplate)
+                res += `\nTorso: ${chestplate.name}`;
+            if (leggings)
+                res += `\nLegs: ${leggings.name}`;
+            if (boots)
+                res += `\nFeet: ${boots.name}`;
+            if (!helmet && !chestplate && !leggings && !boots)
+                res += 'Nothing';
+
+            return pad(res);
+        }
+    },
+    {
+        name: "!nearbyBlocks",
+        description: "Get the blocks near the bot.",
+        perform: function (agent) {
+            let bot = agent.bot;
+            let res = 'NEARBY_BLOCKS';
+            let blocks = world.getNearestBlocks(bot);
+            let block_details = new Set();
+            
+            for (let block of blocks) {
+                let details = block.name;
+                if (block.name === 'water' || block.name === 'lava') {
+                    details += block.metadata === 0 ? ' (source)' : ' (flowing)';
+                }
+                block_details.add(details);
+            }
+            for (let details of block_details) {
+                res += `\n- ${details}`;
+            }
+            if (block_details.size === 0) {
+                res += ': none';
+            } 
+            else {
+                res += '\n- ' + world.getSurroundingBlocks(bot).join('\n- ');
+                res += `\n- First Solid Block Above Head: ${world.getFirstBlockAboveHead(bot, null, 32)}`;
+            }
+            return pad(res);
+        }
+    },
+    {
+        name: "!craftable",
+        description: "Get the craftable items with the bot's inventory.",
+        perform: function (agent) {
+            let craftable = world.getCraftableItems(agent.bot);
+            let res = 'CRAFTABLE_ITEMS';
+            for (const item of craftable) {
+                res += `\n- ${item}`;
+            }
+            if (res == 'CRAFTABLE_ITEMS') {
+                res += ': none';
+            }
+            return pad(res);
+        }
+    },
+    {
+        name: "!entities",
+        description: "Get the nearby players and entities.",
+        perform: function (agent) {
+            let bot = agent.bot;
+            let res = 'NEARBY_ENTITIES';
+            let players = world.getNearbyPlayerNames(bot);
+            let bots = convoManager.getInGameAgents().filter(b => b !== agent.name);
+            players = players.filter(p => !bots.includes(p));
+
+            for (const player of players) {
+                res += `\n- Human player: ${player}`;
+            }
+            for (const bot of bots) {
+                res += `\n- Bot player: ${bot}`;
+            }
+
+            let nearbyEntities = world.getNearbyEntities(bot);
+            let entityCounts = {};
+            let villagerIds = [];
+            let babyVillagerIds = [];
+            let villagerDetails = []; // Store detailed villager info including profession
+            
+            for (const entity of nearbyEntities) {
+                if (entity.type === 'player' || entity.name === 'item')
+                    continue;
+                    
+                if (!entityCounts[entity.name]) {
+                    entityCounts[entity.name] = 0;
+                }
+                entityCounts[entity.name]++;
+                
+                if (entity.name === 'villager') {
+                    if (entity.metadata && entity.metadata[16] === 1) {
+                        babyVillagerIds.push(entity.id);
+                    } else {
+                        const profession = world.getVillagerProfession(entity);
+                        villagerIds.push(entity.id);
+                        villagerDetails.push({
+                            id: entity.id,
+                            profession: profession
+                        });
+                    }
+                }
+            }
+            
+            for (const [entityType, count] of Object.entries(entityCounts)) {
+                if (entityType === 'villager') {
+                    let villagerInfo = `${count} ${entityType}(s)`;
+                    if (villagerDetails.length > 0) {
+                        const detailStrings = villagerDetails.map(v => `(${v.id}:${v.profession})`);
+                        villagerInfo += ` - Adults: ${detailStrings.join(', ')}`;
+                    }
+                    if (babyVillagerIds.length > 0) {
+                        villagerInfo += ` - Baby IDs: ${babyVillagerIds.join(', ')} (babies cannot trade)`;
+                    }
+                    res += `\n- entities: ${villagerInfo}`;
+                } else {
+                    res += `\n- entities: ${count} ${entityType}(s)`;
+                }
+            }
+            
+            if (res == 'NEARBY_ENTITIES') {
+                res += ': none';
+            }
+            return pad(res);
+        }
+    },
+    {
+        name: "!modes",
+        description: "Get all available modes and their docs and see which are on/off.",
+        perform: function (agent) {
+            return agent.bot.modes.getDocs();
+        }
+    },
+    {
+        name: '!savedPlaces',
+        description: 'List all saved locations.',
+        perform: async function (agent) {
+            return "Saved place names: " + agent.memory_bank.getKeys();
+        }
+    }, 
+    {
+        name: '!checkBlueprintLevel',
+        description: 'Check if the level is complete and what blocks still need to be placed for the blueprint',
+        params: {
+            'levelNum': { type: 'int', description: 'The level number to check.', domain: [0, Number.MAX_SAFE_INTEGER] }
+        },
+        perform: function (agent, levelNum) {
+            let res = checkLevelBlueprint(agent, levelNum);
+            console.log(res);
+            return pad(res);
+        }
+    }, 
+    {
+        name: '!checkBlueprint',
+        description: 'Check what blocks still need to be placed for the blueprint',
+        perform: function (agent) {
+            let res = checkBlueprint(agent);
+            return pad(res);
+        }
+    }, 
+    {
+        name: '!getBlueprint',
+        description: 'Get the blueprint for the building',
+        perform: function (agent) {
+            let res = agent.task.blueprint.explain();
+            return pad(res);
+        }
+    }, 
+    {
+        name: '!getBlueprintLevel',
+        description: 'Get the blueprint for the building',
+        params: {
+            'levelNum': { type: 'int', description: 'The level number to check.', domain: [0, Number.MAX_SAFE_INTEGER] }
+        },
+        perform: function (agent, levelNum) {
+            let res = agent.task.blueprint.explainLevel(levelNum);
+            console.log(res);
+            return pad(res);
+        }
+    },
+    {
+        name: '!getCraftingPlan',
+        description: "Provides a comprehensive crafting plan for a specified item. This includes a breakdown of required ingredients, the exact quantities needed, and an analysis of missing ingredients or extra items needed based on the bot's current inventory.",
+        params: {
+            targetItem: { 
+                type: 'string', 
+                description: 'The item that we are trying to craft' 
+            },
+            quantity: { 
+                type: 'int',
+                description: 'The quantity of the item that we are trying to craft',
+                optional: true,
+                domain: [1, Infinity, '[)'], // Quantity must be at least 1,
+                default: 1
+            }
+        },
+        perform: function (agent, targetItem, quantity = 1) {
+            let bot = agent.bot;
+
+            // Fetch the bot's inventory
+            const curr_inventory = world.getInventoryCounts(bot); 
+            const target_item = targetItem;
+            let existingCount = curr_inventory[target_item] || 0;
+            let prefixMessage = '';
+            if (existingCount > 0) {
+                curr_inventory[target_item] -= existingCount;
+                prefixMessage = `You already have ${existingCount} ${target_item} in your inventory. If you need to craft more,\n`;
+            }
+
+            // Generate crafting plan
+            try {
+                let craftingPlan = mc.getDetailedCraftingPlan(target_item, quantity, curr_inventory);
+                craftingPlan = prefixMessage + craftingPlan;
+                return pad(craftingPlan);
+            } catch (error) {
+                console.error("Error generating crafting plan:", error);
+                return `An error occurred while generating the crafting plan: ${error.message}`;
+            }
+            
+            
+        },
+    },
+    {
+        name: '!searchWiki',
+        description: 'Search the Minecraft Wiki for the given query.',
+        params: {
+            'query': { type: 'string', description: 'The query to search for.' }
+        },
+        perform: async function (agent, query) {
+            const url = `https://minecraft.wiki/w/${query}`
+            try {
+                const response = await fetch(url);
+                if (response.status === 404) {
+                  return `${query} was not found on the Minecraft Wiki. Try adjusting your search term.`;
+                }
+                const html = await response.text();
+                const $ = load(html);
+            
+                const parserOutput = $("div.mw-parser-output");
+                
+                parserOutput.find("table.navbox").remove();
+
+                const divContent = parserOutput.text();
+            
+                return divContent.trim();
+              } catch (error) {
+                console.error("Error fetching or parsing HTML:", error);
+                return `The following error occurred: ${error}`
+              }
+        }
+    },
+    {
+        name: '!help',
+        description: 'Lists all available commands and their descriptions.',
+        perform: async function (agent) {
+            return getCommandDocs(agent);
+        }
+    },
+];