@mylesiyabor/claudex 0.1.0

package/README.md

@@ -0,0 +1,43 @@
+# claudex
+
+Ink TUI that lets you chat through either native `claude` or native `codex`, switch the active backend mid-thread, and import Claude JSONL sessions into Codex sessions.
+
+## Install
+
+```bash
+cd /Users/myles/Development/Repos/claudex
+npm install
+npm link
+```
+
+## Start
+
+```bash
+claudex
+claudex --cli claude
+claudex resume --cli claude 22ef532e-636f-4666-bf17-ccd272f8877d
+claudex resume --cli codex ca36d796-b8cb-46c9-b0d1-6de1d8480dba
+```
+
+If you pass a Claude session ID to `claudex resume --cli codex <session>`, it will import that Claude transcript into a new Codex rollout file and then open the Codex side.
+
+## In-App Commands
+
+```text
+/use claude
+/use codex
+/resume --cli claude <session-id>
+/resume --cli codex <session-id-or-claude-jsonl-path>
+/ids
+/clear
+/help
+/exit
+```
+
+## One-Shot Import
+
+```bash
+claudex import-claude 22ef532e-636f-4666-bf17-ccd272f8877d
+```
+
+This prints the generated Codex session ID and writes a rollout file under `~/.codex/sessions/YYYY/MM/DD/`.

package/bin/claudex.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import React from 'react';
+import { render } from 'ink';
+import { ClauDexApp } from '../lib/ui.js';
+import { hasCodexSession, importClaudeSessionToCodex } from '../lib/session-store.js';
+
+const [, , command, ...args] = process.argv;
+
+async function main() {
+  if (command === 'import-claude') {
+    const session = args[0] || valueAfter(args, '--session');
+    if (!session) {
+      console.error('Usage: claudex import-claude <claude-session-id-or-jsonl-path>');
+      process.exit(1);
+    }
+
+    const result = await importClaudeSessionToCodex({ session, cwd: process.cwd() });
+    console.log(result.sessionId);
+    console.error(`Codex session file: ${result.sessionPath}`);
+    console.error(`Thread: ${result.threadName}`);
+    console.error(`Imported ${result.userMessages} user messages and ${result.assistantMessages} assistant messages`);
+    process.exit(0);
+  }
+
+  const startup = await buildStartupState(command, args);
+  render(React.createElement(ClauDexApp, startup));
+}
+
+async function buildStartupState(commandName, values) {
+  if (commandName === 'resume') {
+    const agent = valueAfter(values, '--cli');
+    const session = firstPositional(values, new Set(['--cli']));
+
+    if (!agent || !session || !['claude', 'codex'].includes(agent)) {
+      console.error('Usage: claudex resume --cli <claude|codex> <session-id-or-claude-jsonl-path>');
+      process.exit(1);
+    }
+
+    if (agent === 'claude') {
+      return {
+        initialAgent: 'claude',
+        initialSessions: { claude: session, codex: null },
+        initialNotice: `Resuming Claude session ${session}`,
+      };
+    }
+
+    if (hasCodexSession(session)) {
+      return {
+        initialAgent: 'codex',
+        initialSessions: { claude: null, codex: session },
+        initialNotice: `Resuming Codex session ${session}`,
+      };
+    }
+
+    const imported = await importClaudeSessionToCodex({ session, cwd: process.cwd() });
+    return {
+      initialAgent: 'codex',
+      initialSessions: { claude: session, codex: imported.sessionId },
+      initialNotice: `Imported Claude ${session} -> Codex ${imported.sessionId}`,
+    };
+  }
+
+  const agent = valueAfter([commandName, ...values].filter(Boolean), '--cli') || 'codex';
+  return {
+    initialAgent: ['claude', 'codex'].includes(agent) ? agent : 'codex',
+    initialSessions: { claude: null, codex: null },
+    initialNotice: 'Type /help for commands, /use claude or /use codex to swap backends.',
+  };
+}
+
+function valueAfter(values, flag) {
+  const index = values.indexOf(flag);
+  return index >= 0 ? values[index + 1] : undefined;
+}
+
+function firstPositional(values, flagsWithValues = new Set()) {
+  for (let i = 0; i < values.length; i += 1) {
+    const value = values[i];
+    if (flagsWithValues.has(value)) {
+      i += 1;
+      continue;
+    }
+    if (!value.startsWith('-')) return value;
+  }
+  return undefined;
+}
+
+main().catch((error) => {
+  console.error(error?.stack || error?.message || String(error));
+  process.exit(1);
+});

package/lib/native-agents.js

@@ -0,0 +1,261 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+
+export function startClaudePrompt({ prompt, sessionId, cwd, onActivity }) {
+  const nextSessionId = sessionId || randomUUID();
+  const args = sessionId
+    ? ['-p', '--output-format', 'json', '--resume', sessionId, prompt]
+    : ['-p', '--output-format', 'json', '--session-id', nextSessionId, prompt];
+
+  return {
+    ...runProcess('claude', args, cwd, {
+      onStdoutLine: () => onActivity?.('claude response received'),
+      onStart: () => onActivity?.('claude thinking'),
+      onSpawn: () => onActivity?.('claude process started'),
+      parseResult: ({ stdout, stderr, code, interrupted }) => {
+        const parsed = parseJsonMaybe(stdout);
+        if (interrupted) {
+          return {
+            sessionId: parsed?.session_id || parsed?.sessionId || nextSessionId,
+            text: 'Interrupted.',
+            interrupted: true,
+          };
+        }
+        if (parsed?.is_error) {
+          throw new Error(parsed.result || parsed.error || 'Claude returned an error');
+        }
+        if (code !== 0) {
+          throw new Error((stderr || renderClaudeResponse(parsed, stdout) || `claude exited with ${code}`).trim());
+        }
+        return {
+          sessionId: parsed?.session_id || parsed?.sessionId || nextSessionId,
+          text: renderClaudeResponse(parsed, stdout),
+          interrupted: false,
+        };
+      },
+    }),
+  };
+}
+
+export function startCodexPrompt({ prompt, sessionId, cwd, onActivity }) {
+  const args = [
+    'exec',
+    '-C',
+    cwd,
+    '--json',
+    '--dangerously-bypass-approvals-and-sandbox',
+  ];
+  if (!isGitRepo(cwd)) {
+    args.push('--skip-git-repo-check');
+  }
+  if (sessionId) {
+    args.push('resume', sessionId, prompt);
+  } else {
+    args.push(prompt);
+  }
+
+  return {
+    ...runProcess('codex', args, cwd, {
+      onStart: () => onActivity?.('codex thinking'),
+      onSpawn: () => onActivity?.('codex process started'),
+      onStdoutLine: (line) => emitCodexActivity(line, onActivity),
+      parseResult: ({ stdout, stderr, code, interrupted }) => {
+        const parsed = parseCodexJsonl(stdout);
+        if (interrupted) {
+          return {
+            sessionId: parsed.sessionId || sessionId,
+            text: `${parsed.text}\n\nInterrupted.`.trim(),
+            interrupted: true,
+          };
+        }
+        if (code !== 0) {
+          throw new Error((stderr || parsed.text || stdout || `codex exited with ${code}`).trim());
+        }
+        return {
+          sessionId: parsed.sessionId || sessionId,
+          text: parsed.text || '(no output)',
+          interrupted: false,
+        };
+      },
+    }),
+  };
+}
+
+export async function sendClaudePrompt(options) {
+  const run = startClaudePrompt(options);
+  return run.promise;
+}
+
+export async function sendCodexPrompt(options) {
+  const run = startCodexPrompt(options);
+  return run.promise;
+}
+
+function isGitRepo(cwd) {
+  const result = spawnSync('git', ['-C', cwd, 'rev-parse', '--is-inside-work-tree'], {
+    env: process.env,
+    stdio: 'ignore',
+  });
+  return result.status === 0;
+}
+
+function runProcess(command, args, cwd, handlers = {}) {
+  let child = null;
+  let interrupted = false;
+  let stdoutBuffer = '';
+
+  handlers.onStart?.();
+
+  const promise = new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    handlers.onSpawn?.(child.pid);
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString('utf8');
+      stdout += text;
+      stdoutBuffer += text;
+      const lines = stdoutBuffer.split('\n');
+      stdoutBuffer = lines.pop() || '';
+      for (const line of lines) {
+        if (line.trim()) handlers.onStdoutLine?.(line);
+      }
+    });
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString('utf8');
+    });
+    child.on('close', (code) => {
+      try {
+        resolve(handlers.parseResult
+          ? handlers.parseResult({ code, stdout, stderr, interrupted })
+          : { code, stdout, stderr, interrupted });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+
+  return {
+    promise,
+    interrupt: () => {
+      interrupted = true;
+      if (child && !child.killed) child.kill('SIGINT');
+    },
+  };
+}
+
+function parseJsonMaybe(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function renderClaudeResponse(parsed, fallbackText) {
+  if (!parsed) return (fallbackText || '').trim() || '(no output)';
+  if (typeof parsed.result === 'string') return parsed.result;
+  if (typeof parsed.output === 'string') return parsed.output;
+  if (typeof parsed.content === 'string') return parsed.content;
+  return JSON.stringify(parsed, null, 2);
+}
+
+function parseCodexJsonl(output) {
+  let sessionId = null;
+  const assistantChunks = [];
+  const toolChunks = [];
+
+  for (const line of output.split('\n')) {
+    const raw = line.trim();
+    if (!raw) continue;
+
+    let record;
+    try {
+      record = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+
+    if (record.type === 'thread.started' && record.thread_id) {
+      sessionId = record.thread_id;
+      continue;
+    }
+
+    if (record.type === 'session_meta' && record.payload?.id) {
+      sessionId = record.payload.id;
+      continue;
+    }
+
+    if (record.type === 'item.completed' && record.item) {
+      const item = record.item;
+      if (item.type === 'agent_message' && typeof item.text === 'string' && item.text.trim()) {
+        assistantChunks.push(item.text.trim());
+      } else if (item.type === 'tool_call') {
+        toolChunks.push(formatCodexToolCall(item));
+      } else if (item.type === 'tool_call_output' && typeof item.output === 'string') {
+        toolChunks.push(`tool output\n${item.output.trim()}`);
+      }
+      continue;
+    }
+
+    if (record.type === 'response_item' && record.payload?.type === 'message' && record.payload.role === 'assistant') {
+      for (const item of record.payload.content || []) {
+        if (typeof item?.text === 'string' && item.text.trim()) {
+          assistantChunks.push(item.text.trim());
+        }
+      }
+    }
+  }
+
+  return {
+    sessionId,
+    text: [...toolChunks, ...assistantChunks].join('\n\n').trim(),
+  };
+}
+
+function formatCodexToolCall(item) {
+  const name = item.name || item.tool_name || 'tool';
+  const args = item.arguments || item.args || item.input;
+  if (!args) return `tool ${name}`;
+  const renderedArgs = typeof args === 'string' ? args : JSON.stringify(args);
+  return `tool ${name}\n${renderedArgs}`;
+}
+
+function emitCodexActivity(line, onActivity) {
+  if (!onActivity) return;
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (record.type === 'turn.started') {
+    onActivity('codex turn started');
+    return;
+  }
+
+  if (record.type === 'item.started' && record.item?.type) {
+    if (record.item.type === 'tool_call') {
+      onActivity(`tool ${record.item.name || record.item.tool_name || 'running'}`);
+    } else if (record.item.type === 'agent_message') {
+      onActivity('codex composing');
+    }
+    return;
+  }
+
+  if (record.type === 'item.completed' && record.item?.type === 'tool_call') {
+    onActivity(`tool ${record.item.name || record.item.tool_name || 'done'}`);
+    return;
+  }
+
+  if (record.type === 'turn.completed') {
+    onActivity('codex turn complete');
+  }
+}

package/lib/session-store.js

@@ -0,0 +1,358 @@
+import { appendFileSync, 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';
+import readline from 'node:readline';
+
+const CODEX_HOME = join(homedir(), '.codex');
+const CLAUDE_PROJECTS = join(homedir(), '.claude', 'projects');
+const MAX_TEXT_CHARS = 20000;
+const SECRET_PATTERNS = [
+  /\bgithub_pat_[A-Za-z0-9_]+\b/g,
+  /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+  /\bsk-or-v1-[A-Za-z0-9_-]{20,}\b/g,
+  /\bsk-[A-Za-z0-9_-]{20,}\b/g,
+  /\bgsk_[A-Za-z0-9]{20,}\b/g,
+  /\b[A-Fa-f0-9]{48,}\b/g,
+];
+
+export function hasCodexSession(sessionId) {
+  const indexPath = join(CODEX_HOME, 'session_index.jsonl');
+  if (existsSync(indexPath)) {
+    const lines = readFileSync(indexPath, 'utf8').split('\n');
+    if (lines.some((line) => line.includes(`"id":"${sessionId}"`))) return true;
+  }
+
+  return findCodexSessionPath(sessionId, join(CODEX_HOME, 'sessions')) != null;
+}
+
+export function listResumeSessions(limit = 200) {
+  return [...listCodexSessions(limit), ...listClaudeSessions(limit)]
+    .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+    .slice(0, limit);
+}
+
+export async function importClaudeSessionToCodex({ session, cwd = process.cwd() }) {
+  if (!session) throw new Error('Missing Claude session ID or JSONL path');
+
+  const sourcePath = resolveClaudeSessionPath(session);
+  const sessionId = randomUUID();
+  const records = [];
+  let firstTimestamp = null;
+  let lastTimestamp = null;
+  let importedCwd = null;
+  let threadName = `Imported Claude session ${basename(sourcePath, '.jsonl')}`;
+  let userMessages = 0;
+  let assistantMessages = 0;
+
+  const rl = readline.createInterface({
+    input: createReadStream(sourcePath, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+
+  for await (const line of rl) {
+    const raw = line.trim();
+    if (!raw) continue;
+
+    let entry;
+    try {
+      entry = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+
+    importedCwd ??= entry.cwd || null;
+    firstTimestamp ??= entry.timestamp || null;
+    lastTimestamp = entry.timestamp || lastTimestamp;
+
+    if (entry.type === 'user') {
+      const text = renderClaudeUser(entry.message?.content);
+      if (!text) continue;
+      if (threadName.startsWith('Imported Claude session ')) {
+        threadName = text.replace(/\s+/g, ' ').slice(0, 80) || threadName;
+      }
+      records.push(makeMessageRecord(entry.timestamp, 'user', 'input_text', text));
+      userMessages += 1;
+    }
+
+    if (entry.type === 'assistant') {
+      const text = renderClaudeAssistant(entry);
+      if (!text) continue;
+      records.push(makeMessageRecord(entry.timestamp, 'assistant', 'output_text', text));
+      assistantMessages += 1;
+    }
+  }
+
+  const createdAt = firstTimestamp || new Date().toISOString();
+  const sessionPath = writeCodexSession({
+    sessionId,
+    createdAt,
+    cwd: importedCwd || cwd,
+    records,
+  });
+
+  appendSessionIndex({
+    sessionId,
+    threadName,
+    updatedAt: lastTimestamp || createdAt,
+  });
+
+  return {
+    sessionId,
+    sessionPath,
+    threadName,
+    sourcePath,
+    userMessages,
+    assistantMessages,
+  };
+}
+
+function resolveClaudeSessionPath(sessionRef) {
+  if (sessionRef.endsWith('.jsonl')) {
+    const explicitPath = isAbsolute(sessionRef) ? sessionRef : resolve(process.cwd(), sessionRef);
+    if (!existsSync(explicitPath)) throw new Error(`Claude session file not found: ${explicitPath}`);
+    return explicitPath;
+  }
+
+  const target = `${sessionRef}.jsonl`;
+  const stack = [CLAUDE_PROJECTS];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isFile() && entry.name === target) return fullPath;
+      if (entry.isDirectory()) stack.push(fullPath);
+    }
+  }
+
+  throw new Error(`Claude session ${sessionRef} not found under ${CLAUDE_PROJECTS}`);
+}
+
+function listCodexSessions(limit) {
+  const indexPath = join(CODEX_HOME, 'session_index.jsonl');
+  if (!existsSync(indexPath)) return [];
+
+  return readFileSync(indexPath, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .slice(-limit)
+    .map((line) => {
+      try {
+        const entry = JSON.parse(line);
+        return {
+          cli: 'codex',
+          sessionId: entry.id,
+          title: entry.thread_name || '(untitled)',
+          updatedAt: entry.updated_at || '1970-01-01T00:00:00.000Z',
+        };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function listClaudeSessions(limit) {
+  const stack = [CLAUDE_PROJECTS];
+  const sessions = [];
+
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      const sessionId = entry.name.replace(/\.jsonl$/, '');
+      const { title, updatedAt } = readClaudeSessionSummary(fullPath);
+      sessions.push({
+        cli: 'claude',
+        sessionId,
+        title,
+        updatedAt: updatedAt || statSync(fullPath).mtime.toISOString(),
+        path: fullPath,
+      });
+    }
+  }
+
+  return sessions
+    .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+    .slice(0, limit);
+}
+
+function readClaudeSessionSummary(path) {
+  let title = '(untitled)';
+  let updatedAt = null;
+
+  try {
+    const lines = readFileSync(path, 'utf8').split('\n');
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      const entry = JSON.parse(line);
+      updatedAt = entry.timestamp || updatedAt;
+      if (title === '(untitled)' && entry.type === 'user') {
+        const text = renderClaudeUser(entry.message?.content).replace(/\s+/g, ' ').trim();
+        if (text) title = text.slice(0, 100);
+      }
+    }
+  } catch {
+    return { title, updatedAt };
+  }
+
+  return { title, updatedAt };
+}
+
+function findCodexSessionPath(sessionId, root) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isFile() && entry.name.endsWith(`${sessionId}.jsonl`)) return fullPath;
+      if (entry.isDirectory()) stack.push(fullPath);
+    }
+  }
+  return null;
+}
+
+function writeCodexSession({ sessionId, createdAt, cwd, records }) {
+  const date = new Date(createdAt);
+  const stamp = createdAt.replace(/:/g, '-').replace(/\.\d{3}Z$/, '');
+  const sessionDir = join(
+    CODEX_HOME,
+    'sessions',
+    String(date.getUTCFullYear()),
+    String(date.getUTCMonth() + 1).padStart(2, '0'),
+    String(date.getUTCDate()).padStart(2, '0'),
+  );
+
+  mkdirSync(sessionDir, { recursive: true });
+  const sessionPath = join(sessionDir, `rollout-${stamp}-${sessionId}.jsonl`);
+  const lines = [
+    JSON.stringify({
+      timestamp: createdAt,
+      type: 'session_meta',
+      payload: {
+        id: sessionId,
+        timestamp: createdAt,
+        cwd,
+        originator: 'claudex',
+        cli_version: 'imported',
+        source: 'cli',
+      },
+    }),
+    JSON.stringify({
+      timestamp: createdAt,
+      type: 'event_msg',
+      payload: {
+        type: 'task_started',
+        turn_id: randomUUID(),
+        collaboration_mode_kind: 'default',
+      },
+    }),
+    ...records.map((record) => JSON.stringify(record)),
+  ];
+  writeFileSync(sessionPath, `${lines.join('\n')}\n`, 'utf8');
+  return sessionPath;
+}
+
+function appendSessionIndex({ sessionId, threadName, updatedAt }) {
+  const indexPath = join(CODEX_HOME, 'session_index.jsonl');
+  mkdirSync(dirname(indexPath), { recursive: true });
+  appendFileSync(
+    indexPath,
+    `${JSON.stringify({ id: sessionId, thread_name: threadName, updated_at: updatedAt })}\n`,
+    'utf8',
+  );
+}
+
+function makeMessageRecord(timestamp, role, type, text) {
+  return {
+    timestamp: timestamp || new Date().toISOString(),
+    type: 'response_item',
+    payload: {
+      type: 'message',
+      role,
+      content: [{ type, text: truncate(redact(text)) }],
+    },
+  };
+}
+
+function renderClaudeUser(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((item) => {
+      if (item?.type === 'text') return item.text || '';
+      if (item?.type === 'tool_result') return `[Claude tool result ${item.tool_use_id || 'unknown'}]\n${renderToolResult(item.content)}`;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function renderClaudeAssistant(entry) {
+  if (entry.error && entry.isApiErrorMessage) {
+    return `[Claude API error: ${entry.error}]\n${renderToolResult(entry.message?.content)}`.trim();
+  }
+  if (!Array.isArray(entry.message?.content)) return '';
+  return entry.message.content
+    .map((item) => {
+      if (item?.type === 'text') return item.text || '';
+      if (item?.type === 'tool_use') {
+        return `[Claude tool use: ${item.name || 'tool'} ${item.id || ''}]\n${JSON.stringify(item.input || {}, null, 2)}`;
+      }
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function renderToolResult(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => (typeof item === 'string' ? item : item?.text || JSON.stringify(item)))
+      .filter(Boolean)
+      .join('\n');
+  }
+  if (content == null) return '';
+  return JSON.stringify(content, null, 2);
+}
+
+function redact(text) {
+  let value = String(text || '');
+  for (const pattern of SECRET_PATTERNS) {
+    value = value.replace(pattern, '[REDACTED_SECRET]');
+  }
+  return value;
+}
+
+function truncate(text) {
+  const value = String(text || '');
+  if (value.length <= MAX_TEXT_CHARS) return value;
+  return `${value.slice(0, MAX_TEXT_CHARS)}\n\n[truncated ${value.length - MAX_TEXT_CHARS} chars during Claude -> Codex import]`;
+}

package/lib/ui.js

@@ -0,0 +1,382 @@
+import React, { useMemo, 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';
+
+const HELP_LINES = [
+  '/use claude | /use codex',
+  '/resume --cli <claude|codex> <session-id-or-claude-jsonl-path>',
+  '/ids',
+  '/menu',
+  '/clear',
+  '/help',
+  '/exit',
+];
+
+export function ClauDexApp({ initialAgent = 'codex', initialSessions, initialNotice }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [agent, setAgent] = useState(initialAgent);
+  const [sessions, setSessions] = useState(initialSessions || { claude: null, codex: null });
+  const [messages, setMessages] = useState(() => [
+    messageOf('system', initialNotice || 'Type /help for commands.'),
+  ]);
+  const [busy, setBusy] = useState(false);
+  const [menu, setMenu] = useState({ open: false, selected: 0, items: [] });
+
+  const transcriptHeight = Math.max(8, (stdout?.rows || 24) - 7);
+  const accent = agent === 'claude' ? 'magenta' : 'cyan';
+  const status = useMemo(() => {
+    const claudeId = sessions.claude ? sessions.claude.slice(0, 8) : 'none';
+    const codexId = sessions.codex ? sessions.codex.slice(0, 8) : 'none';
+    return `active=${agent} claude=${claudeId} codex=${codexId}`;
+  }, [agent, sessions]);
+
+  async function submit(value) {
+    const text = value.trim();
+    if (!text || busy) return;
+
+    setMessages((current) => [...current, messageOf('user', `[to ${agent}] ${text}`)]);
+
+    if (text.startsWith('/')) {
+      await runCommand(text, {
+        sessions,
+        setAgent,
+        setSessions,
+        setMessages,
+        setMenu,
+        exit,
+      });
+      return;
+    }
+
+    setBusy(true);
+    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}`)]);
+      }
+    } catch (error) {
+      setMessages((current) => [...current, messageOf('error', error?.message || String(error))]);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column', minHeight: stdout?.rows || 24 },
+    React.createElement(
+      Box,
+      {
+        borderStyle: 'round',
+        borderColor: accent,
+        paddingX: 1,
+        justifyContent: 'space-between',
+      },
+      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(
+      Box,
+      {
+        flexDirection: 'column',
+        borderStyle: 'single',
+        borderColor: 'gray',
+        paddingX: 1,
+        height: transcriptHeight,
+        overflow: 'hidden',
+      },
+      messages.slice(-120).map((message, index) =>
+        React.createElement(MessageComponent, {
+          key: `${message.timestamp.getTime()}-${index}`,
+          message,
+          variant: 'chat',
+          toolDisplayMode: 'minimal',
+          showTimestamp: false,
+          prefixOverrides: {
+            user: 'you ',
+            assistant: 'agent ',
+            system: 'system ',
+            error: 'error ',
+          },
+        }),
+      ),
+      busy
+        ? React.createElement(
+          Box,
+          { marginBottom: 1 },
+          React.createElement(Text, { color: accent }, 'agent '),
+          React.createElement(Text, { color: accent },
+            React.createElement(Spinner, { type: 'dots' }),
+            ' thinking...',
+          ),
+        )
+        : null,
+      menu.open
+        ? React.createElement(SessionMenu, {
+          menu,
+          setMenu,
+          setAgent,
+          setSessions,
+          setMessages,
+        })
+        : null,
+    ),
+    React.createElement(
+      Box,
+      {
+        borderStyle: 'round',
+        borderColor: accent,
+        paddingX: 1,
+      },
+      React.createElement(Text, { color: accent, bold: true }, `${agent} › `),
+      React.createElement(Composer, {
+        placeholder: busy ? 'waiting for response...' : 'message or /help',
+        onSubmit: submit,
+        disabled: busy || menu.open,
+      }),
+    ),
+  );
+}
+
+async function runCommand(text, ctx) {
+  const [command, ...args] = text.split(/\s+/);
+
+  if (command === '/exit' || command === '/quit') {
+    ctx.exit();
+    return;
+  }
+
+  if (command === '/help') {
+    ctx.setMessages((current) => [...current, messageOf('system', `Commands:\n${HELP_LINES.join('\n')}`)]);
+    return;
+  }
+
+  if (command === '/clear') {
+    ctx.setMessages([messageOf('system', 'Cleared transcript.')]);
+    return;
+  }
+
+  if (command === '/ids') {
+    ctx.setMessages((current) => [
+      ...current,
+      messageOf('system', `claude=${ctx.sessions.claude || 'none'}\ncodex=${ctx.sessions.codex || 'none'}`),
+    ]);
+    return;
+  }
+
+  if (command === '/menu') {
+    ctx.setMenu({
+      open: true,
+      selected: 0,
+      items: listResumeSessions(200),
+    });
+    ctx.setMessages((current) => [...current, messageOf('system', 'Opened resume menu. ↑/↓ navigate, Enter resume, Esc close.')]);
+    return;
+  }
+
+  if (command === '/use') {
+    const next = args[0];
+    if (!['claude', 'codex'].includes(next)) {
+      ctx.setMessages((current) => [...current, messageOf('system', 'Usage: /use claude or /use codex')]);
+      return;
+    }
+
+    if (next === 'codex' && !ctx.sessions.codex && ctx.sessions.claude) {
+      ctx.setMessages((current) => [
+        ...current,
+        messageOf('system', `Importing Claude session ${ctx.sessions.claude} into Codex...`),
+      ]);
+      const imported = await importClaudeSessionToCodex({
+        session: ctx.sessions.claude,
+        cwd: process.cwd(),
+      });
+      ctx.setSessions((current) => ({ ...current, codex: imported.sessionId }));
+      ctx.setMessages((current) => [
+        ...current,
+        messageOf('system', `Imported Claude ${ctx.sessions.claude} -> Codex ${imported.sessionId}`),
+      ]);
+    }
+
+    ctx.setAgent(next);
+    ctx.setMessages((current) => [...current, messageOf('system', `Switched active backend to ${next}`)]);
+    return;
+  }
+
+  if (command === '/resume') {
+    await resumeBackend(args, ctx);
+    return;
+  }
+
+  ctx.setMessages((current) => [...current, messageOf('system', `Unknown command: ${command}. Type /help.`)]);
+}
+
+async function resumeBackend(args, ctx) {
+  const cliIndex = args.indexOf('--cli');
+  const target = cliIndex >= 0 ? args[cliIndex + 1] : null;
+  const session = args.find((value, index) => index !== cliIndex && index !== cliIndex + 1 && !value.startsWith('-'));
+
+  if (!['claude', 'codex'].includes(target) || !session) {
+    ctx.setMessages((current) => [
+      ...current,
+      messageOf('system', 'Usage: /resume --cli <claude|codex> <session-id-or-claude-jsonl-path>'),
+    ]);
+    return;
+  }
+
+  if (target === 'claude') {
+    ctx.setSessions((current) => ({ ...current, claude: session }));
+    ctx.setAgent('claude');
+    ctx.setMessages((current) => [...current, messageOf('system', `Resuming Claude session ${session}`)]);
+    return;
+  }
+
+  if (hasCodexSession(session)) {
+    ctx.setSessions((current) => ({ ...current, codex: session }));
+    ctx.setAgent('codex');
+    ctx.setMessages((current) => [...current, messageOf('system', `Resuming Codex session ${session}`)]);
+    return;
+  }
+
+  ctx.setMessages((current) => [
+    ...current,
+    messageOf('system', `Importing Claude session ${session} into Codex...`),
+  ]);
+  const imported = await importClaudeSessionToCodex({ session, cwd: process.cwd() });
+  ctx.setSessions((current) => ({
+    ...current,
+    claude: current.claude || session,
+    codex: imported.sessionId,
+  }));
+  ctx.setAgent('codex');
+  ctx.setMessages((current) => [
+    ...current,
+    messageOf('system', `Imported Claude ${session} -> Codex ${imported.sessionId}`),
+  ]);
+}
+
+function messageOf(role, content) {
+  return {
+    role,
+    content,
+    timestamp: new Date(),
+    status: 'complete',
+  };
+}
+
+function Composer({ placeholder, onSubmit, disabled }) {
+  const [value, setValue] = useState('');
+
+  useInput((input, key) => {
+    if (disabled) return;
+    if (key.return) {
+      if (value.trim()) {
+        onSubmit(value);
+        setValue('');
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setValue((current) => current.slice(0, -1));
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      setValue((current) => current + input);
+    }
+  }, { isActive: !disabled });
+
+  const color = value.startsWith('/') ? 'yellow' : 'white';
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column', flexGrow: 1 },
+    React.createElement(
+      Text,
+      { color: value ? color : 'gray' },
+      value || placeholder,
+      !disabled && React.createElement(Text, { backgroundColor: 'gray' }, ' '),
+    ),
+    !disabled
+      ? React.createElement(Box, { marginTop: 1 }, React.createElement(Text, { color: 'gray', dimColor: true }, 'Press Enter to send'))
+      : null,
+  );
+}
+
+function SessionMenu({ menu, setMenu, setAgent, setSessions, setMessages }) {
+  useInput((input, key) => {
+    if (key.escape || input === 'q') {
+      setMenu((current) => ({ ...current, open: false }));
+      return;
+    }
+
+    if (key.upArrow) {
+      setMenu((current) => ({
+        ...current,
+        selected: Math.max(0, current.selected - 1),
+      }));
+      return;
+    }
+
+    if (key.downArrow) {
+      setMenu((current) => ({
+        ...current,
+        selected: Math.min(current.items.length - 1, current.selected + 1),
+      }));
+      return;
+    }
+
+    if (key.return) {
+      const item = menu.items[menu.selected];
+      if (!item) return;
+      setSessions((current) => ({ ...current, [item.cli]: item.sessionId }));
+      setAgent(item.cli);
+      setMenu((current) => ({ ...current, open: false }));
+      setMessages((current) => [
+        ...current,
+        messageOf('system', `Resuming ${item.cli} session ${item.sessionId}`),
+      ]);
+    }
+  });
+
+  return React.createElement(
+    Box,
+    {
+      flexDirection: 'column',
+      borderStyle: 'round',
+      borderColor: 'yellow',
+      paddingX: 1,
+      marginTop: 1,
+    },
+    React.createElement(Text, { color: 'yellow', bold: true }, 'Resume Menu'),
+    menu.items.slice(Math.max(0, menu.selected - 6), menu.selected + 7).map((item) => {
+      const isSelected = item === menu.items[menu.selected];
+      return React.createElement(
+        Text,
+        {
+          key: `${item.cli}-${item.sessionId}`,
+          color: isSelected ? 'black' : item.cli === 'claude' ? 'magenta' : 'cyan',
+          backgroundColor: isSelected ? 'yellow' : undefined,
+        },
+        `${isSelected ? '›' : ' '} ${item.cli.padEnd(6)} ${item.sessionId.slice(0, 8)}  ${item.updatedAt.slice(0, 16)}  ${item.title}`,
+      );
+    }),
+    React.createElement(Text, { dimColor: true }, 'Enter resume  Esc close'),
+  );
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@mylesiyabor/claudex",
+  "version": "0.1.0",
+  "description": "Ink TUI for chatting with Claude Code and Codex CLI from one switchable interface.",
+  "type": "module",
+  "bin": {
+    "claudex": "./bin/claudex.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "ink": "^4.4.1",
+    "ink-spinner": "^5.0.0",
+    "react": "^18.2.0",
+    "terminal-chat-ui": "^1.0.3"
+  }
+}