@mylesiyabor/claudex 0.1.0 → 0.1.1

package/lib/native-agents.js

@@ -107,7 +107,7 @@ function runProcess(command, args, cwd, handlers = {}) {
   handlers.onStart?.();
 
   const promise = new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
+    child = spawn(command, args, {
       cwd,
       env: process.env,
       stdio: ['ignore', 'pipe', 'pipe'],

package/lib/session-store.js

@@ -1,4 +1,4 @@
-import { appendFileSync, createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { appendFileSync, copyFileSync, createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
@@ -97,6 +97,8 @@ export async function importClaudeSessionToCodex({ session, cwd = process.cwd()
     updatedAt: lastTimestamp || createdAt,
   });
 
+  syncClaudeMemoriesToCodex();
+
   return {
     sessionId,
     sessionPath,
@@ -107,6 +109,29 @@ export async function importClaudeSessionToCodex({ session, cwd = process.cwd()
   };
 }
 
+export function syncClaudeMemoriesToCodex() {
+  const targetRoot = join(CODEX_HOME, 'memories', 'claude');
+  mkdirSync(targetRoot, { recursive: true });
+
+  let copied = 0;
+  const sources = [
+    { root: join(homedir(), '.claude', 'memory'), prefix: 'global' },
+    { root: CLAUDE_PROJECTS, prefix: 'projects' },
+  ];
+
+  for (const source of sources) {
+    copied += copyMarkdownTree(source.root, join(targetRoot, source.prefix));
+  }
+
+  writeFileSync(
+    join(targetRoot, 'README.md'),
+    `# Claude Memories\n\nImported from ~/.claude on ${new Date().toISOString()}.\n\nFiles copied: ${copied}\n`,
+    'utf8',
+  );
+
+  return copied;
+}
+
 function resolveClaudeSessionPath(sessionRef) {
   if (sessionRef.endsWith('.jsonl')) {
     const explicitPath = isAbsolute(sessionRef) ? sessionRef : resolve(process.cwd(), sessionRef);
@@ -196,6 +221,37 @@ function listClaudeSessions(limit) {
     .slice(0, limit);
 }
 
+function copyMarkdownTree(sourceDir, targetDir) {
+  if (!existsSync(sourceDir)) return 0;
+
+  let copied = 0;
+  const stack = [{ sourceDir, targetDir }];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(current.sourceDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const src = join(current.sourceDir, entry.name);
+      const dest = join(current.targetDir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push({ sourceDir: src, targetDir: dest });
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith('.md')) continue;
+      mkdirSync(current.targetDir, { recursive: true });
+      copyFileSync(src, dest);
+      copied += 1;
+    }
+  }
+
+  return copied;
+}
+
 function readClaudeSessionSummary(path) {
   let title = '(untitled)';
   let updatedAt = null;

package/lib/ui.js

@@ -1,15 +1,17 @@
-import React, { useMemo, useState } from 'react';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
 import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import Spinner from 'ink-spinner';
 import { MessageComponent } from 'terminal-chat-ui';
-import { sendClaudePrompt, sendCodexPrompt } from './native-agents.js';
-import { hasCodexSession, importClaudeSessionToCodex, listResumeSessions } from './session-store.js';
+import { startClaudePrompt, startCodexPrompt } from './native-agents.js';
+import { hasCodexSession, importClaudeSessionToCodex, listResumeSessions, syncClaudeMemoriesToCodex } from './session-store.js';
 
 const HELP_LINES = [
   '/use claude | /use codex',
   '/resume --cli <claude|codex> <session-id-or-claude-jsonl-path>',
   '/ids',
   '/menu',
+  '/sync-memory',
+  '/stop',
   '/clear',
   '/help',
   '/exit',
@@ -24,6 +26,11 @@ export function ClauDexApp({ initialAgent = 'codex', initialSessions, initialNot
     messageOf('system', initialNotice || 'Type /help for commands.'),
   ]);
   const [busy, setBusy] = useState(false);
+  const [queuedMessages, setQueuedMessages] = useState([]);
+  const [activity, setActivity] = useState('idle');
+  const [elapsedSec, setElapsedSec] = useState(0);
+  const activeRunRef = useRef(null);
+  const startedAtRef = useRef(null);
   const [menu, setMenu] = useState({ open: false, selected: 0, items: [] });
 
   const transcriptHeight = Math.max(8, (stdout?.rows || 24) - 7);
@@ -34,9 +41,32 @@ export function ClauDexApp({ initialAgent = 'codex', initialSessions, initialNot
     return `active=${agent} claude=${claudeId} codex=${codexId}`;
   }, [agent, sessions]);
 
+  useEffect(() => {
+    if (!busy) return undefined;
+    const timer = setInterval(() => {
+      if (startedAtRef.current) {
+        setElapsedSec(Math.max(0, Math.floor((Date.now() - startedAtRef.current) / 1000)));
+      }
+    }, 250);
+    return () => clearInterval(timer);
+  }, [busy]);
+
+  useInput((input, key) => {
+    if (key.escape && busy && activeRunRef.current) {
+      activeRunRef.current.interrupt();
+      setActivity('interrupt requested');
+    }
+  });
+
   async function submit(value) {
     const text = value.trim();
-    if (!text || busy) return;
+    if (!text) return;
+
+    if (busy && !text.startsWith('/')) {
+      setQueuedMessages((current) => [...current, { agent, text }]);
+      setMessages((current) => [...current, messageOf('system', `Queued for ${agent}: ${text}`)]);
+      return;
+    }
 
     setMessages((current) => [...current, messageOf('user', `[to ${agent}] ${text}`)]);
 
@@ -47,34 +77,60 @@ export function ClauDexApp({ initialAgent = 'codex', initialSessions, initialNot
         setSessions,
         setMessages,
         setMenu,
+        interrupt: () => activeRunRef.current?.interrupt(),
+        setActivity,
         exit,
       });
       return;
     }
 
+    await runPrompt(agent, text);
+  }
+
+  async function runPrompt(targetAgent, text) {
     setBusy(true);
+    setElapsedSec(0);
+    setActivity(`${targetAgent} starting`);
+    startedAtRef.current = Date.now();
+
+    const run = targetAgent === 'claude'
+      ? startClaudePrompt({
+        prompt: text,
+        sessionId: sessions.claude,
+        cwd: process.cwd(),
+        onActivity: setActivity,
+      })
+      : startCodexPrompt({
+        prompt: text,
+        sessionId: sessions.codex,
+        cwd: process.cwd(),
+        onActivity: setActivity,
+      });
+
+    activeRunRef.current = run;
+
     try {
-      if (agent === 'claude') {
-        const result = await sendClaudePrompt({
-          prompt: text,
-          sessionId: sessions.claude,
-          cwd: process.cwd(),
-        });
-        setSessions((current) => ({ ...current, claude: result.sessionId }));
-        setMessages((current) => [...current, messageOf('assistant', `[claude]\n${result.text}`)]);
-      } else {
-        const result = await sendCodexPrompt({
-          prompt: text,
-          sessionId: sessions.codex,
-          cwd: process.cwd(),
-        });
-        setSessions((current) => ({ ...current, codex: result.sessionId }));
-        setMessages((current) => [...current, messageOf('assistant', `[codex]\n${result.text}`)]);
-      }
+      const result = await run.promise;
+      setSessions((current) => ({ ...current, [targetAgent]: result.sessionId }));
+      setMessages((current) => [...current, messageOf('assistant', `[${targetAgent}]\n${result.text}`)]);
     } catch (error) {
       setMessages((current) => [...current, messageOf('error', error?.message || String(error))]);
     } finally {
+      activeRunRef.current = null;
+      startedAtRef.current = null;
       setBusy(false);
+      setElapsedSec(0);
+      setActivity('idle');
+      setQueuedMessages((current) => {
+        const [next, ...rest] = current;
+        if (next) {
+          setTimeout(() => {
+            setMessages((existing) => [...existing, messageOf('user', `[to ${next.agent}] ${next.text}`)]);
+            runPrompt(next.agent, next.text);
+          }, 0);
+        }
+        return rest;
+      });
     }
   }
 
@@ -91,7 +147,13 @@ export function ClauDexApp({ initialAgent = 'codex', initialSessions, initialNot
       },
       React.createElement(Text, { color: accent, bold: true }, 'ClauDex'),
       React.createElement(Text, { dimColor: true }, status),
-      React.createElement(Text, { color: busy ? 'yellow' : 'green' }, busy ? 'running' : 'ready'),
+      React.createElement(
+        Text,
+        { color: busy ? 'yellow' : 'green' },
+        busy
+          ? `Working (${formatElapsed(elapsedSec)} • esc to interrupt • q:${queuedMessages.length})`
+          : `ready • q:${queuedMessages.length}`,
+      ),
     ),
     React.createElement(
       Box,
@@ -125,7 +187,7 @@ export function ClauDexApp({ initialAgent = 'codex', initialSessions, initialNot
           React.createElement(Text, { color: accent }, 'agent '),
           React.createElement(Text, { color: accent },
             React.createElement(Spinner, { type: 'dots' }),
-            ' thinking...',
+            ` ${activity}`,
           ),
         )
         : null,
@@ -148,9 +210,9 @@ export function ClauDexApp({ initialAgent = 'codex', initialSessions, initialNot
       },
       React.createElement(Text, { color: accent, bold: true }, `${agent} › `),
       React.createElement(Composer, {
-        placeholder: busy ? 'waiting for response...' : 'message or /help',
+        placeholder: busy ? 'queue next message or /stop' : 'message or /help',
         onSubmit: submit,
-        disabled: busy || menu.open,
+        disabled: menu.open,
       }),
     ),
   );
@@ -192,6 +254,19 @@ async function runCommand(text, ctx) {
     return;
   }
 
+  if (command === '/sync-memory') {
+    const copied = syncClaudeMemoriesToCodex();
+    ctx.setMessages((current) => [...current, messageOf('system', `Synced ${copied} Claude memory markdown files into ~/.codex/memories/claude`)]);
+    return;
+  }
+
+  if (command === '/stop') {
+    ctx.interrupt?.();
+    ctx.setActivity?.('interrupt requested');
+    ctx.setMessages((current) => [...current, messageOf('system', 'Interrupt requested.')]);
+    return;
+  }
+
   if (command === '/use') {
     const next = args[0];
     if (!['claude', 'codex'].includes(next)) {
@@ -281,6 +356,12 @@ function messageOf(role, content) {
   };
 }
 
+function formatElapsed(totalSeconds) {
+  const mins = String(Math.floor(totalSeconds / 60));
+  const secs = String(totalSeconds % 60).padStart(2, '0');
+  return `${mins}:${secs}`;
+}
+
 function Composer({ placeholder, onSubmit, disabled }) {
   const [value, setValue] = useState('');
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@mylesiyabor/claudex",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Ink TUI for chatting with Claude Code and Codex CLI from one switchable interface.",
   "type": "module",
   "bin": {
-    "claudex": "./bin/claudex.js"
+    "claudex": "bin/claudex.js"
   },
   "engines": {
     "node": ">=20.0.0"