memhouse 0.0.1 → 0.3.0

package/editors/codex.js

@@ -0,0 +1,537 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const name = 'codex';
+const DEFAULT_CODEX_HOME = path.join(os.homedir(), '.codex');
+const SESSION_SUBDIR = 'sessions';
+const ARCHIVED_SESSION_SUBDIR = 'archived_sessions';
+const MAX_TOOL_RESULT_PREVIEW = 500;
+
+function getChats() {
+  const dirs = [getSessionsDir(), getArchivedSessionsDir()];
+  const seen = new Set();
+  const chats = [];
+
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    for (const filePath of walkJsonlFiles(dir)) {
+      const chat = readChatMetadata(filePath);
+      if (!chat) continue;
+      if (seen.has(chat.composerId)) continue;
+      seen.add(chat.composerId);
+      chats.push(chat);
+    }
+  }
+
+  return chats;
+}
+
+function getMessages(chat) {
+  const filePath = chat && chat._filePath;
+  if (!filePath || !fs.existsSync(filePath)) return [];
+  return parseSessionMessages(filePath);
+}
+
+function getCodexHome() {
+  return process.env.CODEX_HOME && process.env.CODEX_HOME.trim()
+    ? path.resolve(process.env.CODEX_HOME.trim())
+    : DEFAULT_CODEX_HOME;
+}
+
+function getSessionsDir() {
+  return path.join(getCodexHome(), SESSION_SUBDIR);
+}
+
+function getArchivedSessionsDir() {
+  return path.join(getCodexHome(), ARCHIVED_SESSION_SUBDIR);
+}
+
+function walkJsonlFiles(dir) {
+  const results = [];
+  const stack = [dir];
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  return results.sort();
+}
+
+function readChatMetadata(filePath) {
+  const lines = readLines(filePath);
+  if (lines.length === 0) return null;
+
+  const first = safeParseJson(lines[0]);
+  if (!first || first.type !== 'session_meta' || !first.payload) return null;
+
+  let title = null;
+  for (let i = 1; i < lines.length; i++) {
+    const entry = safeParseJson(lines[i]);
+    if (!entry || entry.type !== 'response_item' || !entry.payload) continue;
+    const payload = entry.payload;
+    if (payload.type !== 'message' || payload.role !== 'user') continue;
+    const text = extractUserText(payload.content);
+    if (!text || isBootstrapMessage(text)) continue;
+    title = cleanPrompt(text);
+    break;
+  }
+
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    stat = null;
+  }
+
+  const payload = first.payload;
+  return {
+    source: 'codex',
+    composerId: payload.id || path.basename(filePath, '.jsonl'),
+    name: title,
+    createdAt: toTimestamp(payload.timestamp) || (stat ? stat.birthtimeMs : null),
+    lastUpdatedAt: stat ? stat.mtimeMs : null,
+    mode: 'codex',
+    folder: payload.cwd || null,
+    encrypted: false,
+    bubbleCount: 0,
+    _filePath: filePath,
+    _rawSource: payload.source || null,
+    _originator: payload.originator || null,
+    _cliVersion: payload.cli_version || null,
+    _modelProvider: payload.model_provider || null,
+  };
+}
+
+function parseSessionMessages(filePath) {
+  const lines = readLines(filePath);
+  const messages = [];
+
+  let currentModel = null;
+  let previousTotals = null;
+  let currentTurn = createTurnState();
+  let turnHasStarted = false;
+  const toolNamesByCallId = new Map();
+
+  function flushTurn() {
+    const hasAssistantContent = currentTurn.parts.length > 0;
+    const hasTokens = currentTurn.inputTokens > 0 || currentTurn.outputTokens > 0 || currentTurn.cacheRead > 0;
+    const hasTools = currentTurn.toolCalls.length > 0;
+    if (!hasAssistantContent && !hasTokens && !hasTools) {
+      currentTurn = createTurnState();
+      toolNamesByCallId.clear();
+      return;
+    }
+
+    messages.push(composeAssistantMessage(currentTurn));
+    currentTurn = createTurnState();
+    toolNamesByCallId.clear();
+  }
+
+  for (const line of lines) {
+    const entry = safeParseJson(line);
+    if (!entry) continue;
+
+    if (entry.type === 'turn_context') {
+      if (turnHasStarted) flushTurn();
+      turnHasStarted = true;
+      const model = extractModel(entry.payload);
+      if (model) {
+        currentModel = model;
+        currentTurn.model = model;
+      }
+      continue;
+    }
+
+    if (entry.type === 'response_item' && entry.payload) {
+      const payload = entry.payload;
+
+      if (payload.type === 'message') {
+        if (payload.role === 'user') {
+          const text = extractUserText(payload.content);
+          if (!text || isBootstrapMessage(text)) continue;
+          if (turnHasStarted) flushTurn();
+          messages.push({ role: 'user', content: text });
+        } else if (payload.role === 'assistant') {
+          const text = extractAssistantText(payload.content);
+          if (text) currentTurn.parts.push(text);
+          if (!currentTurn.model && currentModel) currentTurn.model = currentModel;
+        } else if (payload.role === 'system') {
+          const text = extractAssistantText(payload.content);
+          if (text) messages.push({ role: 'system', content: text });
+        }
+        continue;
+      }
+
+      if (payload.type === 'reasoning') {
+        const summary = extractReasoningSummary(payload);
+        if (summary) currentTurn.parts.push(summary);
+        continue;
+      }
+
+      if (isToolCallPayload(payload.type)) {
+        const toolCall = normalizeToolCall(payload);
+        currentTurn.parts.push(toolCall.line);
+        currentTurn.toolCalls.push({ name: toolCall.name, args: toolCall.args });
+        if (payload.call_id) toolNamesByCallId.set(payload.call_id, toolCall.name);
+        continue;
+      }
+
+      if (isToolOutputPayload(payload.type)) {
+        const lineText = normalizeToolResult(payload, toolNamesByCallId.get(payload.call_id));
+        if (lineText) currentTurn.parts.push(lineText);
+        continue;
+      }
+
+      continue;
+    }
+
+    if (entry.type === 'event_msg' && entry.payload && entry.payload.type === 'token_count') {
+      const tokenInfo = entry.payload.info || {};
+      const lastUsage = normalizeRawUsage(tokenInfo.last_token_usage);
+      const totalUsage = normalizeRawUsage(tokenInfo.total_token_usage);
+
+      let rawUsage = lastUsage;
+      if (!rawUsage && totalUsage) rawUsage = subtractRawUsage(totalUsage, previousTotals);
+      if (totalUsage) previousTotals = totalUsage;
+      if (!rawUsage) continue;
+
+      const delta = convertToDelta(rawUsage);
+      if (delta.inputTokens === 0 && delta.outputTokens === 0 && delta.cacheRead === 0) continue;
+
+      currentTurn.inputTokens += delta.inputTokens;
+      currentTurn.outputTokens += delta.outputTokens;
+      currentTurn.cacheRead += delta.cacheRead;
+
+      const model = extractModel(tokenInfo) || extractModel(entry.payload);
+      if (model) {
+        currentModel = model;
+        currentTurn.model = model;
+      } else if (!currentTurn.model && currentModel) {
+        currentTurn.model = currentModel;
+      }
+    }
+  }
+
+  if (turnHasStarted) flushTurn();
+
+  return messages;
+}
+
+function createTurnState() {
+  return {
+    parts: [],
+    toolCalls: [],
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheRead: 0,
+    model: null,
+  };
+}
+
+function composeAssistantMessage(turn) {
+  const content = turn.parts.join('\n') || '[assistant activity]';
+  return {
+    role: 'assistant',
+    content,
+    _model: turn.model || undefined,
+    _inputTokens: turn.inputTokens || undefined,
+    _outputTokens: turn.outputTokens || undefined,
+    _cacheRead: turn.cacheRead || undefined,
+    _toolCalls: turn.toolCalls.length > 0 ? turn.toolCalls : undefined,
+  };
+}
+
+function extractUserText(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((item) => item && item.type === 'input_text' && typeof item.text === 'string')
+    .map((item) => item.text.trim())
+    .filter(Boolean)
+    .join('\n')
+    .trim();
+}
+
+function extractAssistantText(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((item) => item && item.type === 'output_text' && typeof item.text === 'string')
+    .map((item) => item.text.trim())
+    .filter(Boolean)
+    .join('\n')
+    .trim();
+}
+
+function extractReasoningSummary(payload) {
+  if (!Array.isArray(payload.summary)) return '';
+  return payload.summary
+    .filter((item) => item && typeof item.text === 'string' && item.text.trim())
+    .map((item) => `[thinking] ${item.text.trim()}`)
+    .join('\n')
+    .trim();
+}
+
+function isBootstrapMessage(text) {
+  const trimmed = text.trim();
+  return trimmed.startsWith('<user_instructions>') || trimmed.startsWith('<environment_context>');
+}
+
+function cleanPrompt(text) {
+  return text.replace(/\s+/g, ' ').trim().substring(0, 120) || null;
+}
+
+function isToolCallPayload(type) {
+  return type === 'function_call' || type === 'custom_tool_call' || type === 'web_search_call';
+}
+
+function isToolOutputPayload(type) {
+  return type === 'function_call_output' || type === 'custom_tool_call_output';
+}
+
+function normalizeToolCall(payload) {
+  const name = payload.name || (payload.type === 'web_search_call' ? 'web_search' : 'tool');
+  const args = parseToolArgs(payload);
+  const argKeys = Object.keys(args).join(', ');
+  return {
+    name,
+    args,
+    line: `[tool-call: ${name}(${argKeys})]`,
+  };
+}
+
+function normalizeToolResult(payload, fallbackName) {
+  const name = payload.name || fallbackName || 'tool';
+  const preview = previewToolOutput(payload.output);
+  return preview ? `[tool-result: ${name}] ${preview}` : `[tool-result: ${name}]`;
+}
+
+function parseToolArgs(payload) {
+  if (payload.type === 'function_call') {
+    return parseJsonRecord(payload.arguments);
+  }
+  if (payload.type === 'custom_tool_call') {
+    return { input: truncateSingleLine(String(payload.input || ''), 300) };
+  }
+  if (payload.type === 'web_search_call') {
+    return parseJsonRecord(payload.arguments || payload.input || payload.query);
+  }
+  return {};
+}
+
+function previewToolOutput(output) {
+  if (output == null) return '';
+  let value = output;
+  if (typeof value === 'string') {
+    const parsed = safeParseJson(value);
+    if (parsed && typeof parsed === 'object' && typeof parsed.output === 'string') {
+      value = parsed.output;
+    } else {
+      value = value;
+    }
+  } else if (typeof value === 'object') {
+    value = JSON.stringify(value);
+  } else {
+    value = String(value);
+  }
+
+  const trimmed = String(value).trim();
+  if (!trimmed) return '';
+  return truncateSingleLine(trimmed, MAX_TOOL_RESULT_PREVIEW);
+}
+
+function truncateSingleLine(text, maxLen) {
+  const oneLine = String(text).replace(/\s+/g, ' ').trim();
+  return oneLine.length > maxLen ? oneLine.substring(0, maxLen) + '…' : oneLine;
+}
+
+function parseJsonRecord(value) {
+  if (value == null) return {};
+  if (typeof value === 'object' && !Array.isArray(value)) return value;
+  if (typeof value !== 'string') return {};
+  const parsed = safeParseJson(value);
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+}
+
+function normalizeRawUsage(value) {
+  if (!value || typeof value !== 'object') return null;
+  const input = ensureNumber(value.input_tokens);
+  const cached = ensureNumber(value.cached_input_tokens != null ? value.cached_input_tokens : value.cache_read_input_tokens);
+  const output = ensureNumber(value.output_tokens);
+  const total = ensureNumber(value.total_tokens);
+  return {
+    input_tokens: input,
+    cached_input_tokens: cached,
+    output_tokens: output,
+    total_tokens: total > 0 ? total : input + output,
+  };
+}
+
+function subtractRawUsage(current, previous) {
+  return {
+    input_tokens: Math.max(current.input_tokens - (previous ? previous.input_tokens : 0), 0),
+    cached_input_tokens: Math.max(current.cached_input_tokens - (previous ? previous.cached_input_tokens : 0), 0),
+    output_tokens: Math.max(current.output_tokens - (previous ? previous.output_tokens : 0), 0),
+    total_tokens: Math.max(current.total_tokens - (previous ? previous.total_tokens : 0), 0),
+  };
+}
+
+function convertToDelta(raw) {
+  const cacheRead = Math.min(raw.cached_input_tokens, raw.input_tokens);
+  const billableInput = Math.max(raw.input_tokens - cacheRead, 0);
+  return {
+    inputTokens: billableInput,
+    cacheRead,
+    outputTokens: raw.output_tokens,
+    totalTokens: raw.total_tokens > 0 ? raw.total_tokens : raw.input_tokens + raw.output_tokens,
+  };
+}
+
+function extractModel(value) {
+  if (!value || typeof value !== 'object') return null;
+
+  const direct = asNonEmptyString(value.model)
+    || asNonEmptyString(value.model_name);
+  if (direct) return direct;
+
+  if (value.info && typeof value.info === 'object') {
+    const infoModel = extractModel(value.info);
+    if (infoModel) return infoModel;
+  }
+
+  if (value.metadata && typeof value.metadata === 'object') {
+    const metadataModel = extractModel(value.metadata);
+    if (metadataModel) return metadataModel;
+  }
+
+  return null;
+}
+
+function asNonEmptyString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function ensureNumber(value) {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function toTimestamp(value) {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function readLines(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf-8').split(/\r?\n/).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function safeParseJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+// ============================================================
+// Usage / quota data from Codex auth.json JWT
+// ============================================================
+
+function getCodexAuth() {
+  const authPath = path.join(getCodexHome(), 'auth.json');
+  try {
+    return JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+  } catch { return null; }
+}
+
+function decodeJwtPayload(token) {
+  if (!token) return null;
+  try {
+    const parts = token.split('.');
+    if (parts.length < 2) return null;
+    let payload = parts[1];
+    // Fix base64url padding
+    payload += '='.repeat((4 - payload.length % 4) % 4);
+    const decoded = Buffer.from(payload, 'base64').toString('utf-8');
+    return JSON.parse(decoded);
+  } catch { return null; }
+}
+
+async function getUsage() {
+  const { isSubscriptionAccessAllowed } = require('./base');
+  if (!isSubscriptionAccessAllowed()) return null;
+  const auth = getCodexAuth();
+  if (!auth || !auth.tokens) return null;
+
+  const idPayload = decodeJwtPayload(auth.tokens.id_token);
+  const accessPayload = decodeJwtPayload(auth.tokens.access_token);
+
+  const authClaims = idPayload?.['https://api.openai.com/auth'] || accessPayload?.['https://api.openai.com/auth'] || {};
+  const profileClaims = idPayload?.['https://api.openai.com/profile'] || accessPayload?.['https://api.openai.com/profile'] || {};
+
+  const planType = authClaims.chatgpt_plan_type || null;
+  const email = profileClaims.email || null;
+  const subscriptionStart = authClaims.chatgpt_subscription_active_start || null;
+  const subscriptionEnd = authClaims.chatgpt_subscription_active_until || null;
+
+  if (!planType && !email) return null;
+
+  return {
+    source: 'codex',
+    plan: {
+      name: planType,
+      subscriptionStart,
+      subscriptionEnd,
+    },
+    user: {
+      email,
+    },
+    authMode: auth.auth_mode || null,
+  };
+}
+
+const labels = { 'codex': 'Codex' };
+
+function getArtifacts(folder) {
+  const { scanArtifacts } = require('./base');
+  return scanArtifacts(folder, {
+    editor: 'codex',
+    label: 'Codex',
+    files: ['AGENTS.md', 'codex.md'],
+    dirs: [],
+  });
+}
+
+function getMCPServers() {
+  // Codex doesn't have native MCP server configuration
+  return [];
+}
+
+module.exports = {
+  name,
+  labels,
+  getArtifacts,
+  getChats,
+  getMessages,
+  getUsage,
+  getMCPServers,
+};

package/editors/commandcode.js

@@ -0,0 +1,166 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const COMMANDCODE_DIR = path.join(os.homedir(), '.commandcode');
+const PROJECTS_DIR = path.join(COMMANDCODE_DIR, 'projects');
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'commandcode';
+
+function getChats() {
+  const chats = [];
+  if (!fs.existsSync(PROJECTS_DIR)) return chats;
+
+  let projDirs;
+  try { projDirs = fs.readdirSync(PROJECTS_DIR); } catch { return chats; }
+
+  for (const projDir of projDirs) {
+    const dir = path.join(PROJECTS_DIR, projDir);
+    try { if (!fs.statSync(dir).isDirectory()) continue; } catch { continue; }
+
+    // Decode folder path from dir name (e.g. users-fka-code-foo -> /users/fka/code/foo)
+    const decodedFolder = '/' + projDir.replace(/-/g, '/');
+
+    let files;
+    try { files = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl') && !f.includes('.checkpoints.')); } catch { continue; }
+
+    for (const file of files) {
+      const sessionId = file.replace('.jsonl', '');
+      const fullPath = path.join(dir, file);
+      const metaPath = path.join(dir, `${sessionId}.meta.json`);
+
+      // Read meta.json for title
+      let title = null;
+      try {
+        const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        title = meta.title || null;
+      } catch { /* no meta */ }
+
+      // Parse first and last lines for timestamps
+      try {
+        const stat = fs.statSync(fullPath);
+        const lines = fs.readFileSync(fullPath, 'utf-8').split('\n').filter(Boolean);
+        if (lines.length === 0) continue;
+
+        const first = JSON.parse(lines[0]);
+        const last = JSON.parse(lines[lines.length - 1]);
+
+        const firstPrompt = extractFirstPrompt(first);
+        const bubbleCount = lines.length;
+
+        chats.push({
+          source: 'commandcode',
+          composerId: sessionId,
+          name: title || cleanPrompt(firstPrompt),
+          createdAt: first.timestamp ? new Date(first.timestamp).getTime() : stat.birthtime.getTime(),
+          lastUpdatedAt: last.timestamp ? new Date(last.timestamp).getTime() : stat.mtime.getTime(),
+          mode: 'commandcode',
+          folder: decodedFolder,
+          encrypted: false,
+          bubbleCount,
+          _fullPath: fullPath,
+          _gitBranch: first.gitBranch || null,
+        });
+      } catch { /* skip */ }
+    }
+  }
+
+  return chats;
+}
+
+function extractFirstPrompt(obj) {
+  if (obj.role !== 'user') return null;
+  if (!obj.content) return null;
+  if (typeof obj.content === 'string') return obj.content;
+  if (Array.isArray(obj.content)) {
+    return obj.content
+      .filter(c => c.type === 'text')
+      .map(c => c.text)
+      .join(' ')
+      .substring(0, 200);
+  }
+  return null;
+}
+
+function cleanPrompt(text) {
+  if (!text) return null;
+  return text.replace(/\s+/g, ' ').trim().substring(0, 120) || null;
+}
+
+function getMessages(chat) {
+  const filePath = chat._fullPath;
+  if (!filePath || !fs.existsSync(filePath)) return [];
+
+  const messages = [];
+  const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+
+  for (const line of lines) {
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+
+    if (obj.role === 'user') {
+      const content = extractContent(obj.content);
+      if (content) messages.push({ role: 'user', content });
+    } else if (obj.role === 'assistant') {
+      const { text, toolCalls } = extractAssistantContent(obj.content);
+      if (text) {
+        messages.push({
+          role: 'assistant',
+          content: text,
+          _toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        });
+      }
+    } else if (obj.role === 'system') {
+      const text = extractContent(obj.content);
+      if (text) messages.push({ role: 'system', content: text });
+    }
+  }
+
+  return messages;
+}
+
+function extractContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  // Skip tool_result blocks for user messages (they are tool outputs)
+  return content
+    .filter(c => c.type === 'text')
+    .map(c => c.text)
+    .join('\n') || '';
+}
+
+function extractAssistantContent(content) {
+  if (typeof content === 'string') return { text: content, toolCalls: [] };
+  if (!Array.isArray(content)) return { text: '', toolCalls: [] };
+  const parts = [];
+  const toolCalls = [];
+  for (const block of content) {
+    if (block.type === 'thinking' && block.thinking) {
+      parts.push(`[thinking] ${block.thinking}`);
+    } else if (block.type === 'text' && block.text) {
+      parts.push(block.text);
+    } else if (block.type === 'tool_use') {
+      const args = block.input || {};
+      const argKeys = Object.keys(args).join(', ');
+      parts.push(`[tool-call: ${block.name || 'unknown'}(${argKeys})]`);
+      toolCalls.push({ name: block.name || 'unknown', args });
+    } else if (block.type === 'tool_result') {
+      const text = typeof block.content === 'string' ? block.content : '';
+      parts.push(`[tool-result: ${block.name || 'tool'}] ${text.substring(0, 500)}`);
+    }
+  }
+  return { text: parts.join('\n') || '', toolCalls };
+}
+
+const labels = { 'commandcode': 'Command Code' };
+
+function getMCPServers() {
+  // CommandCode uses Claude's .mcp.json format (project-level, handled by claude.js)
+  return [];
+}
+
+module.exports = { name, labels, getChats, getMessages, getMCPServers };