kiku-agent 1.3.0 → 1.3.1

package/server/agent/ink/main.jsx

@@ -0,0 +1,195 @@
+import React from 'react';
+import { render } from 'ink';
+import '../youtubeAuth.js';
+import { App } from './App.jsx';
+import { KikuAgent } from '../agentCore.js';
+import { LMStudioClient } from '../llmClient.js';
+import { toolsSchema } from '../tools.js';
+import { config } from '../config.js';
+import { COMMAND_DEFINITIONS } from '../commandRegistry.js';
+import { C, UI_ICONS } from '../ui.js';
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { PACKAGE_VERSION } from '../version.js';
+
+function parseCliArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    query: null,
+    model: 'google/gemma-4-e4b',
+    url: null,
+    showTools: false,
+    showStats: false,
+    thinking: 'show',
+    verbose: false,
+    help: false,
+    version: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--version' || arg === '-V') options.version = true;
+    else if (arg === '--tools' || arg === '-t') options.showTools = true;
+    else if (arg === '--stats' || arg === '-s') options.showStats = true;
+    else if (arg === '--verbose' || arg === '-v') { options.verbose = true; options.thinking = 'show'; }
+    else if (arg === '--thinking') options.thinking = args[++i] || 'show';
+    else if (arg === '--model' || arg === '-m') options.model = args[++i] || options.model;
+    else if (arg === '--url' || arg === '-u') options.url = args[++i];
+    else if (arg === '--query' || arg === '-q') options.query = args[++i];
+    else if (!arg.startsWith('-') && !options.query) { options.query = args.slice(i).join(' '); break; }
+  }
+  return options;
+}
+
+async function waitForLMStudio(baseUrl, timeoutMs = 30000) {
+  const client = new LMStudioClient({ baseUrl });
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const health = await client.checkConnection();
+    if (health.connected) return health;
+    await new Promise(r => setTimeout(r, 1000));
+  }
+  return null;
+}
+
+async function attemptAutoStartLMStudio(baseUrl, model) {
+  const isWin = process.platform === 'win32';
+  const isMac = process.platform === 'darwin';
+
+  const candidates = isWin
+    ? [
+        `${process.env.LOCALAPPDATA}\\LM Studio\\LM Studio.exe`,
+        `${process.env.LOCALAPPDATA}\\Programs\\LM Studio\\LM Studio.exe`,
+        'C:\\Program Files\\LM Studio\\LM Studio.exe'
+      ]
+    : isMac
+      ? ['/Applications/LM Studio.app/Contents/MacOS/LM Studio']
+      : ['lmstudio', '/usr/local/bin/lmstudio', '/opt/lmstudio/bin/lmstudio'];
+
+  const exe = candidates.find(p => {
+    if (p.includes('/') || p.includes('\\')) {
+      try { return existsSync(p); } catch { return false; }
+    }
+    return true;
+  });
+
+  if (!exe) return null;
+
+  try {
+    let port = '1234';
+    try { const parsedUrl = new URL(baseUrl); if (parsedUrl.port) port = parsedUrl.port; } catch {}
+
+    const child = spawn(exe, isWin
+      ? ['--model', model, '--serve', '--port', port]
+      : ['serve', '--model', model, '--port', port],
+      { detached: true, stdio: 'ignore', windowsHide: true }
+    );
+    child.unref();
+
+    return await waitForLMStudio(baseUrl, 45000);
+  } catch { return null; }
+}
+
+function printHelpText() {
+  const commands = COMMAND_DEFINITIONS
+    .map(command => `  ${C.emerald}${command.usage.padEnd(30)}${C.reset} ${command.desc}`)
+    .join('\n');
+  console.log(`\n  ${C.bold}${C.gold}${UI_ICONS.help} Kiku AI Agent — ${COMMAND_DEFINITIONS.length} Commands${C.reset}\n${commands}\n  ${C.dim}Tip: Press [Tab] for auto-completion.${C.reset}\n`);
+}
+
+async function printStatsText() {
+  const { executeTool } = await import('../tools.js');
+  const result = await executeTool('get_system_stats', {});
+  const s = result.stats;
+  console.log(JSON.stringify(s, null, 2));
+}
+
+async function main() {
+  const opts = parseCliArgs();
+
+  if (opts.version) { console.log(PACKAGE_VERSION); process.exit(0); }
+  if (opts.help) { printHelpText(); process.exit(0); }
+  if (opts.showStats) { await printStatsText(); process.exit(0); }
+
+  if (opts.showTools) {
+    console.log(`\n  ${C.bold}${C.sakura}Tools (${toolsSchema.length})${C.reset}\n`);
+    for (const [i, t] of toolsSchema.entries()) {
+      console.log(`  ${C.gold}${String(i + 1).padStart(2)}${C.reset} ${C.cyberCyan}${t.function.name}${C.reset} — ${C.dim}${t.function.description.slice(0, 60)}${C.reset}`);
+    }
+    process.exit(0);
+  }
+
+  const baseUrl = opts.url || config.lmStudio.baseUrl;
+  const client = new LMStudioClient({ baseUrl, model: opts.model });
+  const health = await client.checkConnection();
+
+  if (!health.connected) {
+    console.log(`  ${C.amber}!! LM Studio offline${C.reset}`);
+    console.log(`  ${C.dim}• ${health.error}${C.reset}\n`);
+
+    const autoHealth = await attemptAutoStartLMStudio(baseUrl, opts.model || config.lmStudio.model);
+    if (autoHealth) {
+      console.log(`  ${C.emerald}[OK] LM Studio started.${C.reset}\n`);
+    } else {
+      console.log(`  ${C.sakura}Setup: Open LM Studio → load google/gemma-4-e4b → Start Server :1234${C.reset}\n`);
+      process.exit(1);
+    }
+  }
+
+  const agent = new KikuAgent({
+    baseUrl,
+    model: health.activeModel || opts.model,
+    thinkingMode: opts.thinking,
+  });
+
+  await agent._ready;
+
+  if (opts.query) {
+    const { executeTool: execTool } = await import('../tools.js');
+    const { sanitizeQuery } = await import('../sanitizer.js');
+    const { sanitized } = sanitizeQuery(opts.query);
+    const prompt = sanitized || opts.query;
+
+    console.log(`  ${C.bold}${C.gold}QUERY${C.reset} ${prompt}\n`);
+
+    await agent.ask(prompt, {
+      onReasoningStart: () => process.stdout.write('  THINKING '),
+      onReasoningDelta: (chunk) => process.stdout.write(chunk),
+      onReasoningEnd: () => process.stdout.write('\n'),
+      onToolStart: (name) => process.stdout.write(`  [RUNNING] ${name}... `),
+      onToolResult: () => process.stdout.write(`[OK]\n`),
+      onTokenDelta: (chunk) => process.stdout.write(chunk),
+      onFinalAnswer: () => {},
+      onError: (err) => console.error(`\n  [ERROR] ${err.message}`),
+    });
+    process.exit(0);
+  }
+
+  const helpFn = (sub) => { printHelpText(); };
+  const adFn = () => { console.log(`  ${UI_ICONS.sponsor} SPONSOR  DashSecurity — https://dashsecurity.kpltgroup.com/`); };
+
+  const { waitUntilExit } = render(
+    <App
+      agent={agent}
+      client={client}
+      baseUrl={baseUrl}
+      printHelp={helpFn}
+      printAd={adFn}
+    />,
+    {
+      exitOnCtrlC: true,
+      patchConsole: false,
+    }
+  );
+
+  await waitUntilExit;
+
+  try { await agent.endSession(); } catch {}
+  console.log('\n  Session archived. Goodbye. (鞠躬 ~ 谢谢!)\n');
+}
+
+main().catch(err => {
+  console.error(`\n  ${C.red}Fatal: ${err.message}${C.reset}\n`);
+  process.exit(1);
+});

package/server/agent/ink/useEventBus.js

@@ -0,0 +1,218 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { eventBus } from '../eventBus.js';
+
+export function useEvent(eventName, initialValue = null) {
+  const [value, setValue] = useState(initialValue);
+
+  useEffect(() => {
+    const unsub = eventBus.on(eventName, (data) => {
+      setValue(data);
+    });
+    return unsub;
+  }, [eventName]);
+
+  return value;
+}
+
+export function useEvents(eventMap) {
+  const [state, setState] = useState(() => {
+    const init = {};
+    for (const [key] of Object.entries(eventMap)) {
+      init[key] = null;
+    }
+    return init;
+  });
+
+  useEffect(() => {
+    const unsubs = [];
+    for (const [key, eventName] of Object.entries(eventMap)) {
+      const unsub = eventBus.on(eventName, (data) => {
+        setState(prev => ({ ...prev, [key]: data }));
+      });
+      unsubs.push(unsub);
+    }
+    return () => unsubs.forEach(u => u());
+  }, []);
+
+  return state;
+}
+
+export function useEmit() {
+  return useCallback((eventName, data) => {
+    eventBus.emit(eventName, data);
+  }, []);
+}
+
+export function useAgentState() {
+  const [agentState, setAgentState] = useState({
+    state: 'IDLE',
+    label: 'Idle',
+    toolName: null,
+    elapsedMs: 0,
+    isProcessing: false,
+  });
+
+  useEffect(() => {
+    const unsubs = [
+      eventBus.on('agent:state:change', (data) => {
+        setAgentState({
+          state: data.state || 'IDLE',
+          label: data.label || 'Idle',
+          toolName: data.state === 'FETCHING_TOOL' ? data.label?.replace('Tool: ', '') : null,
+          elapsedMs: 0,
+          isProcessing: data.state !== 'IDLE' && data.state !== 'COMPLETE',
+        });
+      }),
+    ];
+    return () => unsubs.forEach(u => u());
+  }, []);
+
+  return agentState;
+}
+
+export function useStreamingText() {
+  const [text, setText] = useState('');
+  const [isStreaming, setIsStreaming] = useState(false);
+
+  useEffect(() => {
+    const unsubs = [
+      eventBus.on('agent:token:start', () => {
+        setIsStreaming(true);
+        setText('');
+      }),
+      eventBus.on('agent:token:delta', (data) => {
+        setText(prev => prev + (data?.chunk || ''));
+      }),
+      eventBus.on('agent:final:answer', () => {
+        setIsStreaming(false);
+      }),
+    ];
+    return () => unsubs.forEach(u => u());
+  }, []);
+
+  return { text, isStreaming, reset: () => setText('') };
+}
+
+export function useThinking() {
+  const [thinking, setThinking] = useState('');
+  const [duration, setDuration] = useState(0);
+  const [isActive, setIsActive] = useState(false);
+  const startTimeRef = useRef(null);
+
+  useEffect(() => {
+    const unsubs = [
+      eventBus.on('agent:reasoning:start', () => {
+        setIsActive(true);
+        setThinking('');
+        startTimeRef.current = Date.now();
+      }),
+      eventBus.on('agent:reasoning:delta', (data) => {
+        setThinking(prev => prev + (data?.chunk || ''));
+      }),
+      eventBus.on('agent:reasoning:end', () => {
+        setIsActive(false);
+        if (startTimeRef.current) {
+          setDuration(((Date.now() - startTimeRef.current) / 1000).toFixed(1));
+        }
+      }),
+    ];
+    return () => unsubs.forEach(u => u());
+  }, []);
+
+  return { thinking, duration, isActive };
+}
+
+export function useToolResults() {
+  const [tools, setTools] = useState([]);
+
+  useEffect(() => {
+    const onToolStart = (data) => {
+      const toolName = data && data.toolName ? data.toolName : '?';
+      const toolArgs = data && data.args ? data.args : {};
+      setTools((prev) => [...prev, {
+        name: toolName,
+        args: toolArgs,
+        result: null,
+        duration: 0,
+        status: 'running',
+        id: Date.now(),
+      }]);
+    };
+
+    const onToolResult = (data) => {
+      const toolName = data && data.toolName ? data.toolName : '';
+      const result = data && data.result ? data.result : null;
+      const durationMs = data && data.durationMs ? data.durationMs : 0;
+      const isError = result && result.status === 'error';
+      setTools((prev) => prev.map((t) => {
+        if (t.status === 'running' && t.name === toolName) {
+          return Object.assign({}, t, {
+            result: result,
+            duration: durationMs,
+            status: isError ? 'error' : 'done',
+          });
+        }
+        return t;
+      }));
+    };
+
+    const unsub1 = eventBus.on('agent:tool:start', onToolStart);
+    const unsub2 = eventBus.on('agent:tool:result', onToolResult);
+    return function cleanup() {
+      unsub1();
+      unsub2();
+    };
+  }, []);
+
+  const clearTools = useCallback(() => setTools([]), []);
+
+  return { tools: tools, clearTools: clearTools };
+}
+
+export function useTaskPlan() {
+  const [plan, setPlan] = useState(null);
+
+  useEffect(() => {
+    const onStart = (data) => {
+      if (data?.steps) {
+        setPlan({
+          planId: data.planId,
+          question: data.question,
+          steps: data.steps,
+          isActive: true,
+          startTime: Date.now(),
+        });
+      }
+    };
+
+    const onStepUpdate = (data) => {
+      setPlan(prev => {
+        if (!prev) return prev;
+        const updatedSteps = prev.steps.map(s => {
+          if (s.id === data.stepId) {
+            return { ...s, state: data.state, label: data.label || s.label };
+          }
+          return s;
+        });
+        return { ...prev, steps: updatedSteps };
+      });
+    };
+
+    const onComplete = () => {
+      setPlan(prev => prev ? { ...prev, isActive: false } : null);
+    };
+
+    const unsubs = [
+      eventBus.on('agent:plan:start', onStart),
+      eventBus.on('agent:plan:step:update', onStepUpdate),
+      eventBus.on('agent:plan:complete', onComplete),
+      eventBus.on('agent:final:answer', () => setPlan(null)),
+    ];
+
+    return () => unsubs.forEach(u => u());
+  }, []);
+
+  const clearPlan = useCallback(() => setPlan(null), []);
+
+  return { plan, clearPlan };
+}

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 ===`;
+  }
+}