mindcraft 0.1.4-0

package/src/process/agent_process.js

@@ -0,0 +1,84 @@
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { logoutAgent } from '../mindcraft/mindserver.js';
+
+const init_agent_path = fileURLToPath(new URL('./init_agent.js', import.meta.url));
+
+export class AgentProcess {
+    constructor(name, port) {
+        this.name = name;
+        this.port = port;
+    }
+
+    start(load_memory=false, init_message=null, count_id=0) {
+        this.count_id = count_id;
+        this.running = true;
+
+        let args = [init_agent_path, this.name];
+        args.push('-n', this.name);
+        args.push('-c', count_id);
+        if (load_memory)
+            args.push('-l', load_memory);
+        if (init_message)
+            args.push('-m', init_message);
+        args.push('-p', this.port);
+
+        const agentProcess = spawn(process.execPath, args, {
+            stdio: 'inherit',
+            stderr: 'inherit',
+        });
+        
+        let last_restart = Date.now();
+        agentProcess.on('exit', (code, signal) => {
+            console.log(`Agent process exited with code ${code} and signal ${signal}`);
+            this.running = false;
+            logoutAgent(this.name);
+            
+            if (code > 1) {
+                console.log(`Ending task`);
+                process.exit(code);
+            }
+
+            if (code !== 0 && signal !== 'SIGINT') {
+                // agent must run for at least 10 seconds before restarting
+                if (Date.now() - last_restart < 10000) {
+                    console.error(`Agent process exited too quickly and will not be restarted.`);
+                    return;
+                }
+                console.log('Restarting agent...');
+                this.start(true, 'Agent process restarted.', count_id, this.port);
+                last_restart = Date.now();
+            }
+        });
+    
+        agentProcess.on('error', (err) => {
+            console.error('Agent process error:', err);
+        });
+
+        this.process = agentProcess;
+    }
+
+    stop() {
+        if (!this.running) return;
+        this.process.kill('SIGINT');
+    }
+
+    forceRestart() {
+        if (this.running && this.process && !this.process.killed) {
+            console.log(`Agent process for ${this.name} is still running. Attempting to force restart.`);
+            
+            const restartTimeout = setTimeout(() => {
+                console.warn(`Agent ${this.name} did not stop in time. It might be stuck.`);
+            }, 5000); // 5 seconds to exit
+
+            this.process.once('exit', () => {
+                 clearTimeout(restartTimeout);
+                 console.log(`Stopped hanging agent ${this.name}. Now restarting.`);
+                 this.start(true, 'Agent process restarted.', this.count_id);
+            });
+            this.stop(); // sends SIGINT
+        } else {
+             this.start(true, 'Agent process restarted.', this.count_id);
+        }
+    }
+}

package/src/process/init_agent.js

@@ -0,0 +1,54 @@
+import { Agent } from '../agent/agent.js';
+import { serverProxy } from '../agent/mindserver_proxy.js';
+import yargs from 'yargs';
+
+const args = process.argv.slice(2);
+if (args.length < 1) {
+    console.log('Usage: node init_agent.js -n <agent_name> -p <port> -l <load_memory> -m <init_message> -c <count_id>');
+    process.exit(1);
+}
+
+const argv = yargs(args)
+    .option('name', {
+        alias: 'n',
+        type: 'string',
+        description: 'name of agent'
+    })
+    .option('load_memory', {
+        alias: 'l',
+        type: 'boolean',
+        description: 'load agent memory from file on startup'
+    })
+    .option('init_message', {
+        alias: 'm',
+        type: 'string',
+        description: 'automatically prompt the agent on startup'
+    })
+    .option('count_id', {
+        alias: 'c',
+        type: 'number',
+        default: 0,
+        description: 'identifying count for multi-agent scenarios',
+    })
+    .option('port', {
+        alias: 'p',
+        type: 'number',
+        description: 'port of mindserver'
+    })
+    .argv;
+
+(async () => {
+    try {
+        console.log('Connecting to MindServer');
+        await serverProxy.connect(argv.name, argv.port);
+        console.log('Starting agent');
+        const agent = new Agent();
+        serverProxy.setAgent(agent);
+        await agent.start(argv.load_memory, argv.init_message, argv.count_id);
+    } catch (error) {
+        console.error('Failed to start agent process:');
+        console.error(error.message);
+        console.error(error.stack);
+        process.exit(1);
+    }
+})();

package/src/utils/examples.js

@@ -0,0 +1,83 @@
+import { cosineSimilarity } from './math.js';
+import { stringifyTurns, wordOverlapScore } from './text.js';
+
+export class Examples {
+    constructor(model, select_num=2) {
+        this.examples = [];
+        this.model = model;
+        this.select_num = select_num;
+        this.embeddings = {};
+    }
+
+    turnsToText(turns) {
+        let messages = '';
+        for (let turn of turns) {
+            if (turn.role !== 'assistant')
+                messages += turn.content.substring(turn.content.indexOf(':')+1).trim() + '\n';
+        }
+        return messages.trim();
+    }
+
+    async load(examples) {
+        this.examples = examples;
+        if (!this.model) return; // Early return if no embedding model
+        
+        if (this.select_num === 0)
+            return;
+
+        try {
+            // Create array of promises first
+            const embeddingPromises = examples.map(example => {
+                const turn_text = this.turnsToText(example);
+                return this.model.embed(turn_text)
+                    .then(embedding => {
+                        this.embeddings[turn_text] = embedding;
+                    });
+            });
+            
+            // Wait for all embeddings to complete
+            await Promise.all(embeddingPromises);
+        } catch (err) {
+            console.warn('Error with embedding model, using word-overlap instead.');
+            this.model = null;
+        }
+    }
+
+    async getRelevant(turns) {
+        if (this.select_num === 0)
+            return [];
+
+        let turn_text = this.turnsToText(turns);
+        if (this.model !== null) {
+            let embedding = await this.model.embed(turn_text);
+            this.examples.sort((a, b) => 
+                cosineSimilarity(embedding, this.embeddings[this.turnsToText(b)]) -
+                cosineSimilarity(embedding, this.embeddings[this.turnsToText(a)])
+            );
+        }
+        else {
+            this.examples.sort((a, b) => 
+                wordOverlapScore(turn_text, this.turnsToText(b)) -
+                wordOverlapScore(turn_text, this.turnsToText(a))
+            );
+        }
+        let selected = this.examples.slice(0, this.select_num);
+        return JSON.parse(JSON.stringify(selected)); // deep copy
+    }
+
+    async createExampleMessage(turns) {
+        let selected_examples = await this.getRelevant(turns);
+
+        console.log('selected examples:');
+        for (let example of selected_examples) {
+            console.log('Example:', example[0].content)
+        }
+
+        let msg = 'Examples of how to respond:\n';
+        for (let i=0; i<selected_examples.length; i++) {
+            let example = selected_examples[i];
+            msg += `Example ${i+1}:\n${stringifyTurns(example)}\n\n`;
+        }
+        return msg;
+    }
+}

package/src/utils/keys.js

@@ -0,0 +1,34 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+
+// Lookup order: ./keys.json (repo-local), then $XDG_CONFIG_HOME/mindcraft/keys.json
+// (written by the web UI's setup wizard), then environment variables.
+function tryRead(p) {
+    try { return JSON.parse(readFileSync(p, 'utf8')); }
+    catch { return null; }
+}
+
+const configHome = process.env.XDG_CONFIG_HOME || path.join(homedir(), '.config');
+const local = tryRead(path.join(process.cwd(), 'keys.json'));
+const user = tryRead(path.join(configHome, 'mindcraft', 'keys.json'));
+const keys = { ...(user || {}), ...(local || {}) };
+
+if (!local && !user) {
+    console.warn('keys.json not found. Defaulting to environment variables.'); // still works with local models
+}
+
+export function getKey(name) {
+    let key = keys[name];
+    if (!key) {
+        key = process.env[name];
+    }
+    if (!key) {
+        throw new Error(`API key "${name}" not found in keys.json or environment variables!`);
+    }
+    return key;
+}
+
+export function hasKey(name) {
+    return keys[name] || process.env[name];
+}

package/src/utils/math.js

@@ -0,0 +1,13 @@
+export function cosineSimilarity(a, b) {
+    let dotProduct = 0;
+    let magnitudeA = 0;
+    let magnitudeB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];  // calculate dot product
+        magnitudeA += Math.pow(a[i], 2);  // calculate magnitude of a
+        magnitudeB += Math.pow(b[i], 2);  // calculate magnitude of b
+    }
+    magnitudeA = Math.sqrt(magnitudeA);
+    magnitudeB = Math.sqrt(magnitudeB);
+    return dotProduct / (magnitudeA * magnitudeB);  // calculate cosine similarity
+}