claude-termux 1.0.0

package/postinstall.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Termux - Postinstall Script
+ * Automatically installs superpowers to Claude Code and Gemini CLI
+ * Optimized for Termux Android
+ * https://github.com/zesbe/termux-config
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Colors for terminal
+const colors = {
+    green: '\x1b[32m',
+    blue: '\x1b[34m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    reset: '\x1b[0m'
+};
+
+const log = {
+    success: (msg) => console.log(`${colors.green}✓ ${msg}${colors.reset}`),
+    info: (msg) => console.log(`${colors.blue}→ ${msg}${colors.reset}`),
+    warn: (msg) => console.log(`${colors.yellow}! ${msg}${colors.reset}`),
+    error: (msg) => console.log(`${colors.red}✗ ${msg}${colors.reset}`)
+};
+
+// Detect environment
+const isTermux = fs.existsSync('/data/data/com.termux');
+const homeDir = isTermux ? '/data/data/com.termux/files/home' : process.env.HOME;
+const packageDir = __dirname;
+
+console.log(`
+${colors.blue}╔═══════════════════════════════════════════════════════════╗
+║       Claude Termux - AI CLI Config for Android           ║
+║              https://github.com/zesbe                     ║
+╚═══════════════════════════════════════════════════════════╝${colors.reset}
+`);
+
+if (isTermux) {
+    log.success('Termux environment detected');
+} else {
+    log.warn('Not running in Termux, using standard paths');
+}
+
+// Check for installed CLIs
+function commandExists(cmd) {
+    try {
+        execSync(`command -v ${cmd}`, { stdio: 'ignore' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+const claudeInstalled = commandExists('claude');
+const geminiInstalled = commandExists('gemini');
+
+if (claudeInstalled) log.success('Claude Code found');
+else log.warn('Claude Code not found (install: npm i -g @anthropic-ai/claude-code)');
+
+if (geminiInstalled) log.success('Gemini CLI found');
+else log.warn('Gemini CLI not found (install: npm i -g @google/gemini-cli)');
+
+if (!claudeInstalled && !geminiInstalled) {
+    log.error('Neither Claude Code nor Gemini CLI is installed');
+    console.log('Please install at least one:');
+    console.log('  npm install -g @anthropic-ai/claude-code');
+    console.log('  npm install -g @google/gemini-cli');
+    process.exit(0); // Don't fail postinstall
+}
+
+// Helper functions
+function copyDir(src, dest) {
+    if (!fs.existsSync(src)) return 0;
+
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    let count = 0;
+
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+
+        if (entry.isDirectory()) {
+            count += copyDir(srcPath, destPath);
+        } else {
+            fs.copyFileSync(srcPath, destPath);
+            count++;
+        }
+    }
+    return count;
+}
+
+function copyFile(src, dest) {
+    if (!fs.existsSync(src)) return false;
+    fs.copyFileSync(src, dest);
+    return true;
+}
+
+function countItems(dir) {
+    if (!fs.existsSync(dir)) return 0;
+    return fs.readdirSync(dir).length;
+}
+
+// Install for Claude Code
+if (claudeInstalled) {
+    console.log(`\n${colors.blue}Installing Claude Code superpowers...${colors.reset}`);
+
+    const claudeDir = path.join(homeDir, '.claude');
+
+    // Create directories
+    ['agents', 'skills', 'commands', 'hooks', 'plugins', 'lib'].forEach(dir => {
+        fs.mkdirSync(path.join(claudeDir, dir), { recursive: true });
+    });
+
+    // Copy agents
+    copyDir(path.join(packageDir, 'agents'), path.join(claudeDir, 'agents'));
+    log.success(`Agents: ${countItems(path.join(claudeDir, 'agents'))} installed`);
+
+    // Copy skills
+    copyDir(path.join(packageDir, 'skills'), path.join(claudeDir, 'skills'));
+    log.success(`Skills: ${countItems(path.join(claudeDir, 'skills'))} installed`);
+
+    // Copy commands
+    copyDir(path.join(packageDir, 'commands'), path.join(claudeDir, 'commands'));
+    log.success(`Commands: ${countItems(path.join(claudeDir, 'commands'))} installed`);
+
+    // Copy hooks
+    copyDir(path.join(packageDir, 'hooks'), path.join(claudeDir, 'hooks'));
+    log.success('Hooks installed');
+
+    // Copy plugins
+    copyDir(path.join(packageDir, 'plugins'), path.join(claudeDir, 'plugins'));
+    log.success('Plugins installed');
+
+    // Copy lib
+    copyDir(path.join(packageDir, 'lib'), path.join(claudeDir, 'lib'));
+    log.success('Lib installed');
+
+    // Copy CLAUDE.md
+    if (copyFile(path.join(packageDir, 'CLAUDE.md'), path.join(claudeDir, 'CLAUDE.md'))) {
+        log.success('CLAUDE.md installed');
+    }
+
+    // Copy TERMUX.md
+    if (copyFile(path.join(packageDir, 'TERMUX.md'), path.join(claudeDir, 'TERMUX.md'))) {
+        log.success('TERMUX.md installed');
+    }
+
+    // Copy settings.local.json (bypass permissions)
+    if (copyFile(path.join(packageDir, 'settings.local.json'), path.join(claudeDir, 'settings.local.json'))) {
+        log.success('Bypass permissions configured');
+    }
+
+    // Copy MCP config to home
+    const mcpDest = path.join(homeDir, '.mcp.json');
+    if (copyFile(path.join(packageDir, 'mcp.json'), mcpDest)) {
+        fs.chmodSync(mcpDest, 0o600);
+        log.success('MCP servers configured (6 servers)');
+    }
+}
+
+// Install for Gemini CLI
+if (geminiInstalled) {
+    console.log(`\n${colors.blue}Installing Gemini CLI superpowers...${colors.reset}`);
+
+    const geminiDir = path.join(homeDir, '.gemini');
+    const superpowersDir = path.join(geminiDir, 'superpowers');
+
+    // Create directories
+    ['agents', 'skills', 'commands', 'hooks', 'lib'].forEach(dir => {
+        fs.mkdirSync(path.join(superpowersDir, dir), { recursive: true });
+    });
+
+    // Copy agents
+    copyDir(path.join(packageDir, 'agents'), path.join(superpowersDir, 'agents'));
+    log.success(`Agents: ${countItems(path.join(superpowersDir, 'agents'))} installed`);
+
+    // Copy skills
+    copyDir(path.join(packageDir, 'skills'), path.join(superpowersDir, 'skills'));
+    log.success(`Skills: ${countItems(path.join(superpowersDir, 'skills'))} installed`);
+
+    // Copy commands
+    copyDir(path.join(packageDir, 'commands'), path.join(superpowersDir, 'commands'));
+    log.success(`Commands: ${countItems(path.join(superpowersDir, 'commands'))} installed`);
+
+    // Copy hooks
+    copyDir(path.join(packageDir, 'hooks'), path.join(superpowersDir, 'hooks'));
+    log.success('Hooks installed');
+
+    // Copy lib
+    copyDir(path.join(packageDir, 'lib'), path.join(superpowersDir, 'lib'));
+    log.success('Lib installed');
+
+    // Copy GEMINI.md
+    if (copyFile(path.join(packageDir, 'GEMINI.md'), path.join(geminiDir, 'GEMINI.md'))) {
+        log.success('GEMINI.md installed');
+    }
+
+    // Copy settings.json (YOLO mode)
+    if (copyFile(path.join(packageDir, 'settings.json'), path.join(geminiDir, 'settings.json'))) {
+        log.success('YOLO mode configured');
+    }
+
+    // Copy MCP config
+    const mcpDest = path.join(geminiDir, 'mcp.json');
+    if (copyFile(path.join(packageDir, 'mcp.json'), mcpDest)) {
+        fs.chmodSync(mcpDest, 0o600);
+        log.success('MCP servers configured (6 servers)');
+    }
+}
+
+// Final message
+console.log(`
+${colors.green}╔═══════════════════════════════════════════════════════════╗
+║                  Installation Complete!                    ║
+╚═══════════════════════════════════════════════════════════╝${colors.reset}
+`);
+
+if (claudeInstalled) {
+    console.log(`${colors.blue}Claude Code:${colors.reset}`);
+    console.log('  Run: claude');
+    console.log('  Bypass mode: claude --dangerously-skip-permissions');
+}
+
+if (geminiInstalled) {
+    console.log(`${colors.blue}Gemini CLI:${colors.reset}`);
+    console.log('  Run: gemini');
+    console.log('  YOLO mode: gemini --yolo');
+}
+
+console.log(`
+${colors.yellow}Documentation: ~/.claude/TERMUX.md${colors.reset}
+${colors.yellow}GitHub: https://github.com/zesbe/termux-config${colors.reset}
+`);

package/settings.json

@@ -0,0 +1,27 @@
+{
+  "model": {
+    "name": "gemini-2.5-flash"
+  },
+  "theme": "system",
+  "security": {
+    "allowedTools": [
+      "shell",
+      "read_file",
+      "write_file",
+      "edit_file",
+      "glob",
+      "grep",
+      "web_search",
+      "web_fetch"
+    ],
+    "autoApprove": true
+  },
+  "superpowers": {
+    "enabled": true,
+    "path": "~/.gemini/superpowers"
+  },
+  "mcp": {
+    "enabled": true,
+    "configPath": "~/.gemini/mcp.json"
+  }
+}

package/settings.local.json

@@ -0,0 +1,25 @@
+{
+  "agent": "proactive-mode",
+  "permissions": {
+    "allow": [
+      "Bash(git clone:*)",
+      "Bash(python3:*)",
+      "Bash(find:*)",
+      "Bash(node:*)",
+      "Bash(npm config set:*)",
+      "Bash(npm whoami:*)",
+      "Bash(git init:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git push:*)",
+      "Bash(npm install:*)",
+      "Bash(npm publish:*)",
+      "Bash(npm view:*)",
+      "Bash(flutter:*)",
+      "Bash(go build:*)",
+      "Bash(go run:*)",
+      "Bash(systemctl:*)",
+      "Bash(docker:*)"
+    ]
+  }
+}

package/skills/api-development/SKILL.md

@@ -0,0 +1,11 @@
+api-development skill helps design and implement robust APIs following RESTful principles and GraphQL best practices.
+
+For code review, check that:
+1. API follows RESTful conventions (for REST APIs)
+2. Proper HTTP status codes are used
+3. Request/response validation is implemented
+4. API documentation is complete (OpenAPI/Swagger)
+5. Rate limiting is implemented
+6. Versioning strategy is in place
+7. Authentication and authorization are secure
+8. Error handling is consistent and informative

package/skills/api-development/openapi/api-documentation.yaml

@@ -0,0 +1,108 @@
+openapi: 3.0.0
+info:
+  title: API Documentation
+  version: 1.0.0
+  description: API documentation for [Project Name]
+  contact:
+    name: [Contact Name]
+    email: [contact@domain.com]
+  license:
+    name: MIT
+
+servers:
+  - url: https://api.example.com/v1
+    description: Production server
+  - url: https://staging-api.example.com/v1
+    description: Staging server
+
+paths:
+  /users:
+    get:
+      summary: List all users
+      tags:
+        - Users
+      parameters:
+        - name: limit
+          in: query
+          schema:
+            type: integer
+            default: 10
+        - name: offset
+          in: query
+          schema:
+            type: integer
+            default: 0
+      responses:
+        '200':
+          description: List of users
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  users:
+                  type: array
+                  items:
+                    $ref: '#/components/schemas/User'
+                total:
+                  type: integer
+        '401':
+          $ref: '#/components/responses/Unauthorized'
+
+  /users/{id}:
+    get:
+      summary: Get user by ID
+      tags:
+        - Users
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: integer
+      responses:
+        '200':
+          description: User details
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/User'
+        '404':
+          $ref: '#/components/responses/NotFound'
+
+components:
+  schemas:
+    User:
+      type: object
+      required:
+        - id
+        - email
+        - name
+      properties:
+        id:
+          type: integer
+          example: 1
+        email:
+          type: string
+          format: email
+          example: user@example.com
+        name:
+          type: string
+          example: John Doe
+        created_at:
+          type: string
+          format: date-time
+
+  responses:
+    Unauthorized:
+      type: object
+      properties:
+        error:
+          type: string
+          example: Unauthorized
+    NotFound:
+      type: object
+      properties:
+        error:
+          type: string
+          example: Not Found

package/skills/brainstorming/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: brainstorming
+description: Use when creating or developing, before writing code or implementation plans - refines rough ideas into fully-formed designs through collaborative questioning, alternative exploration, and incremental validation. Don't use during clear 'mechanical' processes
+---
+
+# Brainstorming Ideas Into Designs
+
+## Overview
+
+Help turn ideas into fully formed designs and specs through natural collaborative dialogue.
+
+Start by understanding the current project context, then ask questions one at a time to refine the idea. Once you understand what you're building, present the design in small sections (200-300 words), checking after each section whether it looks right so far.
+
+## The Process
+
+**Understanding the idea:**
+- Check out the current project state first (files, docs, recent commits)
+- Ask questions one at a time to refine the idea
+- Prefer multiple choice questions when possible, but open-ended is fine too
+- Only one question per message - if a topic needs more exploration, break it into multiple questions
+- Focus on understanding: purpose, constraints, success criteria
+
+**Exploring approaches:**
+- Propose 2-3 different approaches with trade-offs
+- Present options conversationally with your recommendation and reasoning
+- Lead with your recommended option and explain why
+
+**Presenting the design:**
+- Once you believe you understand what you're building, present the design
+- Break it into sections of 200-300 words
+- Ask after each section whether it looks right so far
+- Cover: architecture, components, data flow, error handling, testing
+- Be ready to go back and clarify if something doesn't make sense
+
+## After the Design
+
+**Documentation:**
+- Write the validated design to `docs/plans/YYYY-MM-DD-<topic>-design.md`
+- Use elements-of-style:writing-clearly-and-concisely skill if available
+- Commit the design document to git
+
+**Implementation (if continuing):**
+- Ask: "Ready to set up for implementation?"
+- Use superpowers:using-git-worktrees to create isolated workspace
+- Use superpowers:writing-plans to create detailed implementation plan
+
+## Key Principles
+
+- **One question at a time** - Don't overwhelm with multiple questions
+- **Multiple choice preferred** - Easier to answer than open-ended when possible
+- **YAGNI ruthlessly** - Remove unnecessary features from all designs
+- **Explore alternatives** - Always propose 2-3 approaches before settling
+- **Incremental validation** - Present design in sections, validate each
+- **Be flexible** - Go back and clarify when something doesn't make sense

package/skills/code-quality/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: code-quality
+description: Use when the code has become difficult to understand, modify, or maintain, or when code smells or anti-patterns have accumulated - identify code smells, suggest improvements, and refactor systematically while preserving functionality
+---
+
+# Code Quality Skill
+
+You are a Code Quality Expert specializing in improving code maintainability, readability, and structure. Your expertise includes:
+
+- **Code Smell Detection**: Identify problematic code patterns
+- **Refactoring Strategies**: Systematic approaches to improve code
+- **Maintainability**: Make code easier to understand and modify
+- **Documentation**: Ensure code is well-documented
+
+## When to Use
+
+Trigger this skill when:
+
+- **Code Smell Accumulation**: Too many quick fixes have created technical debt
+- **Readability Crisis**: Code has become difficult to understand
+- **Maintenance Nightmare**: Changes keep breaking things
+- "This code is a mess" or similar sentiments from the team
+- **Performance Issues**: Code is slow or inefficient
+- "Why is this so complex?" or similar questions
+
+## Code Quality Fundamentals
+
+### Identify Code Smells
+
+Look for these common code smells:
+
+#### 1. Duplicated Code
+- Same logic appears in multiple places
+- Copy-pasted code without abstraction
+- Extract to function or method
+
+#### 2. Long Methods/Functions
+- Methods over 50-100 lines (depends on language)
+- Doing too many things
+- Break down into smaller functions
+
+#### 3. Large Classes/Modules
+- Class/module with too many responsibilities
+- God object anti-pattern
+- Apply Single Responsibility Principle
+
+#### 4. Complex Conditionals
+- Nested if/else or switch statements
+- More than 3 levels of nesting
+- Use guard clauses or early returns
+
+#### 5. Magic Numbers/Strings
+- Hardcoded values without explanation
+- Create constants or configuration
+
+#### 6. Poor Naming
+- cryptic variable names (a, b, x, tmp, temp)
+- Names that don't describe purpose
+- Use descriptive names
+
+#### 7. Dead Code
+- Commented out code that should be removed
+- Unused variables/functions
+- Import statements for unused items
+
+#### 8. God Methods
+- Methods that do too much
+- Try to do everything in one function
+- Break down into smaller, testable units
+
+## Quality Indicators
+
+Good code should be:
+- ✅ **Readable**: Self-documenting with clear names
+- ✅ **Modular**: Broken into small, focused units
+- ✅ **Testable**: Easy to unit test in isolation
+- ✅ **Maintainable**: Easy to modify without breaking things
+- ✅ **Well-Documented**: Comments explain WHY not WHAT
+- ✅ **Consistent**: Follows team conventions and patterns
+
+## Refactoring Process
+
+### Phase 1: Analyze
+1. Read the target code thoroughly
+2. Understand what it does and why it exists
+3. Identify specific code smells
+4. Determine refactoring priority
+
+### Phase 2: Plan
+1. List all identified issues
+2. Categorize by severity (high/medium/low)
+3. Identify dependencies between issues
+4. Create refactoring strategy
+
+### Phase 3: Execute
+1. Start with easiest wins (low hanging fruit)
+2. Refactor incrementally with tests at each step
+3. Run tests after each change
+4. Update documentation
+
+### Phase 4: Verify
+1. Ensure all tests still pass
+2. Check performance hasn't degraded
+3. Get code review if available
+4. Update documentation
+
+## Refactoring Techniques
+
+### Extract Method
+- Break large method into smaller methods
+- Each method does one thing well
+- Use meaningful names
+
+### Extract Class
+- Extract related functionality into new class
+   - Single Responsibility Principle
+   - Reduce class size
+
+### Replace Magic with Constants
+```python
+# Before
+if user_age > 18:  # What is 18?
+    return True
+
+# After
+ADULT_AGE = 18
+if user_age > ADULT_AGE:
+    return True
+```
+
+### Simplify Conditionals
+```python
+# Before
+if condition_a and condition_b:
+    do_thing()
+elif condition_c:
+    do_alternative()
+else:
+    do_default()
+
+# After
+if is_adult():  # Guard clause
+    do_thing()
+    return
+do_alternative()
+do_default()
+```
+
+### Extract Variable/Function
+- Extract repeated logic into reusable components
+- Reduce duplication, improve maintainability
+
+## Performance Considerations
+
+- Don't optimize prematurely
+- Measure before optimizing
+- Profile to find real bottlenecks
+- Consider time vs space trade-offs
+
+## Testing Quality
+
+- Ensure 100% test coverage on refactored code
+- Don't break existing functionality
+- Add tests for new extracted functions
+
+## Document Changes
+
+- Update JSDoc comments/docstrings
+- Update README if public API changes
+- Document refactoring reason
+- Update architecture diagrams if needed
+
+## Output
+
+Provide:
+
+1. **Code Quality Assessment**:
+   - List found code smells
+   - Severity: Critical/High/Medium/Low
+
+2. **Refactoring Plan**:
+   - List of refactorings with priorities
+   - Estimated time for each refactoring
+
+3. Execute refactorings:
+   - Run tests after each refactoring step
+   - Update documentation
+
+4. Quality Metrics:
+   - Cyclomatic complexity (lower is better)
+   - Lines of code (should decrease)
+   - Test coverage (should maintain 100%)
+
+---
+
+**Remember**: The best refactoring is the one that makes the code simpler, not more complex!