momo-ai 1.0.74 → 1.0.75

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "momo-ai",
-    "version": "1.0.74",
+    "version": "1.0.75",
     "description": "Rachel Momo ( OpenSpec )",
     "main": "src/momo.js",
     "bin": {

package/src/executor/executeDocs.js

@@ -1,4 +1,5 @@
-const { spawn, execSync } = require('child_process');
+const { execSync } = require('child_process');
+const crypto = require('crypto');
 const fs = require('fs');
 const fsAsync = require('fs').promises;
 const path = require('path');
@@ -21,103 +22,80 @@ const _getObsidianConfigPath = () => {
     return path.join(xdgConfig, 'obsidian', 'obsidian.json');
 };
 
+/**
+ * 根据绝对路径生成确定性 vault ID（sha256 前 16 位 hex）
+ * 同一路径永远得到相同 ID，避免随机 ID 导致 Vault Not Found
+ * @param {string} absPath vault 绝对路径
+ * @returns {string}
+ */
+const _deriveVaultId = (absPath) => {
+    return crypto.createHash('sha256').update(absPath).digest('hex').slice(0, 16);
+};
+
 /**
  * 检查 Obsidian 是否已安装
- * @returns {Promise<boolean>}
+ * @returns {boolean}
  */
-const _isObsidianInstalled = async () => {
+const _isObsidianInstalled = () => {
     const platform = os.platform();
-    
+
     if (platform === 'darwin') {
-        // macOS: 检查 Applications 目录
-        const obsidianPath = '/Applications/Obsidian.app';
-        return fs.existsSync(obsidianPath);
-    } else if (platform === 'win32') {
-        // Windows: 检查常见安装路径或注册表
+        return fs.existsSync('/Applications/Obsidian.app');
+    }
+    if (platform === 'win32') {
         const localAppData = process.env.LOCALAPPDATA || '';
         const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
-        const possiblePaths = [
+        return [
             path.join(localAppData, 'Obsidian', 'Obsidian.exe'),
-            path.join(programFiles, 'Obsidian', 'Obsidian.exe')
-        ];
-        return possiblePaths.some(p => fs.existsSync(p));
-    } else {
-        // Linux: 检查 which obsidian 或常见路径
+            path.join(programFiles, 'Obsidian', 'Obsidian.exe'),
+        ].some(p => fs.existsSync(p));
+    }
+
+    // Linux
+    try {
+        execSync('which obsidian', { stdio: 'pipe' });
+        return true;
+    } catch {
+        if (fs.existsSync('/snap/bin/obsidian')) return true;
         try {
-            execSync('which obsidian', { stdio: 'pipe' });
+            execSync('flatpak list | grep -i obsidian', { stdio: 'pipe' });
             return true;
         } catch {
-            // 检查 flatpak 或 snap 安装
-            const snapPath = '/snap/bin/obsidian';
-            const flatpakCheck = () => {
-                try {
-                    execSync('flatpak list | grep -i obsidian', { stdio: 'pipe' });
-                    return true;
-                } catch {
-                    return false;
-                }
-            };
-            return fs.existsSync(snapPath) || flatpakCheck();
+            return false;
         }
     }
 };
 
 /**
- * 检查指定 vault 是否正在运行
- * @param {string} vaultPath vault 路径
+ * 检查指定 vault 是否正在运行（open: true）
+ * @param {string} vaultId 确定性 vault ID
  * @returns {Promise<boolean>}
  */
-const _isVaultRunning = async (vaultPath) => {
+const _isVaultRunning = async (vaultId) => {
     const configPath = _getObsidianConfigPath();
-
     try {
-        if (!fs.existsSync(configPath)) {
-            return false;
-        }
-
-        const content = await fsAsync.readFile(configPath, 'utf8');
-        const config = JSON.parse(content);
-
-        // 检查是否有 vault 的 open 状态为 true 且路径匹配
-        const openVault = Object.values(config.vaults || {}).find(
-            vault => vault.path === vaultPath && vault.open === true
-        );
-
-        return !!openVault;
+        if (!fs.existsSync(configPath)) return false;
+        const config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
+        const vault = (config.vaults || {})[vaultId];
+        return vault ? vault.open === true : false;
     } catch {
         return false;
     }
 };
 
 /**
- * 关闭指定 vault 的 Obsidian 窗口
- * 通过更新配置文件将 vault 的 open 状态设为 false
- * @param {string} vaultPath vault 路径
+ * 关闭指定 vault（将 open 设为 false）
+ * @param {string} vaultId 确定性 vault ID
  * @returns {Promise<void>}
  */
-const _closeVault = async (vaultPath) => {
+const _closeVault = async (vaultId) => {
     const configPath = _getObsidianConfigPath();
-
     try {
-        if (!fs.existsSync(configPath)) {
-            return;
-        }
-
-        const content = await fsAsync.readFile(configPath, 'utf8');
-        const config = JSON.parse(content);
-
-        // 找到对应的 vault 并设置 open 为 false
-        let updated = false;
-        for (const [id, vault] of Object.entries(config.vaults || {})) {
-            if (vault.path === vaultPath && vault.open === true) {
-                config.vaults[id].open = false;
-                updated = true;
-            }
-        }
-
-        if (updated) {
-            await fsAsync.writeFile(configPath, JSON.stringify(config), 'utf8');
-            // 等待配置生效
+        if (!fs.existsSync(configPath)) return;
+        const config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
+        if (config.vaults && config.vaults[vaultId] && config.vaults[vaultId].open) {
+            const updatedVaults = { ...config.vaults, [vaultId]: { ...config.vaults[vaultId], open: false } };
+            await fsAsync.writeFile(configPath, JSON.stringify({ ...config, vaults: updatedVaults }), 'utf8');
             await new Promise(resolve => setTimeout(resolve, 500));
         }
     } catch (error) {
@@ -126,64 +104,43 @@ const _closeVault = async (vaultPath) => {
 };
 
 /**
- * 生成 vault ID（模仿 Obsidian 的 16 位十六进制 ID）
- * @returns {string}
- */
-const _generateVaultId = () => {
-    const chars = '0123456789abcdef';
-    let id = '';
-    for (let i = 0; i < 16; i++) {
-        id += chars[Math.floor(Math.random() * chars.length)];
-    }
-    return id;
-};
-
-/**
- * 注册 vault 到 Obsidian 配置
- * @param {string} vaultPath vault 路径
- * @returns {Promise<string|null>} 返回 vault ID，失败返回 null
+ * 注册 vault 到 obsidian.json，使用确定性 ID。
+ * 若已存在同路径的旧随机 ID 记录，先删除旧记录再以确定性 ID 写入。
+ * @param {string} vaultPath vault 绝对路径
+ * @returns {Promise<string|null>} 确定性 vault ID，失败返回 null
  */
 const _registerVaultToObsidian = async (vaultPath) => {
     const configPath = _getObsidianConfigPath();
-    
+    const vaultId = _deriveVaultId(vaultPath);
+
     try {
         let config = { vaults: {}, frame: 'custom' };
-        
-        // 读取现有配置
         if (fs.existsSync(configPath)) {
-            const content = await fsAsync.readFile(configPath, 'utf8');
-            config = JSON.parse(content);
+            config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
         }
-        
-        // 检查 vault 是否已存在
-        const existingVault = Object.entries(config.vaults || {}).find(
-            ([id, vault]) => vault.path === vaultPath
-        );
-        
-        let vaultId;
-        if (existingVault) {
-            // 已存在，更新 ts 和 open 状态
-            [vaultId] = existingVault;
-            config.vaults[vaultId].ts = Date.now();
-            config.vaults[vaultId].open = true;
-        } else {
-            // 新 vault，生成 ID 并添加
-            vaultId = _generateVaultId();
-            config.vaults[vaultId] = {
-                path: vaultPath,
-                ts: Date.now(),
-                open: true
-            };
+        if (!config.vaults) config.vaults = {};
+
+        // 删除所有同路径的旧记录（key 可能是随机 ID）
+        const updatedVaults = {};
+        for (const [id, vault] of Object.entries(config.vaults)) {
+            if (vault.path !== vaultPath) {
+                updatedVaults[id] = vault;
+            }
         }
-        
-        // 确保配置目录存在
+
+        // 写入确定性 ID 记录
+        updatedVaults[vaultId] = {
+            path: vaultPath,
+            ts: Date.now(),
+            open: true,
+        };
+
         const configDir = path.dirname(configPath);
         if (!fs.existsSync(configDir)) {
             await fsAsync.mkdir(configDir, { recursive: true });
         }
-        
-        // 写入配置
-        await fsAsync.writeFile(configPath, JSON.stringify(config), 'utf8');
+
+        await fsAsync.writeFile(configPath, JSON.stringify({ ...config, vaults: updatedVaults }), 'utf8');
         return vaultId;
     } catch (error) {
         Ec.warn(`⚠ 无法注册 vault 到配置: ${error.message}`);
@@ -193,28 +150,20 @@ const _registerVaultToObsidian = async (vaultPath) => {
 
 const _removeVaultRegistration = async (vaultPath) => {
     const configPath = _getObsidianConfigPath();
-
     try {
-        if (!fs.existsSync(configPath)) {
-            return false;
-        }
-
-        const content = await fsAsync.readFile(configPath, 'utf8');
-        const config = JSON.parse(content);
+        if (!fs.existsSync(configPath)) return false;
+        const config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
         let updated = false;
-
+        const updatedVaults = {};
         for (const [id, vault] of Object.entries(config.vaults || {})) {
             if (vault.path === vaultPath) {
-                delete config.vaults[id];
                 updated = true;
+            } else {
+                updatedVaults[id] = vault;
             }
         }
-
-        if (!updated) {
-            return false;
-        }
-
-        await fsAsync.writeFile(configPath, JSON.stringify(config), 'utf8');
+        if (!updated) return false;
+        await fsAsync.writeFile(configPath, JSON.stringify({ ...config, vaults: updatedVaults }), 'utf8');
         return true;
     } catch (error) {
         Ec.warn(`⚠ 清理 vault 注册失败: ${error.message}`);
@@ -224,12 +173,8 @@ const _removeVaultRegistration = async (vaultPath) => {
 
 const _removeLocalObsidianConfig = async (targetDir) => {
     const obsidianConfigPath = path.join(targetDir, '.obsidian');
-
     try {
-        if (!fs.existsSync(obsidianConfigPath)) {
-            return false;
-        }
-
+        if (!fs.existsSync(obsidianConfigPath)) return false;
         await fsAsync.rm(obsidianConfigPath, { recursive: true, force: true });
         return true;
     } catch (error) {
@@ -241,134 +186,34 @@ const _removeLocalObsidianConfig = async (targetDir) => {
 const _resetVaultConfig = async (targetDir) => {
     Ec.waiting(`正在清理 Obsidian 配置: ${targetDir.cyan}...`);
 
-    const isVaultRunning = await _isVaultRunning(targetDir);
-    if (isVaultRunning) {
-        await _closeVault(targetDir);
-    }
+    const vaultId = _deriveVaultId(targetDir);
+    const isRunning = await _isVaultRunning(vaultId);
+    if (isRunning) await _closeVault(vaultId);
 
     const removedVault = await _removeVaultRegistration(targetDir);
     const removedConfig = await _removeLocalObsidianConfig(targetDir);
 
-    if (removedVault) {
-        Ec.info('✓ 已移除 Obsidian 中的 vault 注册');
-    } else {
-        Ec.info('✓ 未发现需要移除的 vault 注册');
-    }
-
-    if (removedConfig) {
-        Ec.info('✓ 已删除目标目录下的 .obsidian 配置');
-    } else {
-        Ec.info('✓ 目标目录下不存在 .obsidian 配置');
-    }
-
+    Ec.info(removedVault ? '✓ 已移除 Obsidian 中的 vault 注册' : '✓ 未发现需要移除的 vault 注册');
+    Ec.info(removedConfig ? '✓ 已删除目标目录下的 .obsidian 配置' : '✓ 目标目录下不存在 .obsidian 配置');
     Ec.info('✅ Obsidian 配置清理完成');
 };
 
 /**
- * 使用 Obsidian 打开目录
- * 直接调用 Obsidian 可执行文件，传递目录路径作为参数
- * @param {string} targetDir 目标目录绝对路径
- * @param {string} vaultId vault ID，用于 URL scheme
- * @returns {Promise<void>}
+ * 通过 Obsidian URL scheme 打开 vault
+ * 使用确定性 ID，保证每次打开的 ID 与注册时一致
+ * @param {string} vaultId 确定性 vault ID
+ * @returns {void}
  */
-const _openWithObsidian = async (targetDir, vaultId = null) => {
+const _openWithObsidian = (vaultId) => {
+    const url = `obsidian://open?vault=${vaultId}`;
     const platform = os.platform();
 
     if (platform === 'darwin') {
-        // macOS: 使用 obsidian-cli 直接打开目录
-        const python3Path = '/opt/miniconda3/bin/python3';
-        return new Promise((resolve, reject) => {
-            const child = spawn(python3Path, ['-m', 'obsidian_cli', 'open', targetDir], {
-                stdio: 'ignore'
-            });
-
-            child.on('error', (error) => {
-                reject(new Error(`启动 Obsidian 失败: ${error.message}`));
-            });
-
-            child.on('close', (code) => {
-                if (code === 0) {
-                    setTimeout(() => resolve(), 1000);
-                } else {
-                    reject(new Error(`启动 Obsidian 失败，退出码: ${code}`));
-                }
-            });
-        });
+        execSync(`open "${url}"`, { stdio: 'ignore' });
     } else if (platform === 'win32') {
-        // Windows: 查找 Obsidian.exe 并直接打开目录
-        const localAppData = process.env.LOCALAPPDATA || '';
-        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
-        const possiblePaths = [
-            path.join(localAppData, 'Obsidian', 'Obsidian.exe'),
-            path.join(programFiles, 'Obsidian', 'Obsidian.exe')
-        ];
-        
-        const obsidianExe = possiblePaths.find(p => fs.existsSync(p));
-        if (!obsidianExe) {
-            throw new Error('找不到 Obsidian 可执行文件');
-        }
-        
-        return new Promise((resolve, reject) => {
-            const child = spawn(obsidianExe, [targetDir], {
-                detached: true,
-                stdio: 'ignore'
-            });
-            
-            child.on('error', (error) => {
-                reject(new Error(`启动 Obsidian 失败: ${error.message}`));
-            });
-            
-            child.unref();
-            
-            setTimeout(() => {
-                resolve();
-            }, 500);
-        });
+        execSync(`start "" "${url}"`, { stdio: 'ignore', shell: true });
     } else {
-        // Linux: 尝试直接启动 obsidian 命令
-        const snapPath = '/snap/bin/obsidian';
-        const flatpakPath = 'flatpak run md.obsidian.Obsidian';
-        let obsidianCmd = 'obsidian';
-        let args = [targetDir];
-        let useShell = false;
-        
-        // 检查 snap 安装
-        if (fs.existsSync(snapPath)) {
-            obsidianCmd = snapPath;
-        } else {
-            // 尝试 flatpak
-            try {
-                execSync('flatpak list | grep -i obsidian', { stdio: 'pipe' });
-                obsidianCmd = flatpakPath;
-                useShell = true;
-                args = [targetDir];
-            } catch {
-                // 使用默认命令
-            }
-        }
-        
-        return new Promise((resolve, reject) => {
-            const spawnOptions = {
-                detached: true,
-                stdio: 'ignore'
-            };
-            
-            if (useShell) {
-                spawnOptions.shell = true;
-            }
-            
-            const child = spawn(obsidianCmd, args, spawnOptions);
-            
-            child.on('error', (error) => {
-                reject(new Error(`启动 Obsidian 失败: ${error.message}`));
-            });
-            
-            child.unref();
-            
-            setTimeout(() => {
-                resolve();
-            }, 500);
-        });
+        execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
     }
 };
 
@@ -377,38 +222,34 @@ const _openWithObsidian = async (targetDir, vaultId = null) => {
  * @returns {string}
  */
 const _getOsName = () => {
-    const platform = os.platform();
-    switch (platform) {
+    switch (os.platform()) {
         case 'darwin': return 'macOS';
         case 'win32': return 'Windows';
         case 'linux': return 'Linux';
-        default: return platform;
+        default: return os.platform();
     }
 };
 
 /**
- * 初始化 .obsidian 目录
- * 从模板目录复制默认配置
+ * 初始化 .obsidian 目录（从模板复制）
  * @param {string} targetDir 目标目录
- * @returns {Promise<boolean>} 是否成功初始化
+ * @returns {Promise<boolean>}
  */
 const _initObsidianConfig = async (targetDir) => {
     const obsidianSourcePath = path.resolve(__dirname, '../_template/LAIN/.obsidian');
     const obsidianTargetPath = path.join(targetDir, '.obsidian');
-    
-    // 检查模板目录是否存在
+
     if (!fs.existsSync(obsidianSourcePath)) {
         Ec.warn(`⚠ 模板目录不存在: ${obsidianSourcePath}`);
         return false;
     }
-    
+
     try {
         const stat = await fsAsync.stat(obsidianSourcePath);
         if (!stat.isDirectory()) {
             Ec.warn(`⚠ 模板路径不是目录: ${obsidianSourcePath}`);
             return false;
         }
-        
         Ec.waiting('正在初始化 .obsidian 配置...');
         await copyDir(obsidianSourcePath, obsidianTargetPath);
         Ec.info('✓ 已创建 .obsidian 配置目录');
@@ -420,38 +261,27 @@ const _initObsidianConfig = async (targetDir) => {
 };
 
 /**
- * 更新目标目录的 .gitignore 文件
- * 添加 .obsidian/workspace.json 到忽略列表
+ * 更新 .gitignore，添加 .obsidian/workspace.json
  * @param {string} targetDir 目标目录
  * @returns {Promise<void>}
  */
 const _updateGitignore = async (targetDir) => {
     const gitignorePath = path.join(targetDir, '.gitignore');
     const ignoreEntry = '.obsidian/workspace.json';
-    
+
     try {
-        let gitignoreContent = '';
-        
-        // 读取现有的 .gitignore 内容
-        if (fs.existsSync(gitignorePath)) {
-            gitignoreContent = await fsAsync.readFile(gitignorePath, 'utf8');
-        }
-        
-        // 检查是否已经包含该条目
-        if (gitignoreContent.includes(ignoreEntry)) {
+        let content = fs.existsSync(gitignorePath)
+            ? await fsAsync.readFile(gitignorePath, 'utf8')
+            : '';
+
+        if (content.includes(ignoreEntry)) {
             Ec.info('✓ .gitignore 已包含 .obsidian/workspace.json');
             return;
         }
-        
-        // 添加条目
-        if (gitignoreContent && !gitignoreContent.endsWith('\n')) {
-            gitignoreContent += '\n';
-        }
-        
-        gitignoreContent += `${ignoreEntry}\n`;
-        
-        // 写入 .gitignore 文件
-        await fsAsync.writeFile(gitignorePath, gitignoreContent, 'utf8');
+
+        if (content && !content.endsWith('\n')) content += '\n';
+        content += `${ignoreEntry}\n`;
+        await fsAsync.writeFile(gitignorePath, content, 'utf8');
         Ec.info('✓ 已添加 .obsidian/workspace.json 到 .gitignore');
     } catch (error) {
         Ec.warn(`⚠ 更新 .gitignore 失败: ${error.message}`);
@@ -460,7 +290,6 @@ const _updateGitignore = async (targetDir) => {
 
 module.exports = async () => {
     try {
-        // 1. 解析 -d/-r 参数，获取目标目录
         const dirArg = parseOptional('dir', 'd');
         const removeArg = parseOptional('remove', 'r');
 
@@ -479,15 +308,12 @@ module.exports = async () => {
         Ec.info(`📁 目标目录: ${targetDir.cyan}`);
         Ec.info(`💻 操作系统: ${_getOsName().cyan}`);
 
-        // 2. 检查目标目录是否存在
         if (!fs.existsSync(targetDir)) {
             Ec.error(`❌ 目录不存在: ${targetDir}`);
             process.exit(1);
         }
 
-        // 3. 检查目录是否是文件夹
-        const stat = fs.statSync(targetDir);
-        if (!stat.isDirectory()) {
+        if (!fs.statSync(targetDir).isDirectory()) {
             Ec.error(`❌ 路径不是目录: ${targetDir}`);
             process.exit(1);
         }
@@ -498,11 +324,10 @@ module.exports = async () => {
             process.exit(0);
         }
 
-        // 4. 检查 .obsidian 配置是否存在，不存在则自动初始化
+        // 检查 .obsidian 配置，不存在则初始化
         const obsidianConfigPath = path.join(targetDir, '.obsidian');
         if (!fs.existsSync(obsidianConfigPath)) {
             Ec.warn(`⚠ 目录中不存在 .obsidian 配置，正在自动初始化...`);
-            
             const initSuccess = await _initObsidianConfig(targetDir);
             if (!initSuccess) {
                 Ec.error('❌ 无法初始化 .obsidian 配置');
@@ -516,14 +341,9 @@ module.exports = async () => {
             Ec.info('✓ 检测到 .obsidian 配置');
         }
 
-        // 4.5. 更新 .gitignore，添加 .obsidian/workspace.json
         await _updateGitignore(targetDir);
 
-        // 5. 检查 Obsidian 是否已安装
-        Ec.waiting('正在检查 Obsidian 安装状态...');
-        const obsidianInstalled = await _isObsidianInstalled();
-
-        if (!obsidianInstalled) {
+        if (!_isObsidianInstalled()) {
             Ec.error('❌ 未检测到 Obsidian 安装');
             console.log('');
             Ec.error('请先安装 Obsidian:');
@@ -534,32 +354,28 @@ module.exports = async () => {
 
         Ec.info('✓ Obsidian 已安装');
 
-        // 6. 检查当前 vault 是否正在运行
-        const isVaultRunning = await _isVaultRunning(targetDir);
-        if (isVaultRunning) {
-            Ec.waiting('检测到该 vault 正在运行，正在关闭以重新加载...');
-            await _closeVault(targetDir);
+        // 派生确定性 ID 并注册（自动替换旧随机 ID 记录）
+        Ec.waiting('正在注册 vault...');
+        const vaultId = await _registerVaultToObsidian(targetDir);
+        if (!vaultId) {
+            Ec.error('❌ Vault 注册失败，无法打开');
+            process.exit(1);
         }
+        Ec.info(`✓ Vault 已注册 (ID: ${vaultId})`);
 
-        // 7. 注册 vault 到 Obsidian 配置
-        Ec.waiting('正在注册 vault 到 Obsidian...');
-        const vaultId = await _registerVaultToObsidian(targetDir);
-        if (vaultId) {
-            Ec.info(`✓ Vault 已注册 (ID: ${vaultId.substring(0, 8)}...)`);
-        } else {
-            Ec.warn('⚠ Vault 注册失败，将尝试直接打开');
+        // 若 vault 正在运行，先关闭再重新打开
+        const isRunning = await _isVaultRunning(vaultId);
+        if (isRunning) {
+            Ec.waiting('检测到该 vault 正在运行，正在关闭以重新加载...');
+            await _closeVault(vaultId);
         }
 
-        // 8. 使用 Obsidian 打开目录
         Ec.waiting(`正在使用 Obsidian 打开: ${targetDir.cyan}...`);
-
         try {
-            await _openWithObsidian(targetDir, vaultId);
+            _openWithObsidian(vaultId);
             console.log('');
-            Ec.info(`✅ 已成功打开 Obsidian`);
-            if (vaultId) {
-                Ec.info(`💡 提示: 该 vault 现在会出现在 Obsidian 的本地仓库列表中`);
-            }
+            Ec.info('✅ 已成功打开 Obsidian');
+            Ec.info('💡 提示: 该 vault 现在会出现在 Obsidian 的本地仓库列表中');
             console.log('');
         } catch (error) {
             console.log('');
@@ -569,10 +385,7 @@ module.exports = async () => {
             console.log('');
         }
 
-        // 短暂延迟后退出，确保进程完成
-        setTimeout(() => {
-            process.exit(0);
-        }, 1000);
+        setTimeout(() => process.exit(0), 1000);
 
     } catch (error) {
         Ec.error(`❌ 执行失败: ${error.message}`);