@axhub/genie 0.2.7 → 0.2.8

package/server/projects.js

@@ -1107,14 +1107,27 @@ async function getSessionMessages(projectName, sessionId, limit = null, offset =
 // Rename a project's display name
 async function renameProject(projectName, newDisplayName) {
   const config = await loadProjectConfig();
+  const existingConfig = config[projectName] && typeof config[projectName] === 'object'
+    ? config[projectName]
+    : {};
+  const trimmedDisplayName = typeof newDisplayName === 'string'
+    ? newDisplayName.trim()
+    : '';
   
-  if (!newDisplayName || newDisplayName.trim() === '') {
-    // Remove custom name if empty, will fall back to auto-generated
-    delete config[projectName];
+  if (!trimmedDisplayName) {
+    // Remove only the custom display name while preserving other metadata such as
+    // manuallyAdded/originalPath so externally added projects do not disappear.
+    const { displayName: _removedDisplayName, ...remainingConfig } = existingConfig;
+
+    if (Object.keys(remainingConfig).length === 0) {
+      delete config[projectName];
+    } else {
+      config[projectName] = remainingConfig;
+    }
   } else {
-    // Set custom display name
     config[projectName] = {
-      displayName: newDisplayName.trim()
+      ...existingConfig,
+      displayName: trimmedDisplayName
     };
   }
   
@@ -1252,7 +1265,41 @@ async function addProjectManually(projectPath, displayName = null) {
   const projectDir = path.join(os.homedir(), '.claude', 'projects', projectName);
 
   if (config[projectName]) {
-    throw new Error(`Project already configured for path: ${absolutePath}`);
+    const existingConfig = config[projectName] && typeof config[projectName] === 'object'
+      ? config[projectName]
+      : {};
+    const hasManualMetadata = Boolean(existingConfig.manuallyAdded || existingConfig.originalPath || existingConfig.path);
+
+    if (hasManualMetadata) {
+      throw new Error(`Project already configured for path: ${absolutePath}`);
+    }
+
+    // Recover historical broken entries that lost their manual-project metadata
+    // during a rename, which otherwise makes the project invisible in the sidebar
+    // while still blocking re-adding the same workspace.
+    config[projectName] = {
+      ...existingConfig,
+      manuallyAdded: true,
+      originalPath: absolutePath
+    };
+
+    if (displayName) {
+      config[projectName].displayName = displayName;
+    }
+
+    await saveProjectConfig(config);
+
+    return {
+      name: projectName,
+      path: absolutePath,
+      fullPath: absolutePath,
+      displayName: config[projectName].displayName || await generateDisplayName(projectName, absolutePath),
+      isManuallyAdded: true,
+      sessions: [],
+      codexSessions: [],
+      opencodeSessions: [],
+      geminiSessions: []
+    };
   }
 
   // Allow adding projects even if the directory exists - this enables tracking
@@ -1730,43 +1777,42 @@ async function deleteOpencodeSession(sessionId) {
   }
 }
 
-async function getGeminiSessions(projectPath, options = {}) {
-  const { limit = 5 } = options;
-  try {
-    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
-    try {
-      await fs.access(geminiTmpDir);
-    } catch {
-      return [];
-    }
+async function findGeminiSessionFiles() {
+  return findFilesRecursively(
+    path.join(os.homedir(), '.gemini', 'tmp'),
+    (entryName, fullPath) => (
+      entryName.endsWith('.json') &&
+      /[\\/]chats[\\/]/.test(fullPath)
+    )
+  );
+}
 
-    const projectHash = crypto.createHash('sha256').update(projectPath).digest('hex');
-    const chatsDir = path.join(geminiTmpDir, projectHash, 'chats');
+function inferGeminiProjectHash(filePath, parsedSession = null) {
+  const explicitHash = typeof parsedSession?.projectHash === 'string'
+    ? parsedSession.projectHash.trim()
+    : '';
+  if (explicitHash) {
+    return explicitHash.toLowerCase();
+  }
 
-    try {
-      await fs.access(chatsDir);
-    } catch {
-      return [];
-    }
+  const parentDir = path.basename(path.dirname(path.dirname(filePath)));
+  if (/^[a-f0-9]{64}$/i.test(parentDir)) {
+    return parentDir.toLowerCase();
+  }
 
-    const entries = await fs.readdir(chatsDir, { withFileTypes: true });
-    const sessionFiles = entries
-      .filter(e => e.isFile() && e.name.endsWith('.json'))
-      .map(e => path.join(chatsDir, e.name));
+  return '';
+}
 
-    const sessions = [];
-    for (const filePath of sessionFiles) {
-      try {
-        const sessionData = await parseGeminiSessionFile(filePath);
-        if (!sessionData?.id) continue;
-        sessions.push(sessionData);
-      } catch (error) {
-        console.warn(`Could not parse Gemini session file ${filePath}:`, error.message);
-      }
-    }
+async function getGeminiSessions(projectPath, options = {}) {
+  const { limit = 5 } = options;
+  const normalizedProjectPath = normalizeComparableProjectPath(projectPath);
+  if (!normalizedProjectPath) {
+    return [];
+  }
 
-    sessions.sort((a, b) => new Date(b.lastActivity) - new Date(a.lastActivity));
-    return limit > 0 ? sessions.slice(0, limit) : sessions;
+  try {
+    const lookup = await buildGeminiSessionsLookup([normalizedProjectPath], { limit });
+    return lookup.get(normalizedProjectPath) || [];
   } catch (error) {
     console.error('Error fetching Gemini sessions:', error);
     return [];
@@ -1805,6 +1851,7 @@ async function parseGeminiSessionFile(filePath) {
     lastActivity,
     createdAt: data?.startTime || lastActivity,
     model: messages.filter(m => m?.model).slice(-1)[0]?.model || null,
+    projectHash: inferGeminiProjectHash(filePath, data),
     provider: 'gemini',
     filePath
   };
@@ -1884,73 +1931,69 @@ async function buildGeminiSessionsLookup(projectPaths, options = {}) {
     (projectPaths || []).map(normalizeComparableProjectPath).filter(Boolean)
   ));
 
+  if (normalizedProjectPaths.length === 0) {
+    return new Map();
+  }
+
   const cacheKey = JSON.stringify({ projectPaths: normalizedProjectPaths, limit });
   return getCachedProviderSessionLookup('gemini', cacheKey, async () => {
-    const sessionsByProjectPath = new Map();
-
-    for (const normalizedProjectPath of normalizedProjectPaths) {
-      const projectHash = crypto.createHash('sha256').update(normalizedProjectPath).digest('hex');
-      const chatsDir = path.join(os.homedir(), '.gemini', 'tmp', projectHash, 'chats');
+    const projectHashToPath = new Map(
+      normalizedProjectPaths.map((normalizedProjectPath) => ([
+        crypto.createHash('sha256').update(normalizedProjectPath).digest('hex'),
+        normalizedProjectPath
+      ]))
+    );
+    const sessionsByProjectPath = new Map(
+      normalizedProjectPaths.map((normalizedProjectPath) => [normalizedProjectPath, []])
+    );
+    const sessionFiles = await findGeminiSessionFiles();
 
+    for (const filePath of sessionFiles) {
       try {
-        const entries = await fs.readdir(chatsDir, { withFileTypes: true });
-        const sessionFiles = entries
-          .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-          .map((entry) => path.join(chatsDir, entry.name));
+        const sessionData = await parseGeminiSessionFile(filePath);
+        if (!sessionData?.id) {
+          continue;
+        }
 
-        const sessions = [];
-        for (const filePath of sessionFiles) {
-          try {
-            const sessionData = await parseGeminiSessionFile(filePath);
-            if (sessionData?.id) {
-              sessions.push(sessionData);
-            }
-          } catch (error) {
-            console.warn(`Could not parse Gemini session file ${filePath}:`, error.message);
-          }
+        const normalizedProjectPath = projectHashToPath.get(sessionData.projectHash || '');
+        if (!normalizedProjectPath) {
+          continue;
         }
 
-        sessions.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
-        sessionsByProjectPath.set(
-          normalizedProjectPath,
-          limit > 0 ? sessions.slice(0, limit) : sessions
-        );
-      } catch (_) {
-        sessionsByProjectPath.set(normalizedProjectPath, []);
+        sessionsByProjectPath.get(normalizedProjectPath)?.push(sessionData);
+      } catch (error) {
+        console.warn(`Could not parse Gemini session file ${filePath}:`, error.message);
       }
     }
 
+    for (const [normalizedProjectPath, sessions] of sessionsByProjectPath.entries()) {
+      sessions.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
+      sessionsByProjectPath.set(
+        normalizedProjectPath,
+        limit > 0 ? sessions.slice(0, limit) : sessions
+      );
+    }
+
     return sessionsByProjectPath;
   });
 }
 
 async function getGeminiSessionMessages(sessionId, limit = null, offset = 0) {
   try {
-    const geminiTmpDir = path.join(os.homedir(), '.gemini', 'tmp');
-    const findSessionFile = async (dir) => {
+    const sessionFiles = await findGeminiSessionFiles();
+    let sessionFilePath = null;
+
+    for (const filePath of sessionFiles) {
       try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          const fullPath = path.join(dir, entry.name);
-          if (entry.isDirectory()) {
-            const found = await findSessionFile(fullPath);
-            if (found) return found;
-            continue;
-          }
-          if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
-          try {
-            const raw = await fs.readFile(fullPath, 'utf8');
-            const parsed = JSON.parse(raw);
-            if (parsed?.sessionId === sessionId) {
-              return fullPath;
-            }
-          } catch {}
+        const raw = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.sessionId === sessionId) {
+          sessionFilePath = filePath;
+          break;
         }
       } catch {}
-      return null;
-    };
+    }
 
-    const sessionFilePath = await findSessionFile(geminiTmpDir);
     if (!sessionFilePath) {
       return { messages: [], total: 0, hasMore: false };
     }