forked from wmantly/mc-bot-town
577 lines
22 KiB
JavaScript
577 lines
22 KiB
JavaScript
'use strict';
|
|
|
|
const express = require('express');
|
|
const { CJbot } = require('../../model/minecraft');
|
|
|
|
function createRouter() {
|
|
const router = express.Router();
|
|
|
|
router.get('/api/ai/status', (req, res) => {
|
|
try {
|
|
const result = {};
|
|
for (const [name, bot] of Object.entries(CJbot.bots)) {
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai) continue;
|
|
const config = ai.__getConfig();
|
|
result[name] = {
|
|
connected: bot.isReady,
|
|
provider: config.provider || 'unknown',
|
|
model: config.model || 'unknown',
|
|
interval: ai.intervalLength,
|
|
promptName: ai.promptName || 'unknown',
|
|
active: !!ai._active,
|
|
};
|
|
}
|
|
res.json({ bots: result });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/status:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Get list of all bots (for UI)
|
|
router.get('/api/ai/bots', (req, res) => {
|
|
try {
|
|
const bots = [];
|
|
for (const [name, bot] of Object.entries(CJbot.bots)) {
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
bots.push({
|
|
name: name,
|
|
hasAI: !!ai,
|
|
hasMemory: !!(ai && ai.memoryDB)
|
|
});
|
|
}
|
|
res.json({ bots });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/bots:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Get all players with memories (shared across all bots)
|
|
router.get('/api/ai/memories/players', async (req, res) => {
|
|
try {
|
|
// Get players from any bot's memoryDB (they're shared now)
|
|
let players = [];
|
|
for (const [name, bot] of Object.entries(CJbot.bots)) {
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (ai && ai.memoryDB) {
|
|
players = await ai.memoryDB.getAllKnownPlayers();
|
|
break;
|
|
}
|
|
}
|
|
res.json({ players });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/memories/players:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Get memories for a specific player
|
|
router.get('/api/ai/memories/:botName/:playerName', async (req, res) => {
|
|
try {
|
|
const { botName, playerName } = req.params;
|
|
const bot = CJbot.bots[botName];
|
|
if (!bot) {
|
|
return res.status(404).json({ error: 'Bot not found' });
|
|
}
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai || !ai.memoryDB) {
|
|
return res.status(404).json({ error: 'AI or memory DB not loaded' });
|
|
}
|
|
const memories = await ai.memoryDB.getAllPlayerMemories(playerName);
|
|
res.json({ bot: botName, player: playerName, memories });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/memories/:bot/:player:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Set or update a player memory
|
|
router.post('/api/ai/memories/:botName/:playerName', async (req, res) => {
|
|
try {
|
|
const { botName, playerName } = req.params;
|
|
const { key, value } = req.body;
|
|
if (!key || !value) {
|
|
return res.status(400).json({ error: 'key and value are required' });
|
|
}
|
|
const bot = CJbot.bots[botName];
|
|
if (!bot) {
|
|
return res.status(404).json({ error: 'Bot not found' });
|
|
}
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai || !ai.memoryDB) {
|
|
return res.status(404).json({ error: 'AI or memory DB not loaded' });
|
|
}
|
|
await ai.memoryDB.setPlayerMemory(playerName, key, value);
|
|
res.json({ success: true, bot: botName, player: playerName, key, value });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/memories/:bot/:player POST:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Delete a player memory
|
|
router.delete('/api/ai/memories/:botName/:playerName/:key', async (req, res) => {
|
|
try {
|
|
const { botName, playerName, key } = req.params;
|
|
const bot = CJbot.bots[botName];
|
|
if (!bot) {
|
|
return res.status(404).json({ error: 'Bot not found' });
|
|
}
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai || !ai.memoryDB) {
|
|
return res.status(404).json({ error: 'AI or memory DB not loaded' });
|
|
}
|
|
await ai.memoryDB.deletePlayerMemory(playerName, key);
|
|
res.json({ success: true, bot: botName, player: playerName, key });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/memories/:bot/:player/:key DELETE:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Get bot directives
|
|
router.get('/api/ai/directives/:botName', async (req, res) => {
|
|
try {
|
|
const { botName } = req.params;
|
|
const bot = CJbot.bots[botName];
|
|
if (!bot) {
|
|
return res.status(404).json({ error: 'Bot not found' });
|
|
}
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai || !ai.memoryDB) {
|
|
return res.status(404).json({ error: 'AI or memory DB not loaded' });
|
|
}
|
|
const directives = await ai.memoryDB.getAllDirectives();
|
|
res.json({ bot: botName, directives });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/directives/:bot:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Set or update a directive
|
|
router.post('/api/ai/directives/:botName', async (req, res) => {
|
|
try {
|
|
const { botName } = req.params;
|
|
const { key, value } = req.body;
|
|
if (!key || !value) {
|
|
return res.status(400).json({ error: 'key and value are required' });
|
|
}
|
|
const bot = CJbot.bots[botName];
|
|
if (!bot) {
|
|
return res.status(404).json({ error: 'Bot not found' });
|
|
}
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai || !ai.memoryDB) {
|
|
return res.status(404).json({ error: 'AI or memory DB not loaded' });
|
|
}
|
|
await ai.memoryDB.setDirective(key, value);
|
|
res.json({ success: true, bot: botName, key, value });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/directives/:bot POST:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Get general memories
|
|
router.get('/api/ai/general-memories/:botName', async (req, res) => {
|
|
try {
|
|
const { botName } = req.params;
|
|
const bot = CJbot.bots[botName];
|
|
if (!bot) {
|
|
return res.status(404).json({ error: 'Bot not found' });
|
|
}
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai || !ai.memoryDB) {
|
|
return res.status(404).json({ error: 'AI or memory DB not loaded' });
|
|
}
|
|
const memories = await ai.memoryDB.getAllGeneralMemories();
|
|
res.json({ bot: botName, memories });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/general-memories/:bot:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// Set or update a general memory
|
|
router.post('/api/ai/general-memories/:botName', async (req, res) => {
|
|
try {
|
|
const { botName } = req.params;
|
|
const { key, value } = req.body;
|
|
if (!key || !value) {
|
|
return res.status(400).json({ error: 'key and value are required' });
|
|
}
|
|
const bot = CJbot.bots[botName];
|
|
if (!bot) {
|
|
return res.status(404).json({ error: 'Bot not found' });
|
|
}
|
|
const ai = bot.plunginsLoaded['Ai'];
|
|
if (!ai || !ai.memoryDB) {
|
|
return res.status(404).json({ error: 'AI or memory DB not loaded' });
|
|
}
|
|
await ai.memoryDB.setGeneralMemory(key, value);
|
|
res.json({ success: true, bot: botName, key, value });
|
|
} catch (error) {
|
|
console.error('API Error /api/ai/general-memories/:bot POST:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
return router;
|
|
}
|
|
|
|
const webUI = {
|
|
tabId: 'ai',
|
|
tabLabel: 'AI',
|
|
tabOrder: 30,
|
|
html: `
|
|
<div id="aiArea">
|
|
<div class="ai-tabs">
|
|
<button class="ai-tab-btn active" data-tab="status" onclick="switchAiTab('status')">AI Status</button>
|
|
<button class="ai-tab-btn" data-tab="memories" onclick="switchAiTab('memories')">Memories</button>
|
|
<button class="ai-tab-btn" data-tab="directives" onclick="switchAiTab('directives')">Directives</button>
|
|
</div>
|
|
<div id="ai-tab-content">
|
|
<div id="ai-status" class="ai-tab-content active"></div>
|
|
<div id="ai-memories" class="ai-tab-content"></div>
|
|
<div id="ai-directives" class="ai-tab-content"></div>
|
|
</div>
|
|
</div>
|
|
`,
|
|
css: `
|
|
.ai-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(340px,1fr));gap:16px}
|
|
.ai-card{background:#111827;border:1px solid #374151;border-radius:8px;padding:16px;transition:border-color .2s}
|
|
.ai-card:hover{border-color:#a78bfa}
|
|
.ai-card h3{font-size:1em;color:#a78bfa;margin-bottom:12px;display:flex;align-items:center;gap:8px}
|
|
.ai-info{font-size:.85em;color:#9ca3af;margin:4px 0}
|
|
.ai-info .ai-label{color:#6b7280;display:inline-block;min-width:80px}
|
|
.ai-info .ai-value{color:#e5e7eb}
|
|
.ai-status-badge{padding:2px 8px;border-radius:10px;font-size:.75em;font-weight:600}
|
|
.ai-status-badge.active{background:#059669;color:#fff}
|
|
.ai-status-badge.inactive{background:#6b7280;color:#fff}
|
|
.ai-empty{padding:40px 20px;color:#6b7280;text-align:center;font-size:.9em}
|
|
.ai-tabs{display:flex;gap:8px;margin-bottom:16px;border-bottom:1px solid #374151;padding-bottom:8px}
|
|
.ai-tab-btn{background:transparent;border:1px solid #374151;color:#9ca3af;padding:8px 16px;border-radius:6px;cursor:pointer;transition:all .2s}
|
|
.ai-tab-btn:hover{border-color:#a78bfa;color:#e5e7eb}
|
|
.ai-tab-btn.active{background:#a78bfa;border-color:#a78bfa;color:#111827}
|
|
.ai-tab-content{display:none}
|
|
.ai-tab-content.active{display:block}
|
|
.memory-card{background:#111827;border:1px solid #374151;border-radius:8px;padding:16px;margin-bottom:12px}
|
|
.memory-card h4{color:#a78bfa;margin:0 0 12px 0;font-size:.95em}
|
|
.memory-entry{display:flex;justify-content:space-between;align-items:center;padding:8px 0;border-bottom:1px solid #1f2937}
|
|
.memory-entry:last-child{border-bottom:none}
|
|
.memory-key{color:#e5e7eb;font-weight:500}
|
|
.memory-value{color:#9ca3af;max-width:60%;overflow:hidden;text-overflow:ellipsis}
|
|
.memory-actions{display:flex;gap:8px}
|
|
.btn-sm{padding:4px 8px;font-size:.75em;border-radius:4px;border:1px solid #374151;background:#1f2937;color:#9ca3af;cursor:pointer}
|
|
.btn-sm:hover{border-color:#a78bfa;color:#e5e7eb}
|
|
.btn-danger{border-color:#dc2626;color:#fca5a5}
|
|
.btn-danger:hover{background:#dc2626;color:#fff}
|
|
.btn-success{border-color:#059669;color:#6ee7b7}
|
|
.btn-success:hover{background:#059669;color:#fff}
|
|
.memory-form{display:flex;gap:8px;flex-wrap:wrap;margin-top:12px}
|
|
.memory-form input{flex:1;min-width:150px;padding:8px;border-radius:4px;border:1px solid #374151;background:#1f2937;color:#e5e7eb}
|
|
.memory-form input:focus{outline:none;border-color:#a78bfa}
|
|
.player-list{display:grid;grid-template-columns:repeat(auto-fill,minmax(200px,1fr));gap:12px}
|
|
.player-card{background:#1f2937;border:1px solid #374151;border-radius:6px;padding:12px;cursor:pointer;transition:border-color .2s}
|
|
.player-card:hover{border-color:#a78bfa}
|
|
.player-card.selected{border-color:#a78bfa;background:#2d1f4e}
|
|
.form-group{margin-bottom:12px}
|
|
.form-group label{display:block;color:#6b7280;font-size:.85em;margin-bottom:4px}
|
|
.form-group input,.form-group textarea{width:100%;padding:8px;border-radius:4px;border:1px solid #374151;background:#1f2937;color:#e5e7eb;box-sizing:border-box}
|
|
.form-group textarea{min-height:80px;resize:vertical}
|
|
.bot-select{margin-bottom:16px;padding:8px;border-radius:6px;border:1px solid #374151;background:#1f2937;color:#e5e7eb;min-width:200px}
|
|
`,
|
|
onTabActive: 'onAiTabActive',
|
|
js: `
|
|
let aiInterval=null;
|
|
let currentAiTab='status';
|
|
let selectedBot=null;
|
|
let selectedPlayer=null;
|
|
|
|
function onAiTabActive() {
|
|
// Initialize tab content structure if needed
|
|
var container = document.getElementById('ai-tab-content');
|
|
if (container && !container.querySelector('#ai-status')) {
|
|
container.innerHTML = '<div id="ai-status" class="ai-tab-content active"></div><div id="ai-memories" class="ai-tab-content"></div><div id="ai-directives" class="ai-tab-content"></div>';
|
|
}
|
|
loadAiStatus();
|
|
if (!aiInterval) aiInterval = setInterval(() => { if (currentTab === 'ai') loadAiStatus(); }, 10000);
|
|
}
|
|
|
|
function switchAiTab(tab) {
|
|
currentAiTab = tab;
|
|
var btns = document.querySelectorAll('.ai-tab-btn');
|
|
for (var i = 0; i < btns.length; i++) {
|
|
btns[i].classList.remove('active');
|
|
}
|
|
var activeBtn = document.querySelector('.ai-tab-btn[data-tab="'+tab+'"]');
|
|
if (activeBtn) activeBtn.classList.add('active');
|
|
var contents = document.querySelectorAll('.ai-tab-content');
|
|
for (var i = 0; i < contents.length; i++) {
|
|
contents[i].classList.remove('active');
|
|
}
|
|
var target = document.getElementById('ai-'+tab);
|
|
if (target) target.classList.add('active');
|
|
if (tab === 'memories') loadAiPlayers();
|
|
if (tab === 'directives') loadAiDirectives();
|
|
}
|
|
|
|
async function loadAiStatus() {
|
|
try {
|
|
const r = await fetch('/api/ai/status');
|
|
if (!r.ok) { document.getElementById('ai-status').innerHTML='<div class="ai-empty">Failed to load AI status</div>'; return; }
|
|
const d = await r.json();
|
|
renderAiStatus(d.bots || {});
|
|
} catch(e) {
|
|
document.getElementById('ai-status').innerHTML='<div class="ai-empty">Failed to load AI status: ' + escHtml(e.message) + '</div>';
|
|
}
|
|
}
|
|
|
|
function renderAiStatus(bots) {
|
|
const names = Object.keys(bots);
|
|
if (names.length === 0) {
|
|
document.getElementById('ai-status').innerHTML='<div class="ai-empty">No bots with AI loaded</div>';
|
|
return;
|
|
}
|
|
|
|
let html = '<div class="ai-grid">' + names.map(name => {
|
|
const ai = bots[name];
|
|
const badge = ai.active
|
|
? '<span class="ai-status-badge active">Active</span>'
|
|
: '<span class="ai-status-badge inactive">Inactive</span>';
|
|
return '<div class="ai-card">' +
|
|
'<h3><span class="bot-status ' + (ai.connected ? 'online' : 'offline') + '"></span> ' + escHtml(name) + ' ' + badge + '</h3>' +
|
|
'<div class="ai-info"><span class="ai-label">Provider:</span> <span class="ai-value">' + escHtml(ai.provider) + '</span></div>' +
|
|
'<div class="ai-info"><span class="ai-label">Model:</span> <span class="ai-value">' + escHtml(ai.model) + '</span></div>' +
|
|
'<div class="ai-info"><span class="ai-label">Interval:</span> <span class="ai-value">' + ai.interval + 's</span></div>' +
|
|
'<div class="ai-info"><span class="ai-label">Prompt:</span> <span class="ai-value">' + escHtml(ai.promptName) + '</span></div>' +
|
|
'</div>';
|
|
}).join('') + '</div>';
|
|
document.getElementById('ai-status').innerHTML = html;
|
|
}
|
|
|
|
async function loadAiPlayers() {
|
|
try {
|
|
// First get list of all bots (for selecting which bot to edit with)
|
|
const botsR = await fetch('/api/ai/bots');
|
|
if (!botsR.ok) throw new Error('Failed to load bots');
|
|
const botsD = await botsR.json();
|
|
|
|
// Then get players with memories (shared across all bots)
|
|
const r = await fetch('/api/ai/memories/players');
|
|
if (!r.ok) throw new Error('Failed to load players');
|
|
const d = await r.json();
|
|
|
|
renderAiPlayers(d.players || [], botsD.bots || []);
|
|
} catch(e) {
|
|
document.getElementById('ai-memories').innerHTML='<div class="ai-empty">Failed to load players: ' + escHtml(e.message) + '</div>';
|
|
}
|
|
}
|
|
|
|
function renderAiPlayers(players, allBots) {
|
|
// players is now a flat array (shared memories)
|
|
// allBots is array of {name, hasAI, hasMemory}
|
|
if (!allBots || allBots.length === 0) {
|
|
document.getElementById('ai-memories').innerHTML='<div class="ai-empty">No bots available</div>';
|
|
return;
|
|
}
|
|
|
|
let html = '<div class="form-group"><label>Select Bot (for editing):</label><select class="bot-select" onchange="onBotSelect(this.value)">';
|
|
html += '<option value="">-- Select --</option>';
|
|
allBots.forEach(bot => {
|
|
html += '<option value="'+escHtml(bot.name)+'">'+escHtml(bot.name) + (bot.hasAI ? '' : ' (no AI)')+'</option>';
|
|
});
|
|
html += '</select></div>';
|
|
|
|
// Player list (shared, no bot filtering)
|
|
if (players && players.length > 0) {
|
|
html += '<div class="player-list">' + players.map(player => {
|
|
const selected = selectedPlayer === player ? 'selected' : '';
|
|
return '<div class="player-card '+selected+'" onclick="selectPlayer(\\''+escHtml(player)+'\\')">'+escHtml(player)+'</div>';
|
|
}).join('') + '</div>';
|
|
} else {
|
|
html += '<div class="ai-empty">No players with stored memories</div>';
|
|
}
|
|
|
|
if (selectedPlayer) {
|
|
html += '<div id="playerMemoriesArea" style="margin-top:16px"></div>';
|
|
setTimeout(() => loadPlayerMemories(selectedBot, selectedPlayer), 0);
|
|
}
|
|
|
|
document.getElementById('ai-memories').innerHTML = html;
|
|
}
|
|
|
|
function onBotSelect(botName) {
|
|
selectedBot = botName;
|
|
}
|
|
|
|
function selectPlayer(playerName) {
|
|
selectedPlayer = playerName;
|
|
// Re-render to show selection highlight
|
|
loadAiPlayers();
|
|
}
|
|
|
|
async function loadPlayerMemories(botName, playerName) {
|
|
// Memories are shared, but we need a bot selected to edit
|
|
if (!botName) {
|
|
const area = document.getElementById('playerMemoriesArea');
|
|
if (area) {
|
|
area.innerHTML='<div class="ai-empty">Select a bot above to view/edit memories</div>';
|
|
}
|
|
return;
|
|
}
|
|
try {
|
|
const r = await fetch('/api/ai/memories/'+encodeURIComponent(botName)+'/'+encodeURIComponent(playerName));
|
|
if (!r.ok) throw new Error('Failed to load memories');
|
|
const d = await r.json();
|
|
renderPlayerMemories(d.memories || {}, botName, playerName);
|
|
} catch(e) {
|
|
const area = document.getElementById('playerMemoriesArea');
|
|
if (area) {
|
|
area.innerHTML='<div class="ai-empty">Failed to load memories: ' + escHtml(e.message) + '</div>';
|
|
}
|
|
}
|
|
}
|
|
|
|
function renderPlayerMemories(memories, botName, playerName) {
|
|
const area = document.getElementById('playerMemoriesArea');
|
|
if (!area) return; // Element doesn't exist yet
|
|
|
|
const keys = Object.keys(memories);
|
|
if (keys.length === 0) {
|
|
area.innerHTML='<div class="ai-empty">No memories stored for '+escHtml(playerName)+'</div>';
|
|
return;
|
|
}
|
|
|
|
let html = '<div class="memory-card"><h4>Memories for '+escHtml(playerName)+' (shared)</h4>';
|
|
keys.forEach(key => {
|
|
html += '<div class="memory-entry">'+
|
|
'<span class="memory-key">'+escHtml(key)+'</span>'+
|
|
'<span class="memory-value">'+escHtml(memories[key])+'</span>'+
|
|
'<div class="memory-actions">'+
|
|
'<button class="btn-sm btn-danger" onclick="deleteMemory(\\''+escHtml(botName)+'\\',\\''+escHtml(playerName)+'\\',\\''+escHtml(key)+'\\')"><svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"></polyline><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path></svg></button>'+
|
|
'</div></div>';
|
|
});
|
|
html += '</div>';
|
|
|
|
html += '<div class="memory-card"><h4>Add Memory</h4><div class="memory-form">'+
|
|
'<input type="text" id="memoryKey" placeholder="Key (e.g., trust_level)">'+
|
|
'<input type="text" id="memoryValue" placeholder="Value">'+
|
|
'<button class="btn-sm btn-success" onclick="addMemory(\\''+escHtml(botName)+'\\',\\''+escHtml(playerName)+'\\')">Add</button>'+
|
|
'</div></div>';
|
|
|
|
document.getElementById('playerMemoriesArea').innerHTML = html;
|
|
}
|
|
|
|
async function deleteMemory(botName, playerName, key) {
|
|
if (!confirm('Delete memory "'+key+'" for '+playerName+'?')) return;
|
|
try {
|
|
const r = await fetch('/api/ai/memories/'+encodeURIComponent(botName)+'/'+encodeURIComponent(playerName)+'/'+encodeURIComponent(key), { method: 'DELETE' });
|
|
if (!r.ok) throw new Error('Failed to delete');
|
|
loadPlayerMemories(botName, playerName);
|
|
} catch(e) {
|
|
alert('Failed to delete: ' + e.message);
|
|
}
|
|
}
|
|
|
|
async function addMemory(botName, playerName) {
|
|
const key = document.getElementById('memoryKey').value;
|
|
const value = document.getElementById('memoryValue').value;
|
|
if (!key || !value) { alert('Key and value required'); return; }
|
|
try {
|
|
const r = await fetch('/api/ai/memories/'+encodeURIComponent(botName)+'/'+encodeURIComponent(playerName), {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ key, value })
|
|
});
|
|
if (!r.ok) throw new Error('Failed to add');
|
|
document.getElementById('memoryKey').value = '';
|
|
document.getElementById('memoryValue').value = '';
|
|
loadPlayerMemories(botName, playerName);
|
|
} catch(e) {
|
|
alert('Failed to add: ' + e.message);
|
|
}
|
|
}
|
|
|
|
async function loadAiDirectives() {
|
|
try {
|
|
const r = await fetch('/api/ai/bots');
|
|
if (!r.ok) throw new Error('Failed to load bots');
|
|
const d = await r.json();
|
|
const bots = d.bots || [];
|
|
|
|
let html = '<div class="form-group"><label>Select Bot:</label><select class="bot-select" onchange="loadBotDirectives(this.value)">';
|
|
html += '<option value="">-- Select --</option>';
|
|
bots.forEach(bot => {
|
|
html += '<option value="'+escHtml(bot.name)+'">'+escHtml(bot.name) + (bot.hasAI ? '' : ' (no AI)')+'</option>';
|
|
});
|
|
html += '</select></div><div id="directivesArea"></div>';
|
|
document.getElementById('ai-directives').innerHTML = html;
|
|
} catch(e) {
|
|
document.getElementById('ai-directives').innerHTML='<div class="ai-empty">Failed to load bots: ' + escHtml(e.message) + '</div>';
|
|
}
|
|
}
|
|
|
|
async function loadBotDirectives(botName) {
|
|
if (!botName) { document.getElementById('directivesArea').innerHTML = ''; return; }
|
|
try {
|
|
const r = await fetch('/api/ai/directives/'+encodeURIComponent(botName));
|
|
if (!r.ok) throw new Error('Failed to load directives');
|
|
const d = await r.json();
|
|
renderBotDirectives(d.directives || {}, botName);
|
|
} catch(e) {
|
|
document.getElementById('directivesArea').innerHTML='<div class="ai-empty">Failed to load: ' + escHtml(e.message) + '</div>';
|
|
}
|
|
}
|
|
|
|
function renderBotDirectives(directives, botName) {
|
|
const keys = Object.keys(directives);
|
|
let html = '<div class="memory-card"><h4>Directives for '+escHtml(botName)+'</h4>';
|
|
if (keys.length === 0) {
|
|
html += '<div class="ai-empty">No directives set</div>';
|
|
} else {
|
|
keys.forEach(key => {
|
|
html += '<div class="memory-entry">'+
|
|
'<span class="memory-key">'+escHtml(key)+'</span>'+
|
|
'<span class="memory-value">'+escHtml(directives[key])+'</span>'+
|
|
'</div>';
|
|
});
|
|
}
|
|
html += '</div>';
|
|
|
|
html += '<div class="memory-card"><h4>Add Directive</h4><div class="form-group">'+
|
|
'<label>Key</label><input type="text" id="directiveKey" placeholder="e.g., current_goal">'+
|
|
'</div><div class="form-group">'+
|
|
'<label>Value</label><textarea id="directiveValue" placeholder="Directive value"></textarea>'+
|
|
'</div><button class="btn-sm btn-success" onclick="addDirective(\\''+escHtml(botName)+'\\')">Add</button>'+
|
|
'</div>';
|
|
|
|
document.getElementById('directivesArea').innerHTML = html;
|
|
}
|
|
|
|
async function addDirective(botName) {
|
|
const key = document.getElementById('directiveKey').value;
|
|
const value = document.getElementById('directiveValue').value;
|
|
if (!key || !value) { alert('Key and value required'); return; }
|
|
try {
|
|
const r = await fetch('/api/ai/directives/'+encodeURIComponent(botName), {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ key, value })
|
|
});
|
|
if (!r.ok) throw new Error('Failed to add');
|
|
document.getElementById('directiveKey').value = '';
|
|
document.getElementById('directiveValue').value = '';
|
|
loadBotDirectives(botName);
|
|
} catch(e) {
|
|
alert('Failed to add: ' + e.message);
|
|
}
|
|
}
|
|
`,
|
|
};
|
|
|
|
module.exports = { createRouter, webUI };
|