@axhub/genie 0.1.7 → 0.1.9

package/server/routes/git.js

@@ -5,7 +5,6 @@ import path from 'path';
 import { promises as fs } from 'fs';
 import { extractProjectDirectory } from '../projects.js';
 import { queryClaudeSDK } from '../claude-sdk.js';
-import { spawnCursor } from '../cursor-cli.js';
 import { queryGemini } from '../gemini-cli.js';
 
 const router = express.Router();
@@ -520,8 +519,8 @@ router.post('/generate-commit-message', async (req, res) => {
   }
 
   // Validate provider
-  if (!['claude', 'cursor', 'gemini'].includes(provider)) {
-    return res.status(400).json({ error: 'provider must be "claude", "cursor", or "gemini"' });
+  if (!['claude', 'gemini'].includes(provider)) {
+    return res.status(400).json({ error: 'provider must be "claude" or "gemini"' });
   }
 
   try {
@@ -574,10 +573,10 @@ router.post('/generate-commit-message', async (req, res) => {
 });
 
 /**
- * Generates a commit message using AI (Claude SDK, Cursor CLI, or Gemini CLI)
+ * Generates a commit message using AI (Claude SDK, Codex, Gemini, or OpenCode)
  * @param {Array<string>} files - List of changed files
  * @param {string} diffContext - Git diff content
- * @param {string} provider - 'claude', 'cursor', or 'gemini'
+ * @param {string} provider - 'claude' or 'gemini'
  * @param {string} projectPath - Project directory path
  * @returns {Promise<string>} Generated commit message
  */
@@ -611,7 +610,7 @@ Generate the commit message:`;
           const parsed = typeof data === 'string' ? JSON.parse(data) : data;
           console.log('🔍 Writer received message type:', parsed.type);
 
-          // Handle different message formats from Claude SDK and Cursor CLI
+          // Handle different message formats from supported providers
           // Claude SDK sends: {type: 'claude-response', data: {message: {content: [...]}}}
           if (parsed.type === 'claude-response' && parsed.data) {
             const message = parsed.data.message || parsed.data;
@@ -626,11 +625,6 @@ Generate the commit message:`;
               }
             }
           }
-          // Cursor CLI sends: {type: 'cursor-output', output: '...'}
-          else if (parsed.type === 'cursor-output' && parsed.output) {
-            console.log('✅ Cursor output:', parsed.output.substring(0, 100));
-            responseText += parsed.output;
-          }
           else if (parsed.type === 'claude-response' && parsed.data?.type === 'content_block_delta' && parsed.data?.delta?.text) {
             responseText += parsed.data.delta.text;
           }
@@ -657,11 +651,6 @@ Generate the commit message:`;
         permissionMode: 'bypassPermissions',
         model: 'sonnet'
       }, writer);
-    } else if (provider === 'cursor') {
-      await spawnCursor(prompt, {
-        cwd: projectPath,
-        skipPermissions: true
-      }, writer);
     } else if (provider === 'gemini') {
       await queryGemini(prompt, {
         cwd: projectPath,

package/server/routes/projects.js

@@ -4,6 +4,7 @@ import path from 'path';
 import { spawn } from 'child_process';
 import os from 'os';
 import { addProjectManually } from '../projects.js';
+import { githubTokensDb } from '../database/db.js';
 
 const router = express.Router();
 
@@ -311,13 +312,7 @@ router.post('/create-workspace', async (req, res) => {
  * Helper function to get GitHub token from database
  */
 async function getGithubTokenById(tokenId, userId) {
-  const { getDatabase } = await import('../database/db.js');
-  const db = await getDatabase();
-
-  const credential = await db.get(
-    'SELECT * FROM user_credentials WHERE id = ? AND user_id = ? AND credential_type = ? AND is_active = 1',
-    [tokenId, userId, 'github_token']
-  );
+  const credential = githubTokensDb.getGithubTokenById(userId, tokenId);
 
   // Return in the expected format (github_token field for compatibility)
   if (credential) {

package/server/routes/session-core.js

@@ -0,0 +1,177 @@
+import express from 'express';
+import { getProjects } from '../projects.js';
+import { discoverAllProviders, discoverProvider } from '../session-core/providerDiscovery.js';
+import { getProviderAdapter } from '../session-core/providerAdapters.js';
+
+const router = express.Router();
+
+function flattenProjectSessions(project) {
+  const groups = [
+    { provider: 'claude', items: project.sessions || [] },
+    { provider: 'codex', items: project.codexSessions || [] },
+    { provider: 'gemini', items: project.geminiSessions || [] },
+    { provider: 'opencode', items: project.opencodeSessions || [] }
+  ];
+
+  return groups.flatMap(({ provider, items }) => items.map((item) => ({ ...item, provider, __provider: provider })))
+    .sort((a, b) => new Date(b.lastActivity || b.updated_at || b.createdAt || 0) - new Date(a.lastActivity || a.updated_at || a.createdAt || 0));
+}
+
+router.get('/providers', async (req, res) => {
+  try {
+    const providers = await discoverAllProviders({ projectPath: req.query.projectPath });
+    res.json({ success: true, providers });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/providers/:provider', async (req, res) => {
+  try {
+    const result = await discoverProvider(req.params.provider, { projectPath: req.query.projectPath });
+    res.json({ success: true, ...result });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/projects/:projectName/history-index', async (req, res) => {
+  try {
+    const projects = await getProjects();
+    const project = projects.find((entry) => entry.name === req.params.projectName);
+    if (!project) {
+      return res.status(404).json({ success: false, error: 'Project not found' });
+    }
+    res.json({ success: true, project: { name: project.name, fullPath: project.fullPath || project.path, displayName: project.displayName || project.name }, sessions: flattenProjectSessions(project) });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/sessions/:sessionId/resolve', async (req, res) => {
+  try {
+    const projects = await getProjects();
+    const requestedSessionId = String(req.params.sessionId || '').trim();
+    const providerHint = typeof req.query.provider === 'string' ? req.query.provider.trim().toLowerCase() : '';
+
+    if (!requestedSessionId) {
+      return res.status(400).json({ success: false, error: 'Session id is required' });
+    }
+
+    const providerOrder = [
+      providerHint,
+      'codex',
+      'claude',
+      'gemini',
+      'opencode'
+    ].filter((provider, index, all) => provider && all.indexOf(provider) === index);
+
+    const directProjectMatch = projects.find((project) => {
+      const flattened = flattenProjectSessions(project);
+      return flattened.some((session) => session.id === requestedSessionId);
+    });
+
+    if (directProjectMatch) {
+      const flattened = flattenProjectSessions(directProjectMatch);
+      const matchedSession = flattened.find((session) => session.id === requestedSessionId);
+
+      return res.json({
+        success: true,
+        found: true,
+        provider: matchedSession.provider,
+        session: matchedSession,
+        project: {
+          name: directProjectMatch.name,
+          fullPath: directProjectMatch.fullPath || directProjectMatch.path,
+          path: directProjectMatch.path,
+          displayName: directProjectMatch.displayName || directProjectMatch.name
+        }
+      });
+    }
+
+    for (const provider of providerOrder) {
+      const adapter = getProviderAdapter(provider);
+
+      for (const project of projects) {
+        let sessions = [];
+
+        try {
+          if (provider === 'claude') {
+            const result = await adapter.listSessions({ projectName: project.name, limit: 1000, offset: 0 });
+            sessions = Array.isArray(result) ? result : [];
+          } else {
+            sessions = await adapter.listSessions({ projectPath: project.fullPath || project.path, limit: 0 });
+          }
+        } catch (error) {
+          continue;
+        }
+
+        const matchedSession = sessions.find((session) => session.id === requestedSessionId);
+        if (!matchedSession) {
+          continue;
+        }
+
+        return res.json({
+          success: true,
+          found: true,
+          provider,
+          session: matchedSession,
+          project: {
+            name: project.name,
+            fullPath: project.fullPath || project.path,
+            path: project.path,
+            displayName: project.displayName || project.name
+          }
+        });
+      }
+    }
+
+    res.status(404).json({ success: true, found: false });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/sessions/:provider/:sessionId/events', async (req, res) => {
+  try {
+    const adapter = getProviderAdapter(req.params.provider);
+    const parsedLimit = req.query.limit ? parseInt(req.query.limit, 10) : null;
+    const parsedOffset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
+    const result = await adapter.loadEvents({
+      projectName: req.query.projectName,
+      projectPath: req.query.projectPath,
+      sessionId: req.params.sessionId,
+      limit: parsedLimit,
+      offset: parsedOffset
+    });
+
+    const events = Array.isArray(result) ? result : (result?.events || result?.messages || []);
+    const total = typeof result?.total === 'number' ? result.total : events.length;
+    const hasMore = typeof result?.hasMore === 'boolean' ? result.hasMore : false;
+    const offset = typeof result?.offset === 'number' ? result.offset : parsedOffset;
+    const limit = Object.prototype.hasOwnProperty.call(result || {}, 'limit')
+      ? result.limit
+      : parsedLimit;
+
+    const response = {
+      success: true,
+      provider: req.params.provider,
+      sessionId: req.params.sessionId,
+      events,
+      total,
+      hasMore,
+      offset,
+      limit
+    };
+
+    if (result && typeof result === 'object' && result.tokenUsage) {
+      response.tokenUsage = result.tokenUsage;
+    }
+
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/server/session-core/abortSession.js

@@ -0,0 +1,48 @@
+import { abortClaudeSDKSession } from '../claude-sdk.js';
+import { abortCodexSession } from '../openai-codex.js';
+import { abortGeminiSession } from '../gemini-cli.js';
+import { abortOpencodeSession } from '../opencode-cli.js';
+
+export const ABORTABLE_AGENT_PROVIDERS = ['claude', 'codex', 'gemini', 'opencode'];
+
+export function isAbortableAgentProvider(provider) {
+  return ABORTABLE_AGENT_PROVIDERS.includes(String(provider || '').trim().toLowerCase());
+}
+
+export async function abortAgentSession(provider, sessionId) {
+  const normalizedProvider = String(provider || 'claude').trim().toLowerCase();
+
+  if (normalizedProvider === 'codex') {
+    return abortCodexSession(sessionId);
+  }
+
+  if (normalizedProvider === 'gemini') {
+    return abortGeminiSession(sessionId);
+  }
+
+  if (normalizedProvider === 'opencode') {
+    return abortOpencodeSession(sessionId);
+  }
+
+  return abortClaudeSDKSession(sessionId);
+}
+
+export async function abortAgentSessionWithWriter({ provider = 'claude', sessionId, writer }) {
+  const normalizedProvider = String(provider || 'claude').trim().toLowerCase();
+  const success = await abortAgentSession(normalizedProvider, sessionId);
+  const payload = {
+    type: 'session-aborted',
+    sessionId,
+    provider: normalizedProvider,
+    success
+  };
+
+  if (writer && typeof writer.send === 'function') {
+    writer.send(payload);
+  }
+
+  return {
+    success,
+    payload
+  };
+}

package/server/session-core/eventStore.js

@@ -0,0 +1,139 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+
+import {
+  CONVERSATION_EVENT_KINDS,
+  isConversationEvent
+} from '../../shared/conversationEvents.js';
+
+const MIRRORED_EVENT_STORE_ROOT = path.join(os.homedir(), '.axhub-genie', 'session-events');
+const PERSISTED_EVENT_KINDS = new Set([
+  CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED,
+  CONVERSATION_EVENT_KINDS.ERROR,
+  CONVERSATION_EVENT_KINDS.APPROVAL_REQUEST,
+  CONVERSATION_EVENT_KINDS.APPROVAL_RESOLVED,
+  CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE
+]);
+
+function getSessionEventFilePath(provider, sessionId) {
+  return path.join(MIRRORED_EVENT_STORE_ROOT, String(provider || 'claude'), `${sessionId}.jsonl`);
+}
+
+function normalizePersistedEvents(events = []) {
+  return events.filter((event) => (
+    isConversationEvent(event) &&
+    event.sessionId &&
+    PERSISTED_EVENT_KINDS.has(event.kind)
+  ));
+}
+
+function sortObjectKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortObjectKeys);
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.keys(value)
+      .sort()
+      .reduce((accumulator, key) => {
+        accumulator[key] = sortObjectKeys(value[key]);
+        return accumulator;
+      }, {});
+  }
+
+  return value;
+}
+
+function createEventSignature(event) {
+  return JSON.stringify(sortObjectKeys({
+    kind: event.kind,
+    provider: event.provider,
+    sessionId: event.sessionId,
+    timestamp: event.timestamp,
+    payload: event.payload || {},
+    extensions: event.extensions || {},
+    rawRef: event.rawRef || null
+  }));
+}
+
+export async function appendMirroredConversationEvents(events = []) {
+  const normalizedEvents = normalizePersistedEvents(events);
+  if (normalizedEvents.length === 0) {
+    return;
+  }
+
+  const eventsByFile = new Map();
+  normalizedEvents.forEach((event) => {
+    const filePath = getSessionEventFilePath(event.provider, event.sessionId);
+    if (!eventsByFile.has(filePath)) {
+      eventsByFile.set(filePath, []);
+    }
+    eventsByFile.get(filePath).push(event);
+  });
+
+  await Promise.all(Array.from(eventsByFile.entries()).map(async ([filePath, fileEvents]) => {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const serialized = fileEvents.map((event) => JSON.stringify(event)).join('\n');
+    await fs.appendFile(filePath, `${serialized}\n`, 'utf8');
+  }));
+}
+
+export async function readMirroredConversationEvents(provider, sessionId) {
+  if (!provider || !sessionId) {
+    return [];
+  }
+
+  const filePath = getSessionEventFilePath(provider, sessionId);
+
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    return content
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(isConversationEvent);
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+}
+
+export function mergeConversationEventHistories(primaryEvents = [], mirroredEvents = []) {
+  const merged = [];
+  const seenSignatures = new Set();
+
+  [...primaryEvents, ...mirroredEvents].forEach((event) => {
+    if (!isConversationEvent(event)) {
+      return;
+    }
+
+    const signature = createEventSignature(event);
+    if (seenSignatures.has(signature)) {
+      return;
+    }
+
+    seenSignatures.add(signature);
+    merged.push(event);
+  });
+
+  merged.sort((left, right) => {
+    const leftTime = new Date(left.timestamp || 0).getTime();
+    const rightTime = new Date(right.timestamp || 0).getTime();
+    if (leftTime !== rightTime) {
+      return leftTime - rightTime;
+    }
+    return 0;
+  });
+
+  return merged;
+}

package/server/session-core/providerAdapters.js

@@ -0,0 +1,84 @@
+import { normalizeLegacyHistoryEntries, SUPPORTED_PROVIDERS } from '../../shared/conversationEvents.js';
+import { mergeConversationEventHistories, readMirroredConversationEvents } from './eventStore.js';
+import {
+  getSessionMessages,
+  getCodexSessionMessages,
+  getOpencodeSessionMessages,
+  getGeminiSessionMessages,
+  getSessions,
+  getCodexSessions,
+  getOpencodeSessions,
+  getGeminiSessions
+} from '../projects.js';
+
+async function flattenLegacyMessages(result) {
+  if (Array.isArray(result)) return result;
+  return Array.isArray(result?.messages) ? result.messages : [];
+}
+
+async function normalizeLegacyLoadResult(result, provider, sessionId) {
+  const messages = await flattenLegacyMessages(result);
+  const legacyEvents = normalizeLegacyHistoryEntries(messages, provider, sessionId);
+  const mirroredEvents = await readMirroredConversationEvents(provider, sessionId);
+  const events = mergeConversationEventHistories(legacyEvents, mirroredEvents);
+
+  if (Array.isArray(result)) {
+    return events;
+  }
+
+  return {
+    ...result,
+    events
+  };
+}
+
+const PROVIDER_ADAPTERS = {
+  claude: {
+    async listSessions({ projectName, limit = 50, offset = 0 }) {
+      const result = await getSessions(projectName, limit, offset);
+      return (result?.sessions || []).map((session) => ({ ...session, provider: 'claude' }));
+    },
+    async loadEvents({ projectName, sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getSessionMessages(projectName, sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'claude', sessionId);
+    }
+  },
+  codex: {
+    async listSessions({ projectPath, limit = 50 }) {
+      const sessions = await getCodexSessions(projectPath, { limit });
+      return sessions.map((session) => ({ ...session, provider: 'codex' }));
+    },
+    async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getCodexSessionMessages(sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'codex', sessionId);
+    }
+  },
+  gemini: {
+    async listSessions({ projectPath, limit = 50 }) {
+      const sessions = await getGeminiSessions(projectPath, { limit });
+      return sessions.map((session) => ({ ...session, provider: 'gemini' }));
+    },
+    async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getGeminiSessionMessages(sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'gemini', sessionId);
+    }
+  },
+  opencode: {
+    async listSessions({ projectPath, limit = 50 }) {
+      const sessions = await getOpencodeSessions(projectPath, { limit });
+      return sessions.map((session) => ({ ...session, provider: 'opencode' }));
+    },
+    async loadEvents({ sessionId, limit = null, offset = 0 }) {
+      const rawMessages = await getOpencodeSessionMessages(sessionId, limit, offset);
+      return normalizeLegacyLoadResult(rawMessages, 'opencode', sessionId);
+    }
+  }
+};
+
+export function getProviderAdapter(provider) {
+  const normalizedProvider = String(provider || '').toLowerCase();
+  if (!SUPPORTED_PROVIDERS.includes(normalizedProvider)) {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+  return PROVIDER_ADAPTERS[normalizedProvider];
+}