openaxies 1.0.0 → 1.0.2

package/bin/openaxis.js

@@ -33,14 +33,15 @@ for (let i = 0; i < consoleKeys.length; i++) {
 }
 
 const { waitUntilExit } = render(h(App, {}));
+// Keep the process alive until the Ink UI signals exit (e.g., via SIGINT).
+waitUntilExit();
 
 function cleanup() {
   if (debugBuffer.length > 0) {
     const logPath = path.join(process.cwd(), 'openaxies-debug.log');
     try {
       fs.writeFileSync(logPath, debugBuffer.join('\n') + '\n');
-    } catch (_) {
-    }
+    } catch (_) {}
   }
   process.exit(0);
 }
@@ -52,7 +53,6 @@ process.on('exit', function () {
     const logPath = path.join(process.cwd(), 'openaxies-debug.log');
     try {
       fs.writeFileSync(logPath, debugBuffer.join('\n') + '\n');
-    } catch (_) {
-    }
+    } catch (_) {}
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openaxies",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "private": false,
   "type": "module",
   "bin": {

package/src/App.js

@@ -1,13 +1,9 @@
 import React from 'react';
-import { Box, Text, useStdout } from 'ink';
+import { Box, Text, useInput, useStdout } from 'ink';
 import TextInput from 'ink-text-input';
 import { hex } from './config/theme.js';
 import { getModels, getModelById, DEFAULT_MODEL_ID } from './config/models.js';
 import { callModel } from './providers/index.js';
-import { Typography } from './components/ui/Typography.js';
-import { Separator } from './components/ui/Separator.js';
-import { ActivityItem } from './components/timeline/ActivityItem.js';
-import { TodoTracker } from './components/timeline/TodoTracker.js';
 
 const h = React.createElement;
 
@@ -19,6 +15,15 @@ const STARTUP_LOGO = [
   ' \u255a\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255d',
 ];
 
+const COMMANDS = [
+  { id: 'model', trigger: '/model', desc: 'Switch model' },
+  { id: 'thoughts', trigger: '/thoughts', desc: 'Toggle thinking' },
+  { id: 'resume', trigger: '/resume', desc: 'Re-run last query' },
+  { id: 'clear', trigger: '/clear', desc: 'Clear conversation' },
+  { id: 'help', trigger: '/help', desc: 'Show commands' },
+  { id: 'exit', trigger: '/exit', desc: 'Quit' },
+];
+
 export default function AppRoot() {
   const { stdout } = useStdout();
   const rows = stdout.rows || 24;
@@ -26,166 +31,336 @@ export default function AppRoot() {
 
   const [messages, setMessages] = React.useState([]);
   const [activeModel, setActiveModel] = React.useState(DEFAULT_MODEL_ID);
-  const [inputBuffer, setInputBuffer] = React.useState('');
-  const [streamingActive, setStreamingActive] = React.useState(false);
-  const [streamContent, setStreamContent] = React.useState('');
-  const [thoughtContent, setThoughtContent] = React.useState('');
-  const [thinkingElapsed, setThinkingElapsed] = React.useState(0);
-  const [isThinking, setIsThinking] = React.useState(false);
+  const [input, setInput] = React.useState('');
+  const [streaming, setStreaming] = React.useState(false);
+  const [streamText, setStreamText] = React.useState('');
+  const [thinkingActive, setThinkingActive] = React.useState(false);
+  const [thinkingText, setThinkingText] = React.useState('');
+  const [thinkElapsed, setThinkElapsed] = React.useState(0);
   const [startupDone, setStartupDone] = React.useState(false);
-  const [todos, setTodos] = React.useState([]);
+  const [showOverlay, setShowOverlay] = React.useState(false);
+  const [overlayIdx, setOverlayIdx] = React.useState(0);
+  const [showThought, setShowThought] = React.useState(true);
+  const [toolEvent, setToolEvent] = React.useState(null);
 
-  const abortControllerRef = React.useRef(null);
+  const abortRef = React.useRef(null);
+  const accumulatedRef = React.useRef('');
+  const lastQueryRef = React.useRef('');
 
   React.useEffect(() => {
-    let timer;
-    if (isThinking) {
-      timer = setInterval(() => {
-        setThinkingElapsed(prev => prev + 0.1);
-      }, 100);
-    }
-    return () => clearInterval(timer);
-  }, [isThinking]);
+    if (!thinkingActive) return;
+    const t = setInterval(() => setThinkElapsed(p => p + 0.1), 100);
+    return () => clearInterval(t);
+  }, [thinkingActive]);
 
   const model = getModelById(activeModel);
-  const modelLabel = model ? model.label : 'Unknown Model';
+  const modelLabel = model ? model.label : 'Unknown';
+
+  function stripThink(t) {
+    return showThought ? t : t.split('<think>').join('').split('</think>').join('');
+  }
 
   async function handleSubmit(text) {
-    if (!text || streamingActive) return;
-    if (!startupDone) setStartupDone(true);
-    
-    const userMsg = { role: 'user', content: text };
-    setMessages(prev => [...prev, userMsg]);
-    setInputBuffer('');
-    setStreamingActive(true);
-    setStreamContent('');
-    setThoughtContent('');
-    setThinkingElapsed(0);
-
-    abortControllerRef.current = new AbortController();
-    
+    const s = typeof text === 'string' ? text.trim() : '';
+    if (!s || streaming) return;
+    setStartupDone(true);
+    lastQueryRef.current = s;
+    accumulatedRef.current = '';
+    setStreaming(true);
+    setStreamText('');
+    setThinkingText('');
+    setThinkElapsed(0);
+    setToolEvent(null);
+    setMessages(p => [...p, { type: 'user', content: s }]);
+    setInput('');
+
+    const m = getModelById(activeModel);
+    if (!m) { setMessages(p => [...p, { type: 'assistant', content: 'No model loaded.' }]); setStreaming(false); return; }
+
+    const ac = new AbortController();
+    abortRef.current = ac;
+
     try {
-      const history = [...messages, userMsg];
-      const stream = callModel({ id: activeModel }, history, abortControllerRef.current.signal);
-      
-      for await (const event of stream) {
-        if (event.type === 'tool') {
-          setMessages(prev => [...prev, { type: 'tool', tool: event.tool, query: event.query }]);
-        } else if (event.type === 'token') {
-          const content = event.content;
-          if (content.includes('<think>')) {
-            setIsThinking(true);
-            setThoughtContent(prev => prev + content.replace('<think>', ''));
-          } else if (content.includes('</think>')) {
-            setIsThinking(false);
-            setThoughtContent(prev => prev + content.replace('</think>', ''));
-            setMessages(prev => [...prev, { type: 'thought', content: thoughtContent, elapsed: thinkingElapsed.toFixed(1) + 's' }]);
-          } else if (isThinking) {
-            setThoughtContent(prev => prev + content);
+      const history = [];
+      for (const msg of messages) {
+        if (msg.type === 'user') history.push({ role: 'user', content: msg.content });
+        else if (msg.type === 'assistant' || msg.type === 'thought') history.push({ role: 'assistant', content: msg.content });
+      }
+      history.push({ role: 'user', content: s });
+
+      let thinkOpen = false;
+
+      for await (const ev of callModel({ id: activeModel }, history, ac.signal)) {
+        if (ac.signal.aborted) break;
+
+        if (ev.type === 'tool') {
+          setToolEvent({ tool: ev.tool, query: ev.query, sites: ev.sites });
+          continue;
+        }
+
+        if (ev.type === 'token' || ev.type === 'thinking') {
+          const c = typeof ev.content === 'string' ? ev.content : '';
+          if (!c) continue;
+
+          // Track think state
+          if (c.includes('<think>')) thinkOpen = true;
+          accumulatedRef.current += c;
+
+          const clean = stripThink(accumulatedRef.current);
+          if (thinkOpen || accumulatedRef.current.includes('<think>')) {
+            const stillOpen = thinkOpen || !accumulatedRef.current.includes('</think>');
+            if (stillOpen) {
+              setThinkingActive(true);
+              setThinkingText(clean);
+              setStreamText('');
+            } else {
+              thinkOpen = false;
+              setThinkingActive(false);
+              setStreamText(clean);
+              setThinkingText('');
+            }
           } else {
-            setStreamContent(prev => prev + content);
+            setStreamText(clean);
+          }
+        }
+
+        if (ev.type === 'done' || ev.type === 'timeout') {
+          if (ev.type === 'timeout' && accumulatedRef.current) {
+            accumulatedRef.current += '\n\u2014 timed out \u2014';
           }
+          break;
         }
       }
-    } catch (e) {
-      setMessages(prev => [...prev, { type: 'assistant', content: 'Error connecting to model.' }]);
+    } catch (err) {
+      if (!ac.signal.aborted) {
+        setMessages(p => [...p, { type: 'assistant', content: 'Error: ' + (err.message || 'Connection failed') }]);
+      }
     } finally {
-      setStreamingActive(false);
-      setIsThinking(false);
-      if (streamContent) {
-        setMessages(prev => [...prev, { type: 'assistant', content: streamContent }]);
+      setStreaming(false);
+      setThinkingActive(false);
+      abortRef.current = null;
+      const final = accumulatedRef.current;
+      if (final) {
+        setMessages(p => [...p, { type: 'assistant', content: stripThink(final) }]);
       }
+      setStreamText('');
+      setThinkingText('');
     }
   }
 
-  const renderHeader = () => {
-    if (!startupDone) return null;
-    return h(Box, { height: 1, paddingLeft: 1, paddingRight: 1 },
-      h(Typography.Header, 'OpenAxies'),
-      h(Typography.Muted, ` \u2022 ${modelLabel}`),
-      h(Box, { flexGrow: 1 }),
-      h(Typography.Dim, 'local')
-    );
-  };
-
-  const renderFooter = () => {
-    return h(Box, { 
-      height: 1, 
-      paddingLeft: 1, 
-      paddingRight: 1, 
-      flexDirection: 'row', 
-      alignItems: 'center' 
-    },
-      h(Typography.Dim, 'esc interrupt \u2022 ctrl+t thoughts \u2022 ctrl+p models \u2022 ctrl+k commands'),
-      h(Box, { flexGrow: 1 }),
-      h(Typography.Muted, `${modelLabel.toLowerCase()} \u2022 local`)
-    );
-  };
-
-  const renderStartup = () => {
-    return h(Box, { 
-      flexDirection: 'column', 
-      paddingLeft: 1, 
-      paddingTop: 2,
-      backgroundColor: '#000000'
-    },
-      ...STARTUP_LOGO.map(line => h(Typography.Accent, line)),
-      h(Box, { height: 1 }),
-      h(Typography.Header, 'OpenAxies'),
-      h(Typography.Muted, 'local ai agent runtime'),
-      h(Box, { height: 2 }),
-      h(Typography.Dim, 'Press Enter to begin')
-    );
-  };
+  function cycleModel() {
+    const models = getModels();
+    setActiveModel(p => {
+      let found = false;
+      for (const m of models) {
+        if (found) return m.id;
+        if (m.id === p) found = true;
+      }
+      return models[0].id;
+    });
+  }
+
+  function handleCmd(item) {
+    if (!item) return;
+    const t = item.trigger;
+    if (t === '/exit') process.exit(0);
+    if (t === '/clear') setMessages([]);
+    if (t === '/model') cycleModel();
+    if (t === '/thoughts') setShowThought(p => !p);
+    if (t === '/resume') { const q = lastQueryRef.current; if (q && !streaming) handleSubmit(q); }
+    if (t === '/help') setMessages(p => [...p, { type: 'assistant', content: 'Commands: /help /clear /model /thoughts /resume /exit' }]);
+    setInput('');
+    setShowOverlay(false);
+    setOverlayIdx(0);
+  }
 
-  const renderTimeline = () => {
-    const events = [...messages];
-    if (isThinking) {
-      events.push({ type: 'thought', content: thoughtContent, elapsed: thinkingElapsed.toFixed(1) + 's' });
+  useInput((inp, key) => {
+    if (showOverlay) {
+      if (key.escape) { setShowOverlay(false); setInput(''); setOverlayIdx(0); return; }
+      if (key.upArrow) { setOverlayIdx(p => p > 0 ? p - 1 : COMMANDS.length - 1); return; }
+      if (key.downArrow) { setOverlayIdx(p => p < COMMANDS.length - 1 ? p + 1 : 0); return; }
+      if (key.return) { handleCmd(COMMANDS[overlayIdx]); return; }
+      return;
+    }
+    if (!startupDone && !streaming) {
+      if (key.return) { setStartupDone(true); setInput(''); return; }
+      return;
     }
-    if (streamingActive && streamContent) {
-      events.push({ type: 'assistant', content: streamContent });
+    if (key.escape) {
+      if (streaming && abortRef.current) { abortRef.current.abort(); setStreaming(false); setStreamText(''); setThinkingActive(false); }
+      return;
     }
+    if (key.ctrl) {
+      if (inp === 'c' || inp === 'C') { if (abortRef.current) abortRef.current.abort(); process.exit(0); }
+      if (inp === 't' || inp === 'T') { setShowThought(p => !p); return; }
+      if (inp === 'p' || inp === 'P') { cycleModel(); return; }
+      if (inp === 'r' || inp === 'R') { const q = lastQueryRef.current; if (q && !streaming) handleSubmit(q); return; }
+      if (inp === 'l' || inp === 'L') { setMessages([]); return; }
+      if (inp === 'k' || inp === 'K') { setInput('/'); setShowOverlay(true); setOverlayIdx(0); return; }
+    }
+  });
 
-    return h(Box, { 
-      flexGrow: 1, 
-      flexDirection: 'column', 
-      overflow: 'hidden',
-      paddingLeft: 0,
-      paddingRight: 0,
-    },
-      ...events.slice(-15).map((event, i) => h(ActivityItem, { key: i, event }))
-    );
-  };
-
-  return h(Box, { 
-    flexDirection: 'column', 
-    width: '100%', 
-    height: rows, 
-    overflow: 'hidden' 
-  },
-    renderStartup() && !startupDone ? renderStartup() : null,
-    startupDone && renderHeader(),
-    startupDone && h(Separator),
-    startupDone && renderTimeline(),
-    startupDone && h(Box, { height: 1 }, h(Separator)),
-    startupDone && h(Box, { 
-      height: 1, 
-      paddingLeft: 1, 
-      paddingRight: 1, 
-      flexDirection: 'row', 
-      alignItems: 'center' 
-    },
-      h(Typography.Accent, '▌ Ask OpenAxies'),
+  // Build timeline
+  const events = [];
+  for (const msg of messages) {
+    if (msg.type === 'user' || msg.type === 'assistant' || msg.type === 'thought') {
+      events.push(msg);
+    }
+  }
+
+  // Tool event
+  if (toolEvent && streaming) {
+    events.push({ type: 'tool', tool: toolEvent.tool, query: toolEvent.query });
+  }
+
+  // Live thinking
+  if (thinkingActive && thinkingText) {
+    events.push({ type: 'thought', content: thinkingText, elapsed: thinkElapsed.toFixed(1) + 's' });
+  }
+
+  // Live stream
+  if (streaming && streamText && !thinkingActive) {
+    events.push({ type: 'assistant', content: streamText });
+  }
+
+  const visible = events.slice(-20);
+
+  // Startup screen
+  if (!startupDone && messages.length === 0) {
+    return h(Box, { flexDirection: 'column', width: '100%', height: rows, overflow: 'hidden' },
+      ...STARTUP_LOGO.map((l, i) => h(Box, { key: 'sl' + i, height: 1, paddingLeft: 1 },
+        h(Text, { color: '#00BBFF', bold: true }, l)
+      )),
+      h(Box, { key: 'sp1', height: 1 }),
+      h(Box, { key: 'st1', height: 1, paddingLeft: 1 }, h(Text, { color: '#FFFFFF', bold: true }, 'OpenAxies')),
+      h(Box, { key: 'st2', height: 1, paddingLeft: 1 }, h(Text, { color: '#777788' }, 'local ai agent runtime')),
+      h(Box, { key: 'sp2', height: 1 }),
+      h(Box, { key: 'st3', height: 1, paddingLeft: 1 }, h(Text, { color: '#555577' }, 'Press Enter to begin')),
       h(Box, { flexGrow: 1 }),
-      h(TextInput, { 
-        value: inputBuffer, 
-        onChange: setInputBuffer, 
-        onSubmit: handleSubmit, 
-        focus: true, 
-        showCursor: true 
-      })
-    ),
-    startupDone && renderFooter()
+      h(Box, { key: 'foot', height: 1, paddingLeft: 1 }, h(Text, { color: '#333344' }, 'esc quit     enter begin')),
+    );
+  }
+
+  // Overlay
+  if (showOverlay) {
+    visible.unshift({ type: '_sep' });
+    visible.unshift({ type: '_overlay', idx: overlayIdx });
+  }
+
+  // No content yet after startup
+  if (visible.length === 0) {
+    visible.push({ type: '_sep' });
+    visible.push({ type: '_ready' });
+    visible.push({ type: '_sep' });
+  }
+
+  // Estimate lines
+  const HEADER_H = 1;
+  const SEP_H = 1;
+  const INPUT_H = 1;
+  const FOOTER_H = 1;
+  const fixed = HEADER_H + SEP_H + INPUT_H + FOOTER_H;
+  const maxLines = Math.max(5, rows - fixed);
+
+  function estLines(ev) {
+    if (ev.type === '_sep' || ev.type === '_ready' || ev.type === '_overlay') return 1;
+    if (ev.type === 'tool') return 1;
+    if (ev.type === 'user') return 2;
+    if (ev.type === 'thought') return 2;
+    return 1;
+  }
+
+  let totalEst = 0;
+  let showN = 0;
+  for (let i = visible.length - 1; i >= 0; i--) {
+    const l = estLines(visible[i]);
+    if (totalEst + l > maxLines) break;
+    totalEst += l;
+    showN = visible.length - i;
+  }
+  const show = visible.slice(visible.length - showN);
+
+  const els = [];
+  for (let i = 0; i < show.length; i++) {
+    const ev = show[i];
+    const k = 'e' + i;
+
+    if (ev.type === '_sep') {
+      els.push(h(Box, { key: k, height: 1 }, h(Text, { color: '#1A1A28' }, '\u2500'.repeat(cols))));
+    } else if (ev.type === '_ready') {
+      els.push(h(Box, { key: k, height: 1, paddingLeft: 1 }, h(Text, { color: '#00FF88', bold: true }, 'Ready')));
+    } else if (ev.type === '_overlay') {
+      els.push(h(Box, { key: k + 'h', height: 1, paddingLeft: 1 }, h(Text, { color: '#888899', bold: true }, 'Commands')));
+      for (let ci = 0; ci < COMMANDS.length; ci++) {
+        const c = COMMANDS[ci];
+        const sel = ci === ev.idx;
+        const prefix = sel ? '\u276F ' : '  ';
+        const col = sel ? hex.neonBlue : '#666688';
+        els.push(h(Box, { key: k + 'c' + ci, height: 1, paddingLeft: 2 },
+          h(Text, { color: col }, prefix + c.trigger),
+          h(Text, { color: '#444466' }, '  ' + (c.desc || ''))
+        ));
+      }
+    } else if (ev.type === 'user') {
+      els.push(h(Box, { key: k + 'h', height: 1, paddingLeft: 1 }, h(Text, { color: '#888899', bold: true }, 'You')));
+      els.push(h(Box, { key: k + 'c', height: 1, paddingLeft: 2 }, h(Text, { color: hex.neonBlue, wrap: 'wrap' }, ev.content)));
+    } else if (ev.type === 'assistant') {
+      els.push(h(Box, { key: k, height: 1, paddingLeft: 1 }, h(Text, { color: '#FFFFFF', wrap: 'wrap' }, ev.content)));
+    } else if (ev.type === 'thought') {
+      els.push(h(Box, { key: k + 'h', height: 1, paddingLeft: 1 },
+        h(Text, { color: '#FF9F43', bold: true }, '\u25CB Thinking \u2022 ' + (ev.elapsed || '0.0s'))
+      ));
+      els.push(h(Box, { key: k + 'c', height: 1, paddingLeft: 2 }, h(Text, { color: '#FF9F43', wrap: 'wrap' }, ev.content)));
+    } else if (ev.type === 'tool') {
+      els.push(h(Box, { key: k, height: 1, paddingLeft: 1 },
+        h(Text, { color: '#5B5B8A' }, '\u2500\u2500 ' + (ev.tool || 'tool') + (ev.query ? ' \u2014 ' + ev.query : ''))
+      ));
+    }
+  }
+
+  // Fill
+  while (els.length < maxLines) {
+    els.push(h(Box, { key: 'f' + els.length, height: 1 }));
+  }
+
+  // Header
+  const header = h(Box, { height: HEADER_H, flexShrink: 0, paddingLeft: 1, paddingRight: 1 },
+    h(Text, { color: '#00BBFF', bold: true }, 'OpenAxies'),
+    h(Text, { color: '#555577' }, ' \u2022 '),
+    h(Text, { color: '#FFFFFF' }, modelLabel),
+    h(Box, { flexGrow: 1 }),
+    h(Text, { color: '#666688' }, 'local'),
+  );
+
+  // Separator
+  const sepLine = h(Box, { height: SEP_H, flexShrink: 0 }, h(Text, { color: '#1A1A28' }, '\u2500'.repeat(cols)));
+
+  // Input
+  const inputLine = h(Box, { height: INPUT_H, flexShrink: 0, paddingLeft: 1, paddingRight: 1 },
+    h(Text, { color: hex.greenOnline }, '\u258C'),
+    h(Box, { width: 1 }),
+    h(TextInput, {
+      value: input,
+      onChange: setInput,
+      onSubmit: function (v) { if (typeof v === 'string' && v.trim() && !streaming) handleSubmit(v); },
+      placeholder: '',
+      focus: !showOverlay,
+      showCursor: true,
+    })
+  );
+
+  // Footer
+  const footer = h(Box, { height: FOOTER_H, flexShrink: 0, paddingLeft: 1, paddingRight: 1 },
+    h(Text, { color: '#444466' }, 'esc \u2248  ctrl+t  ctrl+p  ctrl+k'),
+    h(Box, { flexGrow: 1 }),
+    h(Text, { color: '#555577' }, (modelLabel.replace('OpenAxies ', '') || 'model').toLowerCase() + ' \u2022 local'),
+  );
+
+  return h(Box, { flexDirection: 'column', width: '100%', height: rows, overflow: 'hidden' },
+    header,
+    sepLine,
+    h(Box, { flexGrow: 1, flexDirection: 'column', overflow: 'hidden' }, ...els),
+    inputLine,
+    footer,
   );
 }