kiku-agent 1.2.0 → 1.3.1

package/server/agent/lmStudioWakeup.js

@@ -0,0 +1,144 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs';
+
+export async function isLmStudioResponding(baseUrl = 'http://127.0.0.1:1234/v1', timeoutMs = 2500) {
+  try {
+    const root = baseUrl.replace(/\/v1\/?$/, '').replace(/\/+$/, '');
+    const res = await fetch(`${root}/v1/models`, { signal: AbortSignal.timeout(timeoutMs) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function getLoadedModels(baseUrl = 'http://127.0.0.1:1234/v1', timeoutMs = 2500) {
+  try {
+    const root = baseUrl.replace(/\/v1\/?$/, '').replace(/\/+$/, '');
+    const res = await fetch(`${root}/v1/models`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return [];
+    const data = await res.json();
+    return Array.isArray(data.data) ? data.data.map(m => m.id) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function resolveLmsCli() {
+  const userHome = os.homedir();
+  const isWin = process.platform === 'win32';
+  const candidates = [
+    path.join(userHome, '.lmstudio', 'bin', isWin ? 'lms.exe' : 'lms'),
+    isWin ? 'lms.exe' : 'lms'
+  ];
+  return candidates.find(c => {
+    try { return fs.existsSync(c); } catch { return false; }
+  }) || (isWin ? 'lms.exe' : 'lms');
+}
+
+export async function loadLmStudioModel(model, options = {}) {
+  const lmsCmd = resolveLmsCli();
+  return new Promise((resolve) => {
+    const args = ['load', model, '-y', '--identifier', model];
+    const child = spawn(lmsCmd, args, {
+      windowsHide: true,
+      stdio: 'pipe',
+      shell: process.platform === 'win32'
+    });
+    let output = '';
+    child.stdout?.on('data', d => { output += d.toString(); });
+    child.stderr?.on('data', d => { output += d.toString(); });
+    child.on('close', code => {
+      resolve({ ok: code === 0, output });
+    });
+    child.on('error', err => {
+      resolve({ ok: false, error: err.message });
+    });
+  });
+}
+
+export async function wakeUpLmStudio(options = {}) {
+  const {
+    baseUrl = 'http://127.0.0.1:1234/v1',
+    model = 'google/gemma-4-e4b',
+    maxWaitMs = 35000
+  } = options;
+
+  const isLocal = baseUrl.includes('127.0.0.1') || baseUrl.includes('localhost');
+  if (!isLocal) {
+    return { ok: false, reason: 'Non-local endpoint, automatic wakeup skipped' };
+  }
+
+
+  let serverUp = await isLmStudioResponding(baseUrl, 2000);
+  if (!serverUp) {
+    const userHome = os.homedir();
+    const possiblePaths = [
+      path.join(userHome, 'AppData', 'Local', 'Programs', 'LM Studio', 'LM Studio.exe'),
+      path.join(process.env.LOCALAPPDATA || '', 'Programs', 'LM Studio', 'LM Studio.exe'),
+      'C:\\Program Files\\LM Studio\\LM Studio.exe'
+    ];
+
+    const appExe = possiblePaths.find(p => p && fs.existsSync(p));
+    if (appExe) {
+      try {
+        const child = spawn(appExe, [], {
+          detached: true,
+          stdio: 'ignore',
+          windowsHide: false
+        });
+        child.unref();
+      } catch {}
+    }
+
+    try {
+      const lmsCmd = resolveLmsCli();
+      const lmsChild = spawn(lmsCmd, ['server', 'start'], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        shell: process.platform === 'win32'
+      });
+      lmsChild.unref();
+    } catch {}
+
+    const start = Date.now();
+    while (Date.now() - start < maxWaitMs) {
+      await new Promise(r => setTimeout(r, 1500));
+      if (await isLmStudioResponding(baseUrl, 2000)) {
+        serverUp = true;
+        break;
+      }
+    }
+  }
+
+  if (!serverUp) {
+    return { ok: false, reason: 'Timed out waiting for LM Studio server' };
+  }
+
+
+  if (model) {
+    const loaded = await getLoadedModels(baseUrl);
+    if (!loaded.includes(model)) {
+      try {
+        process.stdout.write(`\n🌸 [Kiku Auto-Wakeup] LM Studio server active. Auto-loading model "${model}" into VRAM...\n`);
+      } catch {}
+      await loadLmStudioModel(model);
+
+      const start = Date.now();
+      while (Date.now() - start < maxWaitMs) {
+        await new Promise(r => setTimeout(r, 1500));
+        const currentModels = await getLoadedModels(baseUrl);
+        if (currentModels.includes(model)) {
+          try {
+            process.stdout.write(`🌸 [Kiku Auto-Wakeup] Model "${model}" loaded and ready!\n\n`);
+          } catch {}
+          return { ok: true, awakened: true, modelLoaded: true };
+        }
+      }
+    }
+  }
+
+  return { ok: true, alreadyRunning: true };
+}

package/server/agent/mcpClient.js

@@ -185,7 +185,6 @@ export class McpClientManager {
       let resources = serverConfig.resources || [];
       let prompts = serverConfig.prompts || [];
 
-      // If tools not pre-provided, fetch once upon connection
       if (!tools || tools.length === 0) {
         try {
           if (!this._isRateLimited(name)) {
@@ -570,7 +569,6 @@ export class McpClientManager {
           if (cfg.enabled === false || cfg.disabled === true) continue;
           if (this.servers.has(name)) continue;
 
-          // If tools are cached or it's a known Kiku remote MCP server, register lazily without network call on startup
           let tools = cfg.tools;
           if (!tools || tools.length === 0) {
             if (name === 'kiku-mcp' || /jujingyi-kikuuu|vercel\.app/i.test(cfg.url || '')) {
@@ -641,3 +639,5 @@ export class McpClientManager {
     return results;
   }
 }
+
+export const mcpClientManager = new McpClientManager();

package/server/agent/memory/contextAllocator.js

@@ -0,0 +1,214 @@
+export function extractWordTokens(text) {
+  if (!text || typeof text !== 'string') return [];
+  return text
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s]+/gu, ' ')
+    .split(/\s+/)
+    .filter(t => t.length >= 2);
+}
+
+export function buildTermFrequencyVector(tokens) {
+  const vec = {};
+  for (const t of tokens) {
+    vec[t] = (vec[t] || 0) + 1;
+  }
+  return vec;
+}
+
+export function computeCosineSimilarity(vecA, vecB) {
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+
+  for (const [key, val] of Object.entries(vecA)) {
+    normA += val * val;
+    if (vecB[key]) {
+      dotProduct += val * vecB[key];
+    }
+  }
+
+  for (const val of Object.values(vecB)) {
+    normB += val * val;
+  }
+
+  if (normA === 0 || normB === 0) return 0;
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+export class ContextAllocator {
+  constructor(options = {}) {
+    this.store = options.store;
+    this.defaultMaxTokens = options.maxTokens || 2000;
+  }
+
+  estimateTokens(text) {
+    if (!text) return 0;
+  
+    return Math.ceil(text.length / 3.5);
+  }
+
+  truncateToTokenLimit(text, tokenLimit) {
+    if (!text) return '';
+    const charLimit = Math.floor(tokenLimit * 3.5);
+    if (text.length <= charLimit) return text;
+    return text.slice(0, charLimit - 15) + '\n...[truncated]';
+  }
+
+ 
+  async allocateContext({ currentQuery = '', activeRunId = null, memory = null, maxTokens = null } = {}) {
+    const budgetTokens = maxTokens || this.defaultMaxTokens;
+    const quota = {
+      user: Math.floor(budgetTokens * 0.20),
+      run: Math.floor(budgetTokens * 0.40),
+      reflections: Math.floor(budgetTokens * 0.20),
+      general: Math.floor(budgetTokens * 0.20),
+    };
+
+    const sections = [];
+
+   
+    const userParts = [];
+    if (this.store) {
+      const guidelineNodes = await this.store.listNodes('kiku/guidelines/');
+      for (const node of guidelineNodes) {
+        const domain = node.domain || 'general';
+        const content = typeof node.content === 'string' ? node.content : JSON.stringify(node.content);
+        userParts.push(`[Guideline: ${domain}]\n${content}`);
+      }
+    }
+
+    if (memory?.preferences?.language) {
+      userParts.push(`User preferred language: ${memory.preferences.language}`);
+    }
+
+    const userSkillContext = memory?.buildUserSkillContext ? memory.buildUserSkillContext() : '';
+    if (userSkillContext) {
+      userParts.push(`User-taught skills:\n${userSkillContext}`);
+    }
+
+    const feedbackStyleContext = memory?.buildFeedbackStyleContext ? memory.buildFeedbackStyleContext() : '';
+    if (feedbackStyleContext) {
+      userParts.push(`Learned answer-style preferences:\n${feedbackStyleContext}`);
+    }
+
+    if (userParts.length > 0) {
+      const userText = this.truncateToTokenLimit(userParts.join('\n\n'), quota.user);
+      sections.push(`--- USER GUIDELINES & PREFERENCES (20% Quota) ---\n${userText}`);
+    }
+
+   
+    if (activeRunId && this.store) {
+      const runData = await this.store.loadActiveRun(activeRunId);
+      if (runData.exists) {
+        const runParts = [];
+        runParts.push(`Active Run ID: ${activeRunId}`);
+
+        if (runData.state) {
+          runParts.push(`Status: ${runData.state.status || 'IN_PROGRESS'}`);
+          if (runData.state.currentStep) {
+            runParts.push(`Current Step: ${runData.state.currentStep}`);
+          }
+          if (runData.state.lastSummary) {
+            runParts.push(`Latest Step Summary: ${runData.state.lastSummary}`);
+          }
+          if (runData.state.lastFailure) {
+            runParts.push(`Recent Failure Alert: ${runData.state.lastFailure.errorTrace} -> Recovery: ${runData.state.lastFailure.recoveryAction}`);
+          }
+        }
+
+        if (runData.plan && Array.isArray(runData.plan.subtasks) && runData.plan.subtasks.length > 0) {
+          const checklist = runData.plan.subtasks.map(t => {
+            const marker = t.status === 'completed' ? '[x]' : (t.status === 'in_progress' ? '[>]' : (t.status === 'failed' ? '[!]' : '[ ]'));
+            const summaryText = t.summary ? ` - ${t.summary}` : '';
+            return `${marker} ${t.name} (${t.status})${summaryText}`;
+          }).join('\n');
+          runParts.push(`Execution Plan Checklist:\n${checklist}`);
+        }
+
+        if (runData.artifacts && Array.isArray(runData.artifacts.items) && runData.artifacts.items.length > 0) {
+          const artifactList = runData.artifacts.items.map(a => `- ${a.name}: ${a.uri}`).join('\n');
+          runParts.push(`Artifact Pointers:\n${artifactList}`);
+        }
+
+        const runText = this.truncateToTokenLimit(runParts.join('\n\n'), quota.run);
+        sections.push(`--- ACTIVE TASK RUN STATE (40% Quota) ---\n${runText}`);
+      }
+    }
+
+   
+    if (this.store) {
+      const reflectionNodes = await this.store.listNodes('kiku/reflections/');
+      if (reflectionNodes.length > 0) {
+        const queryTokens = extractWordTokens(currentQuery);
+        const queryVector = buildTermFrequencyVector(queryTokens);
+
+        const scored = reflectionNodes.map(node => {
+          const content = node.content || {};
+          const textToMatch = [
+            node.domain || '',
+            content.issuePattern || '',
+            content.errorTrace || '',
+            content.recoveryAction || '',
+            content.lesson || '',
+            content.summary || ''
+          ].join(' ');
+
+          const nodeTokens = extractWordTokens(textToMatch);
+          const nodeVector = buildTermFrequencyVector(nodeTokens);
+          const similarity = computeCosineSimilarity(queryVector, nodeVector);
+
+          return {
+            node,
+            similarity,
+            confidence: Number(content.confidence) || 1.0,
+            score: similarity * (Number(content.confidence) || 1.0)
+          };
+        });
+
+        scored.sort((a, b) => b.score - a.score);
+
+       
+        const positiveScored = scored.filter(s => s.score > 0.05).slice(0, 4);
+        const topReflections = positiveScored.length > 0 ? positiveScored : scored.slice(0, 2);
+
+        const refLines = topReflections.map(item => {
+          const c = item.node.content || {};
+          const title = item.node.domain ? `[Reflection: ${item.node.domain}]` : '[Reflection]';
+          const issue = c.issuePattern ? `Problem: ${c.issuePattern}` : (c.errorTrace ? `Error: ${c.errorTrace}` : '');
+          const solution = c.recoveryAction ? `Solution: ${c.recoveryAction}` : (c.lesson ? `Lesson: ${c.lesson}` : (c.summary || ''));
+          return `${title}\n${issue}\n${solution}`.trim();
+        }).filter(Boolean);
+
+        if (refLines.length > 0) {
+          const refText = this.truncateToTokenLimit(refLines.join('\n\n'), quota.reflections);
+          sections.push(`--- EPISODIC REFLECTIONS & GOTCHAS (20% Quota) ---\n${refText}`);
+        }
+      }
+    }
+
+ 
+    const generalParts = [];
+    if (memory?.getRelevantFacts) {
+      const facts = currentQuery ? memory.getRelevantFacts(currentQuery, 6) : (memory.facts || []).slice(-6);
+      if (facts.length > 0) {
+        generalParts.push('Known facts:\n' + facts.map(f => `- ${f.content}`).join('\n'));
+      }
+    }
+
+    if (memory?.getTopTopics) {
+      const topTopics = memory.getTopTopics(3);
+      if (topTopics.length > 0) {
+        generalParts.push('Frequent topics: ' + topTopics.map(t => `${t.topic} (${t.count}x)`).join(', '));
+      }
+    }
+
+    if (generalParts.length > 0) {
+      const genText = this.truncateToTokenLimit(generalParts.join('\n\n'), quota.general);
+      sections.push(`--- GENERAL KNOWLEDGE & CONTEXT (20% Quota) ---\n${genText}`);
+    }
+
+    if (sections.length === 0) return '';
+
+    return `\n\n=== STATEFUL & SELF-REFLECTIVE MEMORY CONTEXT ===\n${sections.join('\n\n')}\n=== END MEMORY CONTEXT ===`;
+  }
+}