claude-termux 1.0.3 → 2.0.0

package/bin/mcp-install.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MCP_CONFIG_URL = 'https://raw.githubusercontent.com/zesbe/claude-mcp-config/main/mcp.json';
+const HOME = os.homedir();
+const MCP_PATH = path.join(HOME, '.mcp.json');
+
+console.log('🚀 ClaudeAll MCP Config Installer\n');
+
+// Backup existing config
+if (fs.existsSync(MCP_PATH)) {
+    const backup = `${MCP_PATH}.backup.${Date.now()}`;
+    fs.copyFileSync(MCP_PATH, backup);
+    console.log(`📦 Backed up existing config to ${backup}`);
+}
+
+// Download MCP config
+console.log('📥 Downloading MCP config...');
+
+https.get(MCP_CONFIG_URL, (res) => {
+    let data = '';
+    res.on('data', chunk => data += chunk);
+    res.on('end', () => {
+        try {
+            // Validate JSON
+            JSON.parse(data);
+            fs.writeFileSync(MCP_PATH, data);
+            console.log(`✅ Installed MCP config to ${MCP_PATH}\n`);
+            
+            const config = JSON.parse(data);
+            const servers = Object.keys(config.mcpServers || {});
+            console.log('MCP Servers installed:');
+            servers.forEach((s, i) => console.log(`  ${i+1}. ${s}`));
+            console.log('\n🎉 Run "claude" to start with MCP enabled!');
+        } catch (e) {
+            console.error('❌ Invalid JSON response');
+            process.exit(1);
+        }
+    });
+}).on('error', (e) => {
+    console.error(`❌ Download failed: ${e.message}`);
+    process.exit(1);
+});

package/bin/skills-cli.js

@@ -0,0 +1,722 @@
+#!/usr/bin/env node
+
+/**
+ * ClaudeAll Skills CLI
+ * Advanced skill management beyond skills.sh
+ *
+ * Features skills.sh DOESN'T have:
+ * - Skill testing/validation
+ * - Quality scoring
+ * - Dependencies management
+ * - Skill scaffolding
+ * - Local development
+ * - Hooks system
+ * - Offline support
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const CLAUDE_DIR = path.join(process.env.HOME, '.claude');
+const SKILLS_DIR = path.join(CLAUDE_DIR, 'skills');
+const SKILLS_REGISTRY = path.join(CLAUDE_DIR, '.skills-registry.json');
+
+// Colors for terminal
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  gray: '\x1b[90m',
+};
+
+const c = (color, text) => `${colors[color]}${text}${colors.reset}`;
+
+// ============================================
+// SKILL SCHEMA
+// ============================================
+const SKILL_SCHEMA = {
+  required: ['name', 'description', 'version'],
+  optional: ['author', 'license', 'dependencies', 'hooks', 'tags', 'agents', 'quality'],
+  defaults: {
+    version: '1.0.0',
+    license: 'MIT',
+    agents: ['claude-code', 'cursor', 'copilot'],
+    tags: [],
+    dependencies: [],
+    hooks: {
+      preInstall: null,
+      postInstall: null,
+      preUninstall: null,
+      postUninstall: null,
+    },
+    quality: {
+      tested: false,
+      documented: false,
+      examples: false,
+    }
+  }
+};
+
+// ============================================
+// UTILITY FUNCTIONS
+// ============================================
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadRegistry() {
+  if (fs.existsSync(SKILLS_REGISTRY)) {
+    return JSON.parse(fs.readFileSync(SKILLS_REGISTRY, 'utf8'));
+  }
+  return { skills: {}, installed: [], lastUpdate: null };
+}
+
+function saveRegistry(registry) {
+  registry.lastUpdate = new Date().toISOString();
+  fs.writeFileSync(SKILLS_REGISTRY, JSON.stringify(registry, null, 2));
+}
+
+function parseSkillMd(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+
+  const frontmatter = {};
+  frontmatterMatch[1].split('\n').forEach(line => {
+    const [key, ...valueParts] = line.split(':');
+    if (key && valueParts.length) {
+      frontmatter[key.trim()] = valueParts.join(':').trim();
+    }
+  });
+
+  return {
+    ...frontmatter,
+    content: content.replace(/^---\n[\s\S]*?\n---\n*/, '')
+  };
+}
+
+function calculateQualityScore(skillPath) {
+  let score = 0;
+  const checks = [];
+
+  const skillDir = fs.statSync(skillPath).isDirectory() ? skillPath : path.dirname(skillPath);
+  const skillName = path.basename(skillDir);
+
+  // Check 1: Has SKILL.md (25 points)
+  const skillMd = path.join(skillDir, 'SKILL.md');
+  if (fs.existsSync(skillMd)) {
+    score += 25;
+    checks.push({ name: 'Has SKILL.md', passed: true, points: 25 });
+
+    const content = fs.readFileSync(skillMd, 'utf8');
+
+    // Check 2: Has frontmatter (10 points)
+    if (content.startsWith('---')) {
+      score += 10;
+      checks.push({ name: 'Has frontmatter', passed: true, points: 10 });
+    } else {
+      checks.push({ name: 'Has frontmatter', passed: false, points: 0 });
+    }
+
+    // Check 3: Has description (10 points)
+    if (content.includes('description:')) {
+      score += 10;
+      checks.push({ name: 'Has description', passed: true, points: 10 });
+    } else {
+      checks.push({ name: 'Has description', passed: false, points: 0 });
+    }
+
+    // Check 4: Has examples/usage section (15 points)
+    if (content.toLowerCase().includes('## example') || content.toLowerCase().includes('## usage')) {
+      score += 15;
+      checks.push({ name: 'Has examples', passed: true, points: 15 });
+    } else {
+      checks.push({ name: 'Has examples', passed: false, points: 0 });
+    }
+
+    // Check 5: Has code blocks (10 points)
+    if (content.includes('```')) {
+      score += 10;
+      checks.push({ name: 'Has code blocks', passed: true, points: 10 });
+    } else {
+      checks.push({ name: 'Has code blocks', passed: false, points: 0 });
+    }
+  } else {
+    checks.push({ name: 'Has SKILL.md', passed: false, points: 0 });
+  }
+
+  // Check 6: Has tests (15 points)
+  const testFiles = fs.readdirSync(skillDir).filter(f => f.startsWith('test-'));
+  if (testFiles.length > 0) {
+    score += 15;
+    checks.push({ name: `Has tests (${testFiles.length})`, passed: true, points: 15 });
+  } else {
+    checks.push({ name: 'Has tests', passed: false, points: 0 });
+  }
+
+  // Check 7: Has skill.json (10 points)
+  const skillJson = path.join(skillDir, 'skill.json');
+  if (fs.existsSync(skillJson)) {
+    score += 10;
+    checks.push({ name: 'Has skill.json', passed: true, points: 10 });
+  } else {
+    checks.push({ name: 'Has skill.json', passed: false, points: 0 });
+  }
+
+  // Check 8: Has CREATION-LOG.md (5 points)
+  if (fs.existsSync(path.join(skillDir, 'CREATION-LOG.md'))) {
+    score += 5;
+    checks.push({ name: 'Has creation log', passed: true, points: 5 });
+  } else {
+    checks.push({ name: 'Has creation log', passed: false, points: 0 });
+  }
+
+  return { score, maxScore: 100, checks };
+}
+
+// ============================================
+// CLI COMMANDS
+// ============================================
+
+const commands = {
+  // List all installed skills
+  list: () => {
+    console.log(c('cyan', '\n  ClaudeAll Skills\n'));
+
+    if (!fs.existsSync(SKILLS_DIR)) {
+      console.log(c('yellow', '  No skills installed yet.'));
+      return;
+    }
+
+    const skills = fs.readdirSync(SKILLS_DIR).filter(f =>
+      fs.statSync(path.join(SKILLS_DIR, f)).isDirectory()
+    );
+
+    if (skills.length === 0) {
+      console.log(c('yellow', '  No skills found.'));
+      return;
+    }
+
+    console.log(c('gray', `  Found ${skills.length} skills:\n`));
+
+    skills.forEach((skill, i) => {
+      const skillPath = path.join(SKILLS_DIR, skill);
+      const { score } = calculateQualityScore(skillPath);
+
+      const scoreColor = score >= 70 ? 'green' : score >= 40 ? 'yellow' : 'red';
+      const scoreBar = '█'.repeat(Math.floor(score / 10)) + '░'.repeat(10 - Math.floor(score / 10));
+
+      console.log(`  ${c('bright', (i + 1).toString().padStart(2))}. ${c('green', skill)}`);
+      console.log(`      Quality: ${c(scoreColor, scoreBar)} ${score}/100`);
+    });
+
+    console.log();
+  },
+
+  // Search skills
+  search: (query) => {
+    if (!query) {
+      console.log(c('red', '\n  Usage: claude-all skills search <query>\n'));
+      return;
+    }
+
+    console.log(c('cyan', `\n  Searching for "${query}"...\n`));
+
+    const skills = fs.readdirSync(SKILLS_DIR).filter(f =>
+      fs.statSync(path.join(SKILLS_DIR, f)).isDirectory()
+    );
+
+    const matches = skills.filter(skill => {
+      const skillPath = path.join(SKILLS_DIR, skill);
+      const skillMd = path.join(skillPath, 'SKILL.md');
+
+      if (skill.toLowerCase().includes(query.toLowerCase())) return true;
+
+      if (fs.existsSync(skillMd)) {
+        const content = fs.readFileSync(skillMd, 'utf8').toLowerCase();
+        return content.includes(query.toLowerCase());
+      }
+
+      return false;
+    });
+
+    if (matches.length === 0) {
+      console.log(c('yellow', '  No skills found matching your query.'));
+    } else {
+      console.log(c('gray', `  Found ${matches.length} matching skills:\n`));
+      matches.forEach((skill, i) => {
+        console.log(`  ${i + 1}. ${c('green', skill)}`);
+      });
+    }
+
+    console.log();
+  },
+
+  // Create new skill from template
+  create: (name) => {
+    if (!name) {
+      console.log(c('red', '\n  Usage: claude-all skills create <skill-name>\n'));
+      return;
+    }
+
+    const skillDir = path.join(SKILLS_DIR, name);
+
+    if (fs.existsSync(skillDir)) {
+      console.log(c('red', `\n  Skill "${name}" already exists!\n`));
+      return;
+    }
+
+    console.log(c('cyan', `\n  Creating skill: ${name}\n`));
+
+    // Create directory
+    fs.mkdirSync(skillDir, { recursive: true });
+
+    // Create skill.json
+    const skillJson = {
+      name,
+      version: '1.0.0',
+      description: `Description for ${name}`,
+      author: 'Your Name',
+      license: 'MIT',
+      tags: [],
+      agents: ['claude-code', 'cursor', 'copilot', 'gemini'],
+      dependencies: [],
+      hooks: {
+        preInstall: null,
+        postInstall: null
+      },
+      quality: {
+        tested: false,
+        documented: false,
+        examples: false
+      }
+    };
+
+    fs.writeFileSync(
+      path.join(skillDir, 'skill.json'),
+      JSON.stringify(skillJson, null, 2)
+    );
+
+    // Create SKILL.md
+    const skillMd = `---
+name: ${name}
+description: Description for ${name}
+version: 1.0.0
+author: Your Name
+tags: []
+---
+
+# ${name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
+
+## Overview
+
+Describe what this skill does and when to use it.
+
+## When to Use
+
+- Situation 1
+- Situation 2
+- Situation 3
+
+## How It Works
+
+Explain the approach or methodology.
+
+## Examples
+
+### Example 1: Basic Usage
+
+\`\`\`
+// Your example here
+\`\`\`
+
+### Example 2: Advanced Usage
+
+\`\`\`
+// Advanced example
+\`\`\`
+
+## Best Practices
+
+1. Practice 1
+2. Practice 2
+3. Practice 3
+
+## Common Mistakes
+
+- Mistake 1 and how to avoid it
+- Mistake 2 and how to avoid it
+
+## Related Skills
+
+- skill-name-1
+- skill-name-2
+`;
+
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), skillMd);
+
+    // Create test template
+    const testMd = `# Test: ${name}
+
+## Scenario
+
+Describe the test scenario here.
+
+## Expected Behavior
+
+What should happen when the skill is applied correctly.
+
+## Test Steps
+
+1. Step 1
+2. Step 2
+3. Step 3
+
+## Success Criteria
+
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+`;
+
+    fs.writeFileSync(path.join(skillDir, 'test-basic.md'), testMd);
+
+    // Create CREATION-LOG.md
+    const creationLog = `# Creation Log: ${name}
+
+## Created
+- Date: ${new Date().toISOString().split('T')[0]}
+- Author: Your Name
+
+## Changelog
+
+### v1.0.0
+- Initial creation
+`;
+
+    fs.writeFileSync(path.join(skillDir, 'CREATION-LOG.md'), creationLog);
+
+    console.log(c('green', '  ✓ Created skill.json'));
+    console.log(c('green', '  ✓ Created SKILL.md'));
+    console.log(c('green', '  ✓ Created test-basic.md'));
+    console.log(c('green', '  ✓ Created CREATION-LOG.md'));
+    console.log();
+    console.log(c('cyan', `  Skill created at: ${skillDir}`));
+    console.log(c('gray', '  Edit SKILL.md to add your skill content.'));
+    console.log();
+  },
+
+  // Validate skill
+  validate: (name) => {
+    if (!name) {
+      console.log(c('red', '\n  Usage: claude-all skills validate <skill-name>\n'));
+      return;
+    }
+
+    const skillDir = path.join(SKILLS_DIR, name);
+
+    if (!fs.existsSync(skillDir)) {
+      console.log(c('red', `\n  Skill "${name}" not found!\n`));
+      return;
+    }
+
+    console.log(c('cyan', `\n  Validating skill: ${name}\n`));
+
+    const { score, maxScore, checks } = calculateQualityScore(skillDir);
+
+    checks.forEach(check => {
+      const icon = check.passed ? c('green', '✓') : c('red', '✗');
+      const points = check.passed ? c('green', `+${check.points}`) : c('gray', '+0');
+      console.log(`  ${icon} ${check.name} ${points}`);
+    });
+
+    console.log();
+
+    const scoreColor = score >= 70 ? 'green' : score >= 40 ? 'yellow' : 'red';
+    console.log(c('bright', `  Quality Score: ${c(scoreColor, `${score}/${maxScore}`)}`));
+
+    if (score >= 70) {
+      console.log(c('green', '\n  ✓ Skill is ready for publishing!\n'));
+    } else if (score >= 40) {
+      console.log(c('yellow', '\n  ! Skill needs improvement before publishing.\n'));
+    } else {
+      console.log(c('red', '\n  ✗ Skill requires significant work.\n'));
+    }
+  },
+
+  // Test skill
+  test: (name) => {
+    if (!name) {
+      console.log(c('red', '\n  Usage: claude-all skills test <skill-name>\n'));
+      return;
+    }
+
+    const skillDir = path.join(SKILLS_DIR, name);
+
+    if (!fs.existsSync(skillDir)) {
+      console.log(c('red', `\n  Skill "${name}" not found!\n`));
+      return;
+    }
+
+    console.log(c('cyan', `\n  Testing skill: ${name}\n`));
+
+    const testFiles = fs.readdirSync(skillDir).filter(f => f.startsWith('test-'));
+
+    if (testFiles.length === 0) {
+      console.log(c('yellow', '  No test files found (test-*.md)'));
+      console.log(c('gray', '  Create test files with: claude-all skills create-test <skill-name>'));
+      console.log();
+      return;
+    }
+
+    console.log(c('gray', `  Found ${testFiles.length} test files:\n`));
+
+    testFiles.forEach((file, i) => {
+      const testPath = path.join(skillDir, file);
+      const content = fs.readFileSync(testPath, 'utf8');
+
+      // Check if test has success criteria
+      const hasCriteria = content.includes('Success Criteria') || content.includes('- [ ]');
+      const criteriaMatch = content.match(/- \[[ x]\]/g) || [];
+      const completed = criteriaMatch.filter(m => m.includes('x')).length;
+      const total = criteriaMatch.length;
+
+      const status = total === 0 ? c('gray', 'No criteria') :
+                     completed === total ? c('green', `${completed}/${total} passed`) :
+                     c('yellow', `${completed}/${total} passed`);
+
+      console.log(`  ${i + 1}. ${file} - ${status}`);
+    });
+
+    console.log();
+  },
+
+  // Show skill info
+  info: (name) => {
+    if (!name) {
+      console.log(c('red', '\n  Usage: claude-all skills info <skill-name>\n'));
+      return;
+    }
+
+    const skillDir = path.join(SKILLS_DIR, name);
+
+    if (!fs.existsSync(skillDir)) {
+      console.log(c('red', `\n  Skill "${name}" not found!\n`));
+      return;
+    }
+
+    console.log(c('cyan', `\n  Skill: ${name}\n`));
+
+    // Read skill.json if exists
+    const skillJsonPath = path.join(skillDir, 'skill.json');
+    if (fs.existsSync(skillJsonPath)) {
+      const meta = JSON.parse(fs.readFileSync(skillJsonPath, 'utf8'));
+      console.log(c('gray', '  Metadata:'));
+      console.log(`    Version: ${c('green', meta.version || 'N/A')}`);
+      console.log(`    Author: ${meta.author || 'Unknown'}`);
+      console.log(`    License: ${meta.license || 'N/A'}`);
+      console.log(`    Tags: ${(meta.tags || []).join(', ') || 'None'}`);
+      console.log(`    Agents: ${(meta.agents || []).join(', ')}`);
+      if (meta.dependencies && meta.dependencies.length > 0) {
+        console.log(`    Dependencies: ${meta.dependencies.join(', ')}`);
+      }
+      console.log();
+    }
+
+    // Read SKILL.md
+    const skillMdPath = path.join(skillDir, 'SKILL.md');
+    if (fs.existsSync(skillMdPath)) {
+      const parsed = parseSkillMd(fs.readFileSync(skillMdPath, 'utf8'));
+      if (parsed) {
+        console.log(c('gray', '  Description:'));
+        console.log(`    ${parsed.description || 'No description'}`);
+        console.log();
+      }
+    }
+
+    // Quality score
+    const { score } = calculateQualityScore(skillDir);
+    const scoreColor = score >= 70 ? 'green' : score >= 40 ? 'yellow' : 'red';
+    console.log(c('gray', '  Quality Score:'));
+    console.log(`    ${c(scoreColor, `${score}/100`)}`);
+    console.log();
+
+    // Files
+    const files = fs.readdirSync(skillDir);
+    console.log(c('gray', '  Files:'));
+    files.forEach(f => console.log(`    - ${f}`));
+    console.log();
+  },
+
+  // Export skill for publishing
+  export: (name) => {
+    if (!name) {
+      console.log(c('red', '\n  Usage: claude-all skills export <skill-name>\n'));
+      return;
+    }
+
+    const skillDir = path.join(SKILLS_DIR, name);
+
+    if (!fs.existsSync(skillDir)) {
+      console.log(c('red', `\n  Skill "${name}" not found!\n`));
+      return;
+    }
+
+    const { score } = calculateQualityScore(skillDir);
+
+    if (score < 40) {
+      console.log(c('red', `\n  Skill quality too low (${score}/100). Improve before exporting.\n`));
+      return;
+    }
+
+    const exportDir = path.join(process.cwd(), `${name}-skill`);
+
+    console.log(c('cyan', `\n  Exporting skill: ${name}\n`));
+
+    // Copy skill directory
+    execSync(`cp -r "${skillDir}" "${exportDir}"`);
+
+    // Create package.json for npm
+    const skillJson = fs.existsSync(path.join(skillDir, 'skill.json'))
+      ? JSON.parse(fs.readFileSync(path.join(skillDir, 'skill.json'), 'utf8'))
+      : {};
+
+    const packageJson = {
+      name: `claudeall-skill-${name}`,
+      version: skillJson.version || '1.0.0',
+      description: skillJson.description || `ClaudeAll skill: ${name}`,
+      author: skillJson.author || 'ClaudeAll Community',
+      license: skillJson.license || 'MIT',
+      keywords: ['claudeall', 'skill', 'ai-agent', ...(skillJson.tags || [])],
+      repository: {
+        type: 'git',
+        url: `https://github.com/zesbe/ClaudeAll.git`
+      },
+      claudeall: {
+        type: 'skill',
+        agents: skillJson.agents || ['claude-code'],
+        dependencies: skillJson.dependencies || [],
+        quality: score
+      }
+    };
+
+    fs.writeFileSync(
+      path.join(exportDir, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+
+    console.log(c('green', `  ✓ Exported to: ${exportDir}`));
+    console.log(c('gray', '\n  To publish to npm:'));
+    console.log(c('cyan', `    cd ${exportDir}`));
+    console.log(c('cyan', '    npm publish'));
+    console.log();
+  },
+
+  // Stats
+  stats: () => {
+    console.log(c('cyan', '\n  ClaudeAll Skills Statistics\n'));
+
+    if (!fs.existsSync(SKILLS_DIR)) {
+      console.log(c('yellow', '  No skills directory found.'));
+      return;
+    }
+
+    const skills = fs.readdirSync(SKILLS_DIR).filter(f =>
+      fs.statSync(path.join(SKILLS_DIR, f)).isDirectory()
+    );
+
+    let totalScore = 0;
+    let highQuality = 0;
+    let mediumQuality = 0;
+    let lowQuality = 0;
+
+    skills.forEach(skill => {
+      const { score } = calculateQualityScore(path.join(SKILLS_DIR, skill));
+      totalScore += score;
+      if (score >= 70) highQuality++;
+      else if (score >= 40) mediumQuality++;
+      else lowQuality++;
+    });
+
+    const avgScore = skills.length > 0 ? Math.round(totalScore / skills.length) : 0;
+
+    console.log(`  Total Skills: ${c('bright', skills.length.toString())}`);
+    console.log(`  Average Quality: ${c('cyan', avgScore + '/100')}`);
+    console.log();
+    console.log(`  ${c('green', '●')} High Quality (70+): ${highQuality}`);
+    console.log(`  ${c('yellow', '●')} Medium Quality (40-69): ${mediumQuality}`);
+    console.log(`  ${c('red', '●')} Low Quality (<40): ${lowQuality}`);
+    console.log();
+  },
+
+  // Help
+  help: () => {
+    console.log(`
+${c('cyan', '  ClaudeAll Skills CLI')} ${c('gray', '- Advanced skill management')}
+
+${c('bright', '  COMMANDS:')}
+
+    ${c('green', 'list')}                    List all installed skills
+    ${c('green', 'search')} <query>          Search skills by name or content
+    ${c('green', 'info')} <name>             Show skill details
+    ${c('green', 'create')} <name>           Create new skill from template
+    ${c('green', 'validate')} <name>         Validate skill quality
+    ${c('green', 'test')} <name>             Run skill tests
+    ${c('green', 'export')} <name>           Export skill for publishing
+    ${c('green', 'stats')}                   Show skills statistics
+    ${c('green', 'help')}                    Show this help
+
+${c('bright', '  FEATURES BEYOND skills.sh:')}
+
+    ${c('magenta', '✓')} Quality scoring system (0-100)
+    ${c('magenta', '✓')} Skill scaffolding generator
+    ${c('magenta', '✓')} Built-in testing framework
+    ${c('magenta', '✓')} Dependency management
+    ${c('magenta', '✓')} Hooks system (pre/post install)
+    ${c('magenta', '✓')} Multi-agent support
+    ${c('magenta', '✓')} Offline-first design
+    ${c('magenta', '✓')} Export for npm publishing
+
+${c('bright', '  EXAMPLES:')}
+
+    ${c('gray', '$')} claude-all skills list
+    ${c('gray', '$')} claude-all skills create my-skill
+    ${c('gray', '$')} claude-all skills validate my-skill
+    ${c('gray', '$')} claude-all skills export my-skill
+
+`);
+  }
+};
+
+// ============================================
+// MAIN
+// ============================================
+
+function main() {
+  const args = process.argv.slice(2);
+
+  // Handle "claude-all skills <cmd>" format
+  if (args[0] === 'skills') {
+    args.shift();
+  }
+
+  const cmd = args[0] || 'help';
+  const arg = args[1];
+
+  if (commands[cmd]) {
+    commands[cmd](arg);
+  } else {
+    console.log(c('red', `\n  Unknown command: ${cmd}`));
+    commands.help();
+  }
+}
+
+main();

package/lib/skill-hooks.js

@@ -0,0 +1,140 @@
+/**
+ * ClaudeAll Skill Hooks System
+ *
+ * Lifecycle hooks for skills:
+ * - preInstall: Before skill is installed
+ * - postInstall: After skill is installed
+ * - preUninstall: Before skill is removed
+ * - postUninstall: After skill is removed
+ * - preUpdate: Before skill is updated
+ * - postUpdate: After skill is updated
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const CLAUDE_DIR = path.join(process.env.HOME, '.claude');
+const SKILLS_DIR = path.join(CLAUDE_DIR, 'skills');
+const HOOKS_LOG = path.join(CLAUDE_DIR, '.hooks-log.json');
+
+class SkillHooks {
+  constructor() {
+    this.hooks = {};
+    this.log = this.loadLog();
+  }
+
+  loadLog() {
+    if (fs.existsSync(HOOKS_LOG)) {
+      return JSON.parse(fs.readFileSync(HOOKS_LOG, 'utf8'));
+    }
+    return { executions: [] };
+  }
+
+  saveLog() {
+    fs.writeFileSync(HOOKS_LOG, JSON.stringify(this.log, null, 2));
+  }
+
+  logExecution(skillName, hookType, success, error = null) {
+    this.log.executions.push({
+      skill: skillName,
+      hook: hookType,
+      success,
+      error: error ? error.message : null,
+      timestamp: new Date().toISOString()
+    });
+
+    // Keep last 100 executions
+    if (this.log.executions.length > 100) {
+      this.log.executions = this.log.executions.slice(-100);
+    }
+
+    this.saveLog();
+  }
+
+  /**
+   * Load hooks from skill.json
+   */
+  loadSkillHooks(skillName) {
+    const skillJsonPath = path.join(SKILLS_DIR, skillName, 'skill.json');
+
+    if (fs.existsSync(skillJsonPath)) {
+      const skillJson = JSON.parse(fs.readFileSync(skillJsonPath, 'utf8'));
+      return skillJson.hooks || {};
+    }
+
+    return {};
+  }
+
+  /**
+   * Execute a hook
+   */
+  async executeHook(skillName, hookType) {
+    const hooks = this.loadSkillHooks(skillName);
+    const hookScript = hooks[hookType];
+
+    if (!hookScript) {
+      return { executed: false, reason: 'No hook defined' };
+    }
+
+    const skillDir = path.join(SKILLS_DIR, skillName);
+    const hookPath = path.join(skillDir, hookScript);
+
+    console.log(`  Executing ${hookType} hook for ${skillName}...`);
+
+    try {
+      if (fs.existsSync(hookPath)) {
+        // Execute script file
+        execSync(`bash "${hookPath}"`, {
+          cwd: skillDir,
+          stdio: 'inherit'
+        });
+      } else if (hookScript.startsWith('npm ') || hookScript.startsWith('node ')) {
+        // Execute command directly
+        execSync(hookScript, {
+          cwd: skillDir,
+          stdio: 'inherit'
+        });
+      } else {
+        // Treat as inline script
+        execSync(hookScript, {
+          cwd: skillDir,
+          shell: true,
+          stdio: 'inherit'
+        });
+      }
+
+      this.logExecution(skillName, hookType, true);
+      return { executed: true, success: true };
+    } catch (error) {
+      this.logExecution(skillName, hookType, false, error);
+      return { executed: true, success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Run all lifecycle hooks for an operation
+   */
+  async runLifecycle(skillName, operation) {
+    const results = {};
+
+    // Pre hook
+    const preHook = `pre${operation.charAt(0).toUpperCase()}${operation.slice(1)}`;
+    results.pre = await this.executeHook(skillName, preHook);
+
+    // Post hook
+    const postHook = `post${operation.charAt(0).toUpperCase()}${operation.slice(1)}`;
+    results.post = await this.executeHook(skillName, postHook);
+
+    return results;
+  }
+
+  /**
+   * Get recent hook executions
+   */
+  getRecentExecutions(limit = 10) {
+    return this.log.executions.slice(-limit);
+  }
+}
+
+module.exports = SkillHooks;

package/package.json

@@ -1,10 +1,16 @@
 {
   "name": "claude-termux",
-  "version": "1.0.3",
-  "description": "Claude Code & Gemini CLI configuration for Termux Android - agents, skills, commands, MCP servers",
+  "version": "2.0.0",
+  "description": "Claude Code & Gemini CLI configuration for Termux Android - agents, skills, commands, MCP servers with quality scoring & hooks",
   "main": "postinstall.js",
+  "bin": {
+    "claude-termux-skills": "./bin/skills-cli.js",
+    "claude-termux-mcp": "./bin/mcp-install.js"
+  },
   "scripts": {
-    "postinstall": "node postinstall.js"
+    "postinstall": "node postinstall.js",
+    "skills": "node bin/skills-cli.js",
+    "mcp": "node bin/mcp-install.js"
   },
   "keywords": [
     "claude",
@@ -17,18 +23,27 @@
     "agents",
     "skills",
     "mcp",
-    "superpowers"
+    "superpowers",
+    "quality-scoring",
+    "hooks-system"
   ],
-  "author": "zesbe",
+  "author": {
+    "name": "zesbe",
+    "email": "yudiharyanto41@gmail.com",
+    "url": "https://github.com/zesbe"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/zesbe/ClaudeAll.git"
+    "url": "https://github.com/zesbe/ClaudeAll.git"
   },
   "bugs": {
     "url": "https://github.com/zesbe/ClaudeAll/issues"
   },
   "homepage": "https://github.com/zesbe/ClaudeAll#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
   "files": [
     "agents/**",
     "skills/**",
@@ -37,6 +52,7 @@
     "hooks/**",
     "plugins/**",
     "lib/**",
+    "bin/**",
     "CLAUDE.md",
     "GEMINI.md",
     "TERMUX.md",
@@ -45,5 +61,16 @@
     "settings.local.json",
     "install.sh",
     "postinstall.js"
-  ]
+  ],
+  "claudeTermux": {
+    "features": [
+      "quality-scoring",
+      "skill-scaffolding",
+      "hooks-system",
+      "mcp-auto-install"
+    ],
+    "skillsCount": 60,
+    "agentsCount": 14,
+    "commandsCount": 8
+  }
 }