dantelabs-agentic-school 1.0.0 → 1.2.0

package/cli/src/commands/uninstall.js

@@ -8,14 +8,15 @@ import { getMarketplaceConfig } from '../lib/config.js';
 import { uninstallPlugin } from '../lib/installer.js';
 import logger from '../utils/logger.js';
 import { resolvePath } from '../utils/fs-utils.js';
+import { t } from '../i18n/index.js';
 
 export default function uninstallCommand(program) {
   program
     .command('uninstall <plugin>')
     .alias('rm')
-    .description('Uninstall a plugin from your project')
-    .option('-p, --path <path>', 'Project path (default: current directory)')
-    .option('-y, --yes', 'Skip confirmation prompt')
+    .description(t('uninstall.description'))
+    .option('-p, --path <path>', t('uninstall.optionPath'))
+    .option('-y, --yes', t('uninstall.optionYes'))
     .action(async (pluginName, options) => {
       const spinner = ora();
 
@@ -28,12 +29,12 @@ export default function uninstallCommand(program) {
 
         // Check if .claude directory exists
         if (!existsSync(claudeDir)) {
-          logger.error(`No .claude directory found at ${targetPath}`);
+          logger.error(t('uninstall.noClaudeDir', { path: targetPath }));
           process.exit(1);
         }
 
         // Load marketplace config to get plugin info
-        spinner.start('Loading plugin registry...');
+        spinner.start(t('uninstall.loadingRegistry'));
         const config = await getMarketplaceConfig();
         spinner.stop();
 
@@ -41,9 +42,9 @@ export default function uninstallCommand(program) {
         const plugin = config.plugins.find((p) => p.name === pluginName);
 
         if (!plugin) {
-          logger.error(`Plugin '${pluginName}' not found in registry`);
+          logger.error(t('uninstall.pluginNotFound', { name: pluginName }));
           console.log();
-          console.log('Available plugins:');
+          console.log(`${t('common.availablePlugins')}:`);
           config.plugins.forEach((p) => {
             console.log(`  - ${chalk.cyan(p.name)}`);
           });
@@ -52,22 +53,24 @@ export default function uninstallCommand(program) {
 
         // Show what will be removed
         console.log();
-        console.log(chalk.bold(`Will remove ${chalk.cyan(plugin.name)}:`));
+        console.log(
+          chalk.bold(t('uninstall.willRemove', { name: chalk.cyan(plugin.name) }))
+        );
         const components = plugin.components || {};
 
         if (components.agents?.length) {
           console.log(
-            chalk.gray(`  Agents: ${components.agents.join(', ')}`)
+            chalk.gray(`  ${t('common.agents')}: ${components.agents.join(', ')}`)
           );
         }
         if (components.commands?.length) {
           console.log(
-            chalk.gray(`  Commands: /${components.commands.join(', /')}`)
+            chalk.gray(`  ${t('common.commands')}: /${components.commands.join(', /')}`)
           );
         }
         if (components.skills?.length) {
           console.log(
-            chalk.gray(`  Skills: ${components.skills.join(', ')}`)
+            chalk.gray(`  ${t('common.skills')}: ${components.skills.join(', ')}`)
           );
         }
         console.log();
@@ -78,29 +81,33 @@ export default function uninstallCommand(program) {
             {
               type: 'confirm',
               name: 'confirm',
-              message: `Are you sure you want to uninstall ${plugin.name}?`,
+              message: t('uninstall.confirmUninstall', { name: plugin.name }),
               default: false
             }
           ]);
 
           if (!confirm) {
-            logger.info('Uninstall cancelled');
+            logger.info(t('uninstall.uninstallCancelled'));
             return;
           }
         }
 
         // Uninstall
-        spinner.start(`Uninstalling ${chalk.cyan(plugin.name)}...`);
+        spinner.start(t('uninstall.uninstalling', { name: chalk.cyan(plugin.name) }));
 
         const results = await uninstallPlugin(plugin, claudeDir);
 
-        spinner.succeed(`Uninstalled ${chalk.cyan(plugin.name)}`);
+        spinner.succeed(t('uninstall.uninstalled', { name: chalk.cyan(plugin.name) }));
 
         // Summary
         console.log();
         console.log(
           chalk.gray(
-            `Removed: ${results.agents} agents, ${results.commands} commands, ${results.skills} skills`
+            t('uninstall.removedSummary', {
+              agents: results.agents,
+              commands: results.commands,
+              skills: results.skills
+            })
           )
         );
       } catch (error) {

package/cli/src/i18n/index.js

@@ -0,0 +1,96 @@
+/**
+ * Internationalization (i18n) module
+ * Default language: English (en)
+ * Supported languages: en, ko
+ */
+
+import en from './locales/en.js';
+import ko from './locales/ko.js';
+
+const locales = { en, ko };
+
+// Default language
+let currentLocale = 'en';
+
+/**
+ * Set the current locale
+ * @param {string} locale - Locale code (en, ko)
+ */
+export function setLocale(locale) {
+  if (locales[locale]) {
+    currentLocale = locale;
+  } else {
+    console.warn(`Locale '${locale}' not supported. Using 'en' as default.`);
+    currentLocale = 'en';
+  }
+}
+
+/**
+ * Get the current locale
+ * @returns {string} Current locale code
+ */
+export function getLocale() {
+  return currentLocale;
+}
+
+/**
+ * Get available locales
+ * @returns {string[]} Array of locale codes
+ */
+export function getAvailableLocales() {
+  return Object.keys(locales);
+}
+
+/**
+ * Get translation for a key path
+ * @param {string} keyPath - Dot-separated key path (e.g., 'install.description')
+ * @param {object} params - Parameters to interpolate
+ * @returns {string} Translated string
+ */
+export function t(keyPath, params = {}) {
+  const keys = keyPath.split('.');
+  let value = locales[currentLocale];
+
+  for (const key of keys) {
+    if (value && typeof value === 'object' && key in value) {
+      value = value[key];
+    } else {
+      // Fallback to English
+      value = locales.en;
+      for (const k of keys) {
+        if (value && typeof value === 'object' && k in value) {
+          value = value[k];
+        } else {
+          return keyPath; // Return key if not found
+        }
+      }
+      break;
+    }
+  }
+
+  if (typeof value !== 'string') {
+    return keyPath;
+  }
+
+  // Interpolate parameters: {name} -> value
+  return value.replace(/\{(\w+)\}/g, (_, key) => {
+    return params[key] !== undefined ? params[key] : `{${key}}`;
+  });
+}
+
+/**
+ * Get all translations for a section
+ * @param {string} section - Section name (e.g., 'install', 'list')
+ * @returns {object} Section translations
+ */
+export function getSection(section) {
+  return locales[currentLocale][section] || locales.en[section] || {};
+}
+
+export default {
+  setLocale,
+  getLocale,
+  getAvailableLocales,
+  t,
+  getSection
+};

package/cli/src/i18n/locales/en.js

@@ -0,0 +1,107 @@
+/**
+ * English translations (default)
+ */
+export default {
+  // Common
+  common: {
+    plugins: 'plugins',
+    agents: 'agents',
+    commands: 'commands',
+    skills: 'skills',
+    version: 'version',
+    install: 'Install',
+    summary: 'Summary',
+    location: 'Location',
+    external: 'External',
+    availablePlugins: 'Available plugins',
+    yes: 'yes',
+    no: 'no'
+  },
+
+  // CLI descriptions
+  cli: {
+    description: 'Dante Labs Agentic School - Claude Code Plugin Installer',
+    examples: 'Examples',
+    moreInfo: 'More info',
+    installAllPlugins: '# Install all plugins',
+    installSpecificPlugin: '# Install specific plugin',
+    installCustomPath: '# Install to custom path',
+    listPlugins: '# List available plugins',
+    showPluginInfo: '# Show plugin info'
+  },
+
+  // Install command
+  install: {
+    description: 'Install plugins to your project',
+    optionPath: 'Installation path (default: current directory)',
+    optionForce: 'Force overwrite existing files',
+    optionAll: 'Install all available plugins',
+    optionNoCommon: 'Skip common utilities',
+    optionDryRun: 'Show what would be installed without making changes',
+    installTarget: 'Installation target',
+    loadingRegistry: 'Loading plugin registry...',
+    registryLoaded: 'Plugin registry loaded',
+    confirmInstallAll: 'Install all {count} plugins?',
+    installCancelled: 'Installation cancelled',
+    pluginNotFound: "Plugin '{name}' not found",
+    dryRunTitle: 'Dry run - would install:',
+    dryRunFooter: 'Run without --dry-run to install.',
+    installing: 'Installing {name}...',
+    installingComponent: 'Installing {plugin}: {type} {name}',
+    installed: 'Installed {name}',
+    failedToInstall: 'Failed to install {name}: {error}',
+    successMessage: 'Successfully installed {count} plugin(s)',
+    componentSummary: '{agents} agents, {commands} commands, {skills} skills',
+    nextSteps: 'Next steps',
+    nextStep1: 'Run {command} to see available commands',
+    nextStep2: 'Try {command}',
+    externalSkillsRequired: 'External skills required'
+  },
+
+  // List command
+  list: {
+    description: 'List all available plugins',
+    optionJson: 'Output as JSON',
+    optionVerbose: 'Show detailed information',
+    title: 'Dante Labs Agentic School - Available Plugins',
+    summaryText: '{plugins} plugins, {agents} agents, {commands} commands, {skills} skills',
+    installHint: 'Install: npx dantelabs-agentic-school install [plugin-name]'
+  },
+
+  // Info command
+  info: {
+    description: 'Show detailed information about a plugin',
+    optionJson: 'Output as JSON',
+    pluginNotFound: "Plugin '{name}' not found",
+    agents: 'Agents',
+    commands: 'Commands',
+    skills: 'Skills',
+    externalSkillsRequired: 'External Skills Required',
+    installHint: 'Install'
+  },
+
+  // Uninstall command
+  uninstall: {
+    description: 'Uninstall a plugin from your project',
+    optionPath: 'Project path (default: current directory)',
+    optionYes: 'Skip confirmation prompt',
+    noClaudeDir: 'No .claude directory found at {path}',
+    loadingRegistry: 'Loading plugin registry...',
+    pluginNotFound: "Plugin '{name}' not found in registry",
+    willRemove: 'Will remove {name}:',
+    confirmUninstall: 'Are you sure you want to uninstall {name}?',
+    uninstallCancelled: 'Uninstall cancelled',
+    uninstalling: 'Uninstalling {name}...',
+    uninstalled: 'Uninstalled {name}',
+    removedSummary: 'Removed: {agents} agents, {commands} commands, {skills} skills'
+  },
+
+  // Logger
+  logger: {
+    info: 'info',
+    success: 'success',
+    warn: 'warn',
+    error: 'error',
+    debug: 'debug'
+  }
+};

package/cli/src/i18n/locales/ko.js

@@ -0,0 +1,107 @@
+/**
+ * Korean translations
+ */
+export default {
+  // Common
+  common: {
+    plugins: '플러그인',
+    agents: '에이전트',
+    commands: '명령어',
+    skills: '스킬',
+    version: '버전',
+    install: '설치',
+    summary: '요약',
+    location: '위치',
+    external: '외부',
+    availablePlugins: '사용 가능한 플러그인',
+    yes: '예',
+    no: '아니오'
+  },
+
+  // CLI descriptions
+  cli: {
+    description: 'Dante Labs Agentic School - Claude Code 플러그인 설치 도구',
+    examples: '사용 예시',
+    moreInfo: '자세한 정보',
+    installAllPlugins: '# 전체 플러그인 설치',
+    installSpecificPlugin: '# 특정 플러그인 설치',
+    installCustomPath: '# 경로 지정 설치',
+    listPlugins: '# 플러그인 목록 조회',
+    showPluginInfo: '# 플러그인 상세 정보'
+  },
+
+  // Install command
+  install: {
+    description: '프로젝트에 플러그인 설치',
+    optionPath: '설치 경로 (기본: 현재 디렉토리)',
+    optionForce: '기존 파일 강제 덮어쓰기',
+    optionAll: '모든 플러그인 설치',
+    optionNoCommon: 'common 유틸리티 제외',
+    optionDryRun: '실제 설치 없이 미리보기',
+    installTarget: '설치 대상 경로',
+    loadingRegistry: '플러그인 목록 불러오는 중...',
+    registryLoaded: '플러그인 목록 로드 완료',
+    confirmInstallAll: '전체 {count}개 플러그인을 설치할까요?',
+    installCancelled: '설치가 취소되었습니다',
+    pluginNotFound: "플러그인 '{name}'을(를) 찾을 수 없습니다",
+    dryRunTitle: '미리보기 - 설치 예정:',
+    dryRunFooter: '--dry-run 없이 실행하면 설치됩니다.',
+    installing: '{name} 설치 중...',
+    installingComponent: '{plugin} 설치 중: {type} {name}',
+    installed: '{name} 설치 완료',
+    failedToInstall: '{name} 설치 실패: {error}',
+    successMessage: '{count}개 플러그인 설치 완료',
+    componentSummary: '에이전트 {agents}개, 명령어 {commands}개, 스킬 {skills}개',
+    nextSteps: '다음 단계',
+    nextStep1: '{command} 실행하여 사용 가능한 명령어 확인',
+    nextStep2: '{command} 명령어 사용해보기',
+    externalSkillsRequired: '필요한 외부 스킬'
+  },
+
+  // List command
+  list: {
+    description: '사용 가능한 플러그인 목록 조회',
+    optionJson: 'JSON 형식으로 출력',
+    optionVerbose: '상세 정보 표시',
+    title: 'Dante Labs Agentic School - 플러그인 목록',
+    summaryText: '플러그인 {plugins}개, 에이전트 {agents}개, 명령어 {commands}개, 스킬 {skills}개',
+    installHint: '설치: npx dantelabs-agentic-school install [플러그인명]'
+  },
+
+  // Info command
+  info: {
+    description: '플러그인 상세 정보 조회',
+    optionJson: 'JSON 형식으로 출력',
+    pluginNotFound: "플러그인 '{name}'을(를) 찾을 수 없습니다",
+    agents: '에이전트',
+    commands: '명령어',
+    skills: '스킬',
+    externalSkillsRequired: '필요한 외부 스킬',
+    installHint: '설치 명령어'
+  },
+
+  // Uninstall command
+  uninstall: {
+    description: '프로젝트에서 플러그인 제거',
+    optionPath: '프로젝트 경로 (기본: 현재 디렉토리)',
+    optionYes: '확인 프롬프트 건너뛰기',
+    noClaudeDir: '{path}에 .claude 디렉토리가 없습니다',
+    loadingRegistry: '플러그인 목록 불러오는 중...',
+    pluginNotFound: "플러그인 '{name}'이(가) 레지스트리에 없습니다",
+    willRemove: '{name} 제거 예정:',
+    confirmUninstall: '{name}을(를) 정말 삭제하시겠습니까?',
+    uninstallCancelled: '삭제가 취소되었습니다',
+    uninstalling: '{name} 삭제 중...',
+    uninstalled: '{name} 삭제 완료',
+    removedSummary: '삭제됨: 에이전트 {agents}개, 명령어 {commands}개, 스킬 {skills}개'
+  },
+
+  // Logger
+  logger: {
+    info: '정보',
+    success: '성공',
+    warn: '경고',
+    error: '오류',
+    debug: '디버그'
+  }
+};

package/cli/src/lib/config.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from 'fs/promises';
+import { readFile, writeFile, readdir } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
 import { fileURLToPath } from 'url';
@@ -7,6 +7,9 @@ import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+// Package root directory
+const PACKAGE_ROOT = join(__dirname, '../../..');
+
 const CONFIG_CACHE_FILE = '.dantelabs-cache.json';
 const CACHE_TTL = 1000 * 60 * 60; // 1 hour
 
@@ -124,6 +127,118 @@ async function saveCachedConfig(config) {
   }
 }
 
+/**
+ * Normalize source path (handle both 'path' and 'source' fields)
+ */
+export function getSourcePath(plugin) {
+  const source = plugin.source || plugin.path;
+  if (!source) return `plugins/${plugin.name}`;
+  return source.replace(/^\.\//, '');
+}
+
+/**
+ * Discover components by scanning local plugin directory
+ */
+async function discoverLocalComponents(pluginPath) {
+  const components = { agents: [], commands: [], skills: [] };
+
+  // Scan agents directory
+  const agentsDir = join(pluginPath, 'agents');
+  if (existsSync(agentsDir)) {
+    const files = await readdir(agentsDir);
+    components.agents = files
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''));
+  }
+
+  // Scan commands directory
+  const commandsDir = join(pluginPath, 'commands');
+  if (existsSync(commandsDir)) {
+    const files = await readdir(commandsDir);
+    components.commands = files
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''));
+  }
+
+  // Scan skills directory
+  const skillsDir = join(pluginPath, 'skills');
+  if (existsSync(skillsDir)) {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    components.skills = entries
+      .filter(e => e.isDirectory())
+      .map(e => e.name);
+  }
+
+  return components;
+}
+
+/**
+ * Discover components from remote GitHub directory
+ */
+async function discoverRemoteComponents(remotePath) {
+  const components = { agents: [], commands: [], skills: [] };
+
+  const fetchDir = async (path) => {
+    const url = `${GITHUB_CONFIG.apiBase}/contents/${path}?ref=${GITHUB_CONFIG.branch}`;
+    const response = await fetch(url, {
+      headers: {
+        'Accept': 'application/vnd.github.v3+json',
+        'User-Agent': 'dantelabs-agentic-school-cli'
+      }
+    });
+    if (!response.ok) return [];
+    return response.json();
+  };
+
+  // Scan agents directory
+  try {
+    const agentsContents = await fetchDir(`${remotePath}/agents`);
+    components.agents = agentsContents
+      .filter(f => f.type === 'file' && f.name.endsWith('.md'))
+      .map(f => f.name.replace('.md', ''));
+  } catch (e) { /* no agents dir */ }
+
+  // Scan commands directory
+  try {
+    const commandsContents = await fetchDir(`${remotePath}/commands`);
+    components.commands = commandsContents
+      .filter(f => f.type === 'file' && f.name.endsWith('.md'))
+      .map(f => f.name.replace('.md', ''));
+  } catch (e) { /* no commands dir */ }
+
+  // Scan skills directory
+  try {
+    const skillsContents = await fetchDir(`${remotePath}/skills`);
+    components.skills = skillsContents
+      .filter(f => f.type === 'dir')
+      .map(f => f.name);
+  } catch (e) { /* no skills dir */ }
+
+  return components;
+}
+
+/**
+ * Enrich plugin with discovered components
+ */
+export async function enrichPluginWithComponents(plugin) {
+  // If components already exist, return as is
+  if (plugin.components && Object.keys(plugin.components).length > 0) {
+    return plugin;
+  }
+
+  const sourcePath = getSourcePath(plugin);
+  const localPath = join(PACKAGE_ROOT, sourcePath);
+
+  let components;
+  if (existsSync(localPath)) {
+    components = await discoverLocalComponents(localPath);
+  } else {
+    components = await discoverRemoteComponents(sourcePath);
+  }
+
+  return { ...plugin, components };
+}
+
 /**
  * Validate plugin name
  */

package/cli/src/lib/installer.js

@@ -46,6 +46,87 @@ async function copyDirectory(src, dest) {
   }
 }
 
+/**
+ * Discover components by scanning plugin directory
+ */
+async function discoverComponents(localPath) {
+  const components = { agents: [], commands: [], skills: [] };
+
+  // Scan agents directory
+  const agentsDir = join(localPath, 'agents');
+  if (existsSync(agentsDir)) {
+    const files = await readdir(agentsDir);
+    components.agents = files
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''));
+  }
+
+  // Scan commands directory
+  const commandsDir = join(localPath, 'commands');
+  if (existsSync(commandsDir)) {
+    const files = await readdir(commandsDir);
+    components.commands = files
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''));
+  }
+
+  // Scan skills directory
+  const skillsDir = join(localPath, 'skills');
+  if (existsSync(skillsDir)) {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    components.skills = entries
+      .filter(e => e.isDirectory())
+      .map(e => e.name);
+  }
+
+  return components;
+}
+
+/**
+ * Discover components from remote GitHub directory
+ */
+async function discoverRemoteComponents(remotePath) {
+  const { getDirectoryContents } = await import('./downloader.js');
+  const components = { agents: [], commands: [], skills: [] };
+
+  // Scan agents directory
+  try {
+    const agentsContents = await getDirectoryContents(`${remotePath}/agents`);
+    components.agents = agentsContents
+      .filter(f => f.type === 'file' && f.name.endsWith('.md'))
+      .map(f => f.name.replace('.md', ''));
+  } catch (e) { /* no agents dir */ }
+
+  // Scan commands directory
+  try {
+    const commandsContents = await getDirectoryContents(`${remotePath}/commands`);
+    components.commands = commandsContents
+      .filter(f => f.type === 'file' && f.name.endsWith('.md'))
+      .map(f => f.name.replace('.md', ''));
+  } catch (e) { /* no commands dir */ }
+
+  // Scan skills directory
+  try {
+    const skillsContents = await getDirectoryContents(`${remotePath}/skills`);
+    components.skills = skillsContents
+      .filter(f => f.type === 'dir')
+      .map(f => f.name);
+  } catch (e) { /* no skills dir */ }
+
+  return components;
+}
+
+/**
+ * Normalize source path (handle both 'path' and 'source' fields)
+ */
+function getSourcePath(plugin) {
+  // Support both old 'path' format and new 'source' format
+  const source = plugin.source || plugin.path;
+  if (!source) return `plugins/${plugin.name}`;
+  // Remove leading './' if present
+  return source.replace(/^\.\//, '');
+}
+
 /**
  * Install a single plugin to .claude directory
  *
@@ -64,13 +145,22 @@ async function copyDirectory(src, dest) {
 export async function installPlugin(plugin, claudeDir, options = {}) {
   const { force = false, onProgress } = options;
   const pluginName = plugin.name;
-  const components = plugin.components || {};
-  const sourcePath = plugin.path; // e.g., "plugins/brand-analytics"
+  const sourcePath = getSourcePath(plugin); // e.g., "plugins/brand-analytics"
 
   // Determine if we should use local or remote source
   const useLocalSource = hasLocalSource(sourcePath);
   const localSourcePath = join(PACKAGE_ROOT, sourcePath);
 
+  // Discover components dynamically (or use provided components for backward compatibility)
+  let components = plugin.components;
+  if (!components || Object.keys(components).length === 0) {
+    if (useLocalSource) {
+      components = await discoverComponents(localSourcePath);
+    } else {
+      components = await discoverRemoteComponents(sourcePath);
+    }
+  }
+
   // Create base directories
   await ensureDir(join(claudeDir, 'agents'));
   await ensureDir(join(claudeDir, 'commands'));
@@ -194,7 +284,20 @@ export async function installPlugin(plugin, claudeDir, options = {}) {
  */
 export async function uninstallPlugin(plugin, claudeDir) {
   const pluginName = plugin.name;
-  const components = plugin.components || {};
+  const sourcePath = getSourcePath(plugin);
+
+  // Discover components dynamically (or use provided components for backward compatibility)
+  let components = plugin.components;
+  if (!components || Object.keys(components).length === 0) {
+    const useLocalSource = hasLocalSource(sourcePath);
+    const localSourcePath = join(PACKAGE_ROOT, sourcePath);
+
+    if (useLocalSource) {
+      components = await discoverComponents(localSourcePath);
+    } else {
+      components = await discoverRemoteComponents(sourcePath);
+    }
+  }
 
   const results = {
     plugin: pluginName,