kiku-agent 1.2.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 };
+}