@holic512/slothtool 1.0.2 → 1.0.3

package/lib/plugin-manager.js

@@ -1,122 +1,320 @@
-const { execSync } = require('child_process');
+const {execSync} = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const registry = require('./registry');
-const { extractPluginAlias, getPluginDir, ensureDir, getPluginsDir } = require('./utils');
+const {extractPluginAlias, getPluginDir, ensureDir, getPluginsDir, getPluginConfigPath} = require('./utils');
+const {t} = require('./i18n');
 
 /**
  * 安装插件
  * @param {string} packageName - npm 包名 (例如: @slothtool/plugin-loc 或 plugin-loc)
  */
 function installPlugin(packageName) {
-  console.log(`Installing plugin: ${packageName}...`);
+    console.log(t('installing'), packageName + '...');
 
-  // 提取插件别名
-  const alias = extractPluginAlias(packageName);
+    // 提取插件别名
+    const alias = extractPluginAlias(packageName);
 
-  // 检查是否已安装
-  if (registry.hasPlugin(alias)) {
-    console.log(`Plugin "${alias}" is already installed.`);
-    console.log(`Run "slothtool uninstall ${alias}" first if you want to reinstall.`);
-    return;
-  }
+    // 检查是否已安装
+    if (registry.hasPlugin(alias)) {
+        console.log(t('alreadyInstalled', {alias}));
+        console.log(t('uninstallFirst', {alias}));
+        return;
+    }
 
-  // 确保插件目录存在
-  ensureDir(getPluginsDir());
+    // 确保插件目录存在
+    ensureDir(getPluginsDir());
 
-  const pluginDir = getPluginDir(alias);
-  ensureDir(pluginDir);
+    const pluginDir = getPluginDir(alias);
+    ensureDir(pluginDir);
 
-  try {
-    // 使用 npm install 安装插件到指定目录
-    console.log(`Installing to: ${pluginDir}`);
-    execSync(`npm install ${packageName} --prefix "${pluginDir}"`, {
-      stdio: 'inherit',
-      encoding: 'utf8'
-    });
+    try {
+        // 使用 npm install 安装插件到指定目录
+        console.log(t('installingTo'), pluginDir);
+        execSync(`npm install ${packageName} --prefix "${pluginDir}"`, {
+            stdio: 'inherit',
+            encoding: 'utf8'
+        });
 
-    // 读取插件的 package.json
-    const pkgPath = path.join(pluginDir, 'node_modules', packageName, 'package.json');
+        // 读取插件的 package.json
+        const pkgPath = path.join(pluginDir, 'node_modules', packageName, 'package.json');
 
-    if (!fs.existsSync(pkgPath)) {
-      throw new Error(`Package.json not found at: ${pkgPath}`);
-    }
+        if (!fs.existsSync(pkgPath)) {
+            throw new Error(`Package.json not found at: ${pkgPath}`);
+        }
 
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
 
-    // 获取 bin 路径
-    let binPath;
-    if (typeof pkg.bin === 'string') {
-      binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin);
-    } else if (typeof pkg.bin === 'object') {
-      // 如果 bin 是对象，取第一个值
-      const binKey = Object.keys(pkg.bin)[0];
-      binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin[binKey]);
-    } else {
-      throw new Error(`No bin field found in package.json for ${packageName}`);
+        // 获取 bin 路径
+        let binPath;
+        if (typeof pkg.bin === 'string') {
+            binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin);
+        } else if (typeof pkg.bin === 'object') {
+            // 如果 bin 是对象，取第一个值
+            const binKey = Object.keys(pkg.bin)[0];
+            binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin[binKey]);
+        } else {
+            throw new Error(`No bin field found in package.json for ${packageName}`);
+        }
+
+        // 验证 bin 文件存在
+        if (!fs.existsSync(binPath)) {
+            throw new Error(`Bin file not found at: ${binPath}`);
+        }
+
+        // 添加到注册表
+        registry.addPlugin(alias, {
+            name: packageName,
+            version: pkg.version,
+            binPath: binPath,
+            installedAt: new Date().toISOString()
+        });
+
+        console.log(t('installSuccess', {alias}));
+        console.log(t('installRun', {alias}));
+
+    } catch (error) {
+        console.error(t('installFailed', {packageName}), error.message);
+
+        // 清理失败的安装
+        if (fs.existsSync(pluginDir)) {
+            fs.rmSync(pluginDir, {recursive: true, force: true});
+        }
+
+        process.exit(1);
     }
+}
 
-    // 验证 bin 文件存在
-    if (!fs.existsSync(binPath)) {
-      throw new Error(`Bin file not found at: ${binPath}`);
+/**
+ * 卸载插件
+ * @param {string} alias - 插件别名
+ */
+function uninstallPlugin(alias) {
+    const plugin = registry.getPlugin(alias);
+
+    if (!plugin) {
+        console.error(t('notInstalled', {alias}));
+        process.exit(1);
     }
 
-    // 添加到注册表
-    registry.addPlugin(alias, {
-      name: packageName,
-      version: pkg.version,
-      binPath: binPath,
-      installedAt: new Date().toISOString()
-    });
+    console.log(t('uninstalling'), alias + '...');
 
-    console.log(`\n✓ Plugin "${alias}" installed successfully!`);
-    console.log(`  Run: slothtool ${alias} --help`);
+    // 显示将要删除的内容
+    const pluginDir = getPluginDir(alias);
+    const configPath = getPluginConfigPath(alias);
+    const hasConfig = fs.existsSync(configPath);
 
-  } catch (error) {
-    console.error(`\n✗ Failed to install plugin "${packageName}":`, error.message);
+    console.log(t('uninstallWillRemove'));
+    console.log(t('uninstallPluginDir', {dir: pluginDir}));
 
-    // 清理失败的安装
-    if (fs.existsSync(pluginDir)) {
-      fs.rmSync(pluginDir, { recursive: true, force: true });
+    if (hasConfig) {
+        console.log(t('uninstallConfigFile', {file: configPath}));
+    } else {
+        console.log(t('uninstallNoConfig'));
     }
 
-    process.exit(1);
-  }
+    console.log(t('uninstallRegistryEntry'));
+    console.log('');
+
+    try {
+        // 删除插件目录
+        if (fs.existsSync(pluginDir)) {
+            fs.rmSync(pluginDir, {recursive: true, force: true});
+        }
+
+        // 删除插件配置文件（如果存在）
+        if (hasConfig) {
+            fs.rmSync(configPath, {force: true});
+        }
+
+        // 从注册表移除
+        registry.removePlugin(alias);
+
+        console.log(t('uninstallSuccess', {alias}));
+
+    } catch (error) {
+        console.error(t('uninstallFailed', {alias}), error.message);
+        process.exit(1);
+    }
 }
 
 /**
- * 卸载插件
+ * 更新插件
  * @param {string} alias - 插件别名
  */
-function uninstallPlugin(alias) {
-  const plugin = registry.getPlugin(alias);
+function updatePlugin(alias) {
+    const plugin = registry.getPlugin(alias);
 
-  if (!plugin) {
-    console.error(`Plugin "${alias}" is not installed.`);
-    process.exit(1);
-  }
+    if (!plugin) {
+        console.error(t('notInstalled', {alias}));
+        process.exit(1);
+    }
 
-  console.log(`Uninstalling plugin: ${alias}...`);
+    console.log(t('updating'), `${alias} (${plugin.name})...`);
+    console.log(t('currentVersion'), plugin.version);
 
-  try {
-    // 删除插件目录
     const pluginDir = getPluginDir(alias);
-    if (fs.existsSync(pluginDir)) {
-      fs.rmSync(pluginDir, { recursive: true, force: true });
+    const packageName = plugin.name;
+
+    try {
+        // 使用 npm update 更新插件
+        console.log(t('checkingUpdates'));
+        execSync(`npm update ${packageName} --prefix "${pluginDir}"`, {
+            stdio: 'inherit',
+            encoding: 'utf8'
+        });
+
+        // 读取更新后的 package.json
+        const pkgPath = path.join(pluginDir, 'node_modules', packageName, 'package.json');
+
+        if (!fs.existsSync(pkgPath)) {
+            throw new Error(`Package.json not found at: ${pkgPath}`);
+        }
+
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+        // 检查版本是否有变化
+        if (pkg.version === plugin.version) {
+            console.log(t('alreadyLatest', {alias, version: pkg.version}));
+            return;
+        }
+
+        // 获取 bin 路径
+        let binPath;
+        if (typeof pkg.bin === 'string') {
+            binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin);
+        } else if (typeof pkg.bin === 'object') {
+            const binKey = Object.keys(pkg.bin)[0];
+            binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin[binKey]);
+        } else {
+            throw new Error(`No bin field found in package.json for ${packageName}`);
+        }
+
+        // 验证 bin 文件存在
+        if (!fs.existsSync(binPath)) {
+            throw new Error(`Bin file not found at: ${binPath}`);
+        }
+
+        // 更新注册表
+        registry.addPlugin(alias, {
+            name: packageName,
+            version: pkg.version,
+            binPath: binPath,
+            installedAt: plugin.installedAt,
+            updatedAt: new Date().toISOString()
+        });
+
+        console.log(t('updateSuccess', {alias, oldVersion: plugin.version, newVersion: pkg.version}));
+
+    } catch (error) {
+        console.error(t('updateFailed', {alias}), error.message);
+        process.exit(1);
+    }
+}
+
+/**
+ * 更新所有插件
+ */
+function updateAllPlugins() {
+    const plugins = registry.getAllPlugins();
+    const pluginList = Object.keys(plugins);
+
+    if (pluginList.length === 0) {
+        console.log(t('noPlugins'));
+        return;
     }
 
-    // 从注册表移除
-    registry.removePlugin(alias);
+    console.log(t('updateAll.title'));
+    console.log(t('updateAll.foundPlugins', {count: pluginList.length}));
+    console.log('');
+
+    let updatedCount = 0;
+    let alreadyLatestCount = 0;
+    let failedCount = 0;
+    const results = [];
+
+    for (const alias of pluginList) {
+        const plugin = plugins[alias];
+        console.log('─'.repeat(50));
+        console.log(t('updating'), `${alias} (${plugin.name})...`);
+        console.log(t('currentVersion'), plugin.version);
+
+        const pluginDir = getPluginDir(alias);
+        const packageName = plugin.name;
+
+        try {
+            // 使用 npm update 更新插件
+            execSync(`npm update ${packageName} --prefix "${pluginDir}"`, {
+                stdio: 'pipe',
+                encoding: 'utf8'
+            });
+
+            // 读取更新后的 package.json
+            const pkgPath = path.join(pluginDir, 'node_modules', packageName, 'package.json');
+
+            if (!fs.existsSync(pkgPath)) {
+                throw new Error(`Package.json not found at: ${pkgPath}`);
+            }
 
-    console.log(`✓ Plugin "${alias}" uninstalled successfully!`);
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+            // 检查版本是否有变化
+            if (pkg.version === plugin.version) {
+                console.log(t('alreadyLatest', {alias, version: pkg.version}));
+                alreadyLatestCount++;
+                results.push({alias, status: 'latest', version: pkg.version});
+            } else {
+                // 获取 bin 路径
+                let binPath;
+                if (typeof pkg.bin === 'string') {
+                    binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin);
+                } else if (typeof pkg.bin === 'object') {
+                    const binKey = Object.keys(pkg.bin)[0];
+                    binPath = path.join(pluginDir, 'node_modules', packageName, pkg.bin[binKey]);
+                } else {
+                    throw new Error(`No bin field found in package.json for ${packageName}`);
+                }
+
+                // 验证 bin 文件存在
+                if (!fs.existsSync(binPath)) {
+                    throw new Error(`Bin file not found at: ${binPath}`);
+                }
+
+                // 更新注册表
+                registry.addPlugin(alias, {
+                    name: packageName,
+                    version: pkg.version,
+                    binPath: binPath,
+                    installedAt: plugin.installedAt,
+                    updatedAt: new Date().toISOString()
+                });
+
+                console.log(t('updateSuccess', {alias, oldVersion: plugin.version, newVersion: pkg.version}));
+                updatedCount++;
+                results.push({alias, status: 'updated', oldVersion: plugin.version, newVersion: pkg.version});
+            }
+
+        } catch (error) {
+            console.error(t('updateFailed', {alias}), error.message);
+            failedCount++;
+            results.push({alias, status: 'failed', error: error.message});
+        }
+
+        console.log('');
+    }
 
-  } catch (error) {
-    console.error(`✗ Failed to uninstall plugin "${alias}":`, error.message);
-    process.exit(1);
-  }
+    // 显示总结
+    console.log('═'.repeat(50));
+    console.log(t('updateAll.summary'));
+    console.log(t('updateAll.totalPlugins', {count: pluginList.length}));
+    console.log(t('updateAll.updated', {count: updatedCount}));
+    console.log(t('updateAll.alreadyLatest', {count: alreadyLatestCount}));
+    console.log(t('updateAll.failed', {count: failedCount}));
 }
 
 module.exports = {
-  installPlugin,
-  uninstallPlugin
+    installPlugin,
+    uninstallPlugin,
+    updatePlugin,
+    updateAllPlugins
 };

package/lib/registry.js

@@ -1,28 +1,28 @@
 const fs = require('fs');
-const { getRegistryPath, ensureDir, getSlothToolHome } = require('./utils');
+const {getRegistryPath, ensureDir, getSlothToolHome} = require('./utils');
 
 /**
  * 读取注册表
  * @returns {Object} 注册表对象
  */
 function readRegistry() {
-  const registryPath = getRegistryPath();
+    const registryPath = getRegistryPath();
 
-  // 确保 .slothtool 目录存在
-  ensureDir(getSlothToolHome());
+    // 确保 .slothtool 目录存在
+    ensureDir(getSlothToolHome());
 
-  // 如果注册表文件不存在，返回空对象
-  if (!fs.existsSync(registryPath)) {
-    return { plugins: {} };
-  }
+    // 如果注册表文件不存在，返回空对象
+    if (!fs.existsSync(registryPath)) {
+        return {plugins: {}};
+    }
 
-  try {
-    const content = fs.readFileSync(registryPath, 'utf8');
-    return JSON.parse(content);
-  } catch (error) {
-    console.error('Failed to read registry:', error.message);
-    return { plugins: {} };
-  }
+    try {
+        const content = fs.readFileSync(registryPath, 'utf8');
+        return JSON.parse(content);
+    } catch (error) {
+        console.error('Failed to read registry:', error.message);
+        return {plugins: {}};
+    }
 }
 
 /**
@@ -30,17 +30,17 @@ function readRegistry() {
  * @param {Object} registry - 注册表对象
  */
 function writeRegistry(registry) {
-  const registryPath = getRegistryPath();
+    const registryPath = getRegistryPath();
 
-  // 确保 .slothtool 目录存在
-  ensureDir(getSlothToolHome());
+    // 确保 .slothtool 目录存在
+    ensureDir(getSlothToolHome());
 
-  try {
-    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf8');
-  } catch (error) {
-    console.error('Failed to write registry:', error.message);
-    throw error;
-  }
+    try {
+        fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf8');
+    } catch (error) {
+        console.error('Failed to write registry:', error.message);
+        throw error;
+    }
 }
 
 /**
@@ -49,9 +49,9 @@ function writeRegistry(registry) {
  * @param {Object} pluginInfo - 插件信息
  */
 function addPlugin(alias, pluginInfo) {
-  const registry = readRegistry();
-  registry.plugins[alias] = pluginInfo;
-  writeRegistry(registry);
+    const registry = readRegistry();
+    registry.plugins[alias] = pluginInfo;
+    writeRegistry(registry);
 }
 
 /**
@@ -59,9 +59,9 @@ function addPlugin(alias, pluginInfo) {
  * @param {string} alias - 插件别名
  */
 function removePlugin(alias) {
-  const registry = readRegistry();
-  delete registry.plugins[alias];
-  writeRegistry(registry);
+    const registry = readRegistry();
+    delete registry.plugins[alias];
+    writeRegistry(registry);
 }
 
 /**
@@ -70,8 +70,8 @@ function removePlugin(alias) {
  * @returns {Object|null} 插件信息，如果不存在返回 null
  */
 function getPlugin(alias) {
-  const registry = readRegistry();
-  return registry.plugins[alias] || null;
+    const registry = readRegistry();
+    return registry.plugins[alias] || null;
 }
 
 /**
@@ -79,8 +79,8 @@ function getPlugin(alias) {
  * @returns {Object} 所有插件的映射
  */
 function getAllPlugins() {
-  const registry = readRegistry();
-  return registry.plugins;
+    const registry = readRegistry();
+    return registry.plugins;
 }
 
 /**
@@ -89,16 +89,16 @@ function getAllPlugins() {
  * @returns {boolean} 是否已安装
  */
 function hasPlugin(alias) {
-  const registry = readRegistry();
-  return alias in registry.plugins;
+    const registry = readRegistry();
+    return alias in registry.plugins;
 }
 
 module.exports = {
-  readRegistry,
-  writeRegistry,
-  addPlugin,
-  removePlugin,
-  getPlugin,
-  getAllPlugins,
-  hasPlugin
+    readRegistry,
+    writeRegistry,
+    addPlugin,
+    removePlugin,
+    getPlugin,
+    getAllPlugins,
+    hasPlugin
 };

package/lib/settings.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const {getSettingsPath, ensureDir, getSlothToolHome} = require('./utils');
+
+/**
+ * 读取设置
+ * @returns {Object} 设置对象
+ */
+function readSettings() {
+    const settingsPath = getSettingsPath();
+
+    // 确保 .slothtool 目录存在
+    ensureDir(getSlothToolHome());
+
+    // 如果设置文件不存在，返回默认设置
+    if (!fs.existsSync(settingsPath)) {
+        return getDefaultSettings();
+    }
+
+    try {
+        const content = fs.readFileSync(settingsPath, 'utf8');
+        return JSON.parse(content);
+    } catch (error) {
+        console.error('Failed to read settings:', error.message);
+        return getDefaultSettings();
+    }
+}
+
+/**
+ * 写入设置
+ * @param {Object} settings - 设置对象
+ */
+function writeSettings(settings) {
+    const settingsPath = getSettingsPath();
+
+    // 确保 .slothtool 目录存在
+    ensureDir(getSlothToolHome());
+
+    try {
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+    } catch (error) {
+        console.error('Failed to write settings:', error.message);
+        throw error;
+    }
+}
+
+/**
+ * 获取默认设置
+ * @returns {Object} 默认设置对象
+ */
+function getDefaultSettings() {
+    return {
+        language: 'zh' // 默认中文，可选 'zh' 或 'en'
+    };
+}
+
+/**
+ * 获取当前语言设置
+ * @returns {string} 语言代码 ('zh' 或 'en')
+ */
+function getLanguage() {
+    const settings = readSettings();
+    return settings.language || 'zh';
+}
+
+/**
+ * 设置语言
+ * @param {string} language - 语言代码 ('zh' 或 'en')
+ */
+function setLanguage(language) {
+    if (language !== 'zh' && language !== 'en') {
+        throw new Error('Language must be "zh" or "en"');
+    }
+
+    const settings = readSettings();
+    settings.language = language;
+    writeSettings(settings);
+}
+
+module.exports = {
+    readSettings,
+    writeSettings,
+    getDefaultSettings,
+    getLanguage,
+    setLanguage
+};