xtrm-tools 2.0.0

package/project-skills/ts-quality-gate/.claude/settings.json

@@ -0,0 +1,16 @@
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/quality-check.cjs\"",
+            "timeout": 30
+          }
+        ]
+      }
+    ]
+  }
+}

package/project-skills/ts-quality-gate/.claude/skills/using-ts-quality-gate/SKILL.md

@@ -0,0 +1,81 @@
+# Using TS Quality Gate
+
+**TS Quality Gate** enforces TypeScript, ESLint, and Prettier quality checks on every file edit. It provides immediate feedback and auto-fixes issues when possible.
+
+## What It Does
+
+- **TypeScript compilation check** - Catches type errors immediately
+- **ESLint validation** - Enforces code style and best practices
+- **Prettier formatting** - Ensures consistent code formatting
+- **Auto-fix** - Automatically fixes issues when possible
+- **Fast feedback** - Runs in <1s for most files
+
+## How It Works
+
+When you edit a TypeScript/JavaScript file:
+
+1. PostToolUse hook fires after Write/Edit
+2. Runs `quality-check.js` with the file path
+3. Checks TypeScript compilation, ESLint, Prettier
+4. Auto-fixes issues if configured
+5. Returns exit code 2 if blocking errors found
+
+## Configuration
+
+The quality gate is configured via `.claude/hooks/hook-config.json`:
+
+```json
+{
+  "typescript": {
+    "enabled": true,
+    "showDependencyErrors": false
+  },
+  "eslint": {
+    "enabled": true,
+    "autofix": true
+  },
+  "prettier": {
+    "enabled": true,
+    "autofix": true
+  },
+  "general": {
+    "autofixSilent": true,
+    "debug": false
+  }
+}
+```
+
+## Requirements
+
+- Node.js 18+
+- TypeScript installed in project
+- ESLint installed in project (optional)
+- Prettier installed in project (optional)
+
+## Installation
+
+```bash
+# Install project skill
+xtrm install project ts-quality-gate
+
+# Ensure dependencies are installed in your project
+npm install --save-dev typescript eslint prettier
+```
+
+## Troubleshooting
+
+**"ESLint not found"**
+- Install ESLint: `npm install --save-dev eslint`
+- Or disable in hook-config.json: `"eslint": { "enabled": false }`
+
+**"Prettier not found"**
+- Install Prettier: `npm install --save-dev prettier`
+- Or disable in hook-config.json: `"prettier": { "enabled": false }`
+
+**TypeScript errors from dependencies**
+- Set `"showDependencyErrors": false` in hook-config.json
+
+## See Also
+
+- Full documentation: `.claude/docs/ts-quality-gate-readme.md`
+- Reference: https://github.com/bartolli/claude-code-typescript-hooks

package/project-skills/ts-quality-gate/README.md

@@ -0,0 +1,115 @@
+# TS Quality Gate
+
+**TypeScript/ESLint/Prettier quality gate** for Claude Code. Runs automatically on every file edit to ensure code quality.
+
+## What It Does
+
+TS Quality Gate enforces code quality standards in real-time:
+
+| Check | Description | Auto-fix |
+|-------|-------------|----------|
+| **TypeScript** | Compilation errors, type safety | No |
+| **ESLint** | Code style, best practices, rules | Yes (if enabled) |
+| **Prettier** | Code formatting consistency | Yes (if enabled) |
+
+## Installation
+
+```bash
+# Install project skill
+xtrm install project ts-quality-gate
+```
+
+**Post-install:** Ensure your project has the required dependencies:
+
+```bash
+npm install --save-dev typescript eslint prettier
+```
+
+## How It Works
+
+The quality gate runs as a `PostToolUse` hook:
+
+1. You edit a TypeScript/JavaScript file
+2. After the edit completes, the hook fires
+3. `quality-check.cjs` validates the file
+4. Issues are reported with auto-fix when possible
+5. Exit code 2 blocks if critical errors found
+
+## Configuration
+
+Edit `.claude/hooks/hook-config.json` to customize:
+
+```json
+{
+  "typescript": {
+    "enabled": true,
+    "showDependencyErrors": false
+  },
+  "eslint": {
+    "enabled": true,
+    "autofix": true
+  },
+  "prettier": {
+    "enabled": true,
+    "autofix": true
+  },
+  "general": {
+    "autofixSilent": true
+  }
+}
+```
+
+### Environment Variable Overrides
+
+```bash
+export CLAUDE_HOOKS_TYPESCRIPT_ENABLED=false
+export CLAUDE_HOOKS_ESLINT_AUTOFIX=true
+export CLAUDE_HOOKS_PRETTIER_ENABLED=false
+```
+
+## Features
+
+### TypeScript Checking
+- Uses project's tsconfig.json
+- Checks only edited file (fast)
+- Optionally shows dependency errors
+
+### ESLint Integration
+- Auto-discovers .eslintrc or eslint.config.js
+- Auto-fixes when `autofix: true`
+- Reports errors and warnings
+
+### Prettier Formatting
+- Auto-discovers .prettierrc
+- Auto-formats when `autofix: true`
+- Supports all Prettier options
+
+### Smart File Detection
+- Skips non-source files
+- Detects test files, CLI files, services
+- Applies file-type-specific rules
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | All checks passed |
+| 1 | Fatal error (hook crashed) |
+| 2 | Blocking errors found (Claude must fix) |
+
+## Troubleshooting
+
+**Hook not running**
+- Verify PostToolUse hook in `.claude/settings.json`
+- Check hook path is correct
+
+**TypeScript errors from node_modules**
+- Set `showDependencyErrors: false`
+
+**ESLint/Prettier not found**
+- Install in project: `npm install --save-dev eslint prettier`
+- Or disable in config
+
+## Reference
+
+Based on: https://github.com/bartolli/claude-code-typescript-hooks

package/skills/README.txt

@@ -0,0 +1,31 @@
+# Local Agent Skills
+
+This directory contains specialized agent skills designed for the Gemini CLI. These skills extend the agent's capabilities for specific workflows like debugging, security auditing, and cross-model orchestration.
+
+## Skill Discovery
+
+All skills in this directory are automatically discovered by the `hooks/skill-discovery.py` hook at the start of each session. The hook injects a summarized list of these skills into the agent's initial context, ensuring the agent is aware of specialized tools from the first prompt.
+
+### How to Add a New Skill
+
+To add a new skill that is automatically discovered:
+
+1.  **Create a Directory**: Add a new folder in `skills/` (e.g., `skills/my-new-skill/`).
+2.  **Add `SKILL.md`**: Create a `SKILL.md` file in the new folder.
+3.  **Define Metadata**: The `SKILL.md` **MUST** start with YAML frontmatter containing `name` and `description`.
+4.  **Keep it Concise**: The `description` should ideally start with a single, clear sentence explaining *what* the skill does and *when* to use it. The discovery hook will only show the first sentence to keep the initial context efficient.
+
+#### Metadata Schema (Example)
+
+```yaml
+---
+name: my-new-skill
+description: Performs deep architectural analysis of the project's dependency graph. Use when planning major refactors or evaluating library updates.
+version: 1.0.0
+---
+```
+
+## Maintenance
+
+- **Update Descriptions**: If you significantly change a skill's purpose, ensure the first sentence of its description in `SKILL.md` is updated.
+- **Workflow Integrity**: Avoid creating empty skill directories or `SKILL.md` files without proper frontmatter.

package/skills/clean-code/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: clean-code
+description: Pragmatic coding standards - concise, direct, no over-engineering, no unnecessary comments
+allowed-tools: Read, Write, Edit
+version: 2.0
+priority: CRITICAL
+---
+
+# Clean Code - Pragmatic AI Coding Standards
+
+> **CRITICAL SKILL** - Be **concise, direct, and solution-focused**.
+
+---
+
+## Core Principles
+
+| Principle | Rule |
+|-----------|------|
+| **SRP** | Single Responsibility - each function/class does ONE thing |
+| **DRY** | Don't Repeat Yourself - extract duplicates, reuse |
+| **KISS** | Keep It Simple - simplest solution that works |
+| **YAGNI** | You Aren't Gonna Need It - don't build unused features |
+| **Boy Scout** | Leave code cleaner than you found it |
+
+---
+
+## Naming Rules
+
+| Element | Convention |
+|---------|------------|
+| **Variables** | Reveal intent: `userCount` not `n` |
+| **Functions** | Verb + noun: `getUserById()` not `user()` |
+| **Booleans** | Question form: `isActive`, `hasPermission`, `canEdit` |
+| **Constants** | SCREAMING_SNAKE: `MAX_RETRY_COUNT` |
+
+> **Rule:** If you need a comment to explain a name, rename it.
+
+---
+
+## Function Rules
+
+| Rule | Description |
+|------|-------------|
+| **Small** | Max 20 lines, ideally 5-10 |
+| **One Thing** | Does one thing, does it well |
+| **One Level** | One level of abstraction per function |
+| **Few Args** | Max 3 arguments, prefer 0-2 |
+| **No Side Effects** | Don't mutate inputs unexpectedly |
+
+---
+
+## Code Structure
+
+| Pattern | Apply |
+|---------|-------|
+| **Guard Clauses** | Early returns for edge cases |
+| **Flat > Nested** | Avoid deep nesting (max 2 levels) |
+| **Composition** | Small functions composed together |
+| **Colocation** | Keep related code close |
+
+---
+
+## AI Coding Style
+
+| Situation | Action |
+|-----------|--------|
+| User asks for feature | Write it directly |
+| User reports bug | Fix it, don't explain |
+| No clear requirement | Ask, don't assume |
+
+---
+
+## Anti-Patterns (DON'T)
+
+| ❌ Pattern | ✅ Fix |
+|-----------|-------|
+| Comment every line | Delete obvious comments |
+| Helper for one-liner | Inline the code |
+| Factory for 2 objects | Direct instantiation |
+| utils.ts with 1 function | Put code where used |
+| "First we import..." | Just write code |
+| Deep nesting | Guard clauses |
+| Magic numbers | Named constants |
+| God functions | Split by responsibility |
+
+---
+
+## 🔴 Before Editing ANY File (THINK FIRST!)
+
+**Before changing a file, ask yourself:**
+
+| Question | Why |
+|----------|-----|
+| **What imports this file?** | They might break |
+| **What does this file import?** | Interface changes |
+| **What tests cover this?** | Tests might fail |
+| **Is this a shared component?** | Multiple places affected |
+
+**Quick Check:**
+```
+File to edit: UserService.ts
+└── Who imports this? → UserController.ts, AuthController.ts
+└── Do they need changes too? → Check function signatures
+```
+
+> 🔴 **Rule:** Edit the file + all dependent files in the SAME task.
+> 🔴 **Never leave broken imports or missing updates.**
+
+---
+
+## Summary
+
+| Do | Don't |
+|----|-------|
+| Write code directly | Write tutorials |
+| Let code self-document | Add obvious comments |
+| Fix bugs immediately | Explain the fix first |
+| Inline small things | Create unnecessary files |
+| Name things clearly | Use abbreviations |
+| Keep functions small | Write 100+ line functions |
+
+> **Remember: The user wants working code, not a programming lesson.**
+
+---
+
+## 🔴 Self-Check Before Completing (MANDATORY)
+
+**Before saying "task complete", verify:**
+
+| Check | Question |
+|-------|----------|
+| ✅ **Goal met?** | Did I do exactly what user asked? |
+| ✅ **Files edited?** | Did I modify all necessary files? |
+| ✅ **Code works?** | Did I test/verify the change? |
+| ✅ **No errors?** | Lint and TypeScript pass? |
+| ✅ **Nothing forgotten?** | Any edge cases missed? |
+
+> 🔴 **Rule:** If ANY check fails, fix it before completing.
+
+---
+
+## Verification Scripts (MANDATORY)
+
+> 🔴 **CRITICAL:** Each agent runs ONLY their own skill's scripts after completing work.
+
+### Agent → Script Mapping
+
+| Agent | Script | Command |
+|-------|--------|---------|
+| **frontend-specialist** | UX Audit | `python ~/.claude/skills/frontend-design/scripts/ux_audit.py .` |
+| **frontend-specialist** | A11y Check | `python ~/.claude/skills/frontend-design/scripts/accessibility_checker.py .` |
+| **backend-specialist** | API Validator | `python ~/.claude/skills/api-patterns/scripts/api_validator.py .` |
+| **mobile-developer** | Mobile Audit | `python ~/.claude/skills/mobile-design/scripts/mobile_audit.py .` |
+| **database-architect** | Schema Validate | `python ~/.claude/skills/database-design/scripts/schema_validator.py .` |
+| **security-auditor** | Security Scan | `python ~/.claude/skills/vulnerability-scanner/scripts/security_scan.py .` |
+| **seo-specialist** | SEO Check | `python ~/.claude/skills/seo-fundamentals/scripts/seo_checker.py .` |
+| **seo-specialist** | GEO Check | `python ~/.claude/skills/geo-fundamentals/scripts/geo_checker.py .` |
+| **performance-optimizer** | Lighthouse | `python ~/.claude/skills/performance-profiling/scripts/lighthouse_audit.py <url>` |
+| **test-engineer** | Test Runner | `python ~/.claude/skills/testing-patterns/scripts/test_runner.py .` |
+| **test-engineer** | Playwright | `python ~/.claude/skills/webapp-testing/scripts/playwright_runner.py <url>` |
+| **Any agent** | Lint Check | `python ~/.claude/skills/lint-and-validate/scripts/lint_runner.py .` |
+| **Any agent** | Type Coverage | `python ~/.claude/skills/lint-and-validate/scripts/type_coverage.py .` |
+| **Any agent** | i18n Check | `python ~/.claude/skills/i18n-localization/scripts/i18n_checker.py .` |
+
+> ❌ **WRONG:** `test-engineer` running `ux_audit.py`
+> ✅ **CORRECT:** `frontend-specialist` running `ux_audit.py`
+
+---
+
+### 🔴 Script Output Handling (READ → SUMMARIZE → ASK)
+
+**When running a validation script, you MUST:**
+
+1. **Run the script** and capture ALL output
+2. **Parse the output** - identify errors, warnings, and passes
+3. **Summarize to user** in this format:
+
+```markdown
+## Script Results: [script_name.py]
+
+### ❌ Errors Found (X items)
+- [File:Line] Error description 1
+- [File:Line] Error description 2
+
+### ⚠️ Warnings (Y items)
+- [File:Line] Warning description
+
+### ✅ Passed (Z items)
+- Check 1 passed
+- Check 2 passed
+
+**Should I fix the X errors?**
+```
+
+4. **Wait for user confirmation** before fixing
+5. **After fixing** → Re-run script to confirm
+
+> 🔴 **VIOLATION:** Running script and ignoring output = FAILED task.
+> 🔴 **VIOLATION:** Auto-fixing without asking = Not allowed.
+> 🔴 **Rule:** Always READ output → SUMMARIZE → ASK → then fix.
+

package/skills/delegating/SKILL.md

@@ -0,0 +1,196 @@
+---
+name: delegating
+description: >-
+  Proactively delegates tasks to cost-optimized agents before working in main session.
+  MUST suggest for: tests, typos, formatting, docs, refactors, code reviews, feature
+  implementation, debugging, commit validation. Skips main session token usage by routing
+  to GLM (simple/deterministic), Gemini (reasoning/analysis), Qwen (quality/patterns),
+  or multi-agent orchestration (review, feature dev, bug hunt). Never suggest for:
+  architecture decisions, security-critical code, unknown-cause bugs, performance optimization.
+allowed-tools: Bash
+---
+
+# Delegating Tasks
+
+Delegate tasks to cost-optimized models (CCS) or multi-agent orchestration workflows (Gemini/Qwen).
+
+## When to Suggest
+
+**Task Pattern → Backend Mapping** (auto-selection logic):
+
+| Task Pattern                  | Backend     | Cost   | Reason                         |
+|-------------------------------|-------------|--------|--------------------------------|
+| `typo\|test\|doc\|format`     | CCS (GLM)   | LOW    | Simple deterministic           |
+| `think\|analyze\|reason`      | CCS (Gemini)| MEDIUM | Requires reasoning             |
+| `review.*(code\|security)`    | Orchestration| HIGH   | Multi-agent code review        |
+| `implement.*feature`          | Orchestration| HIGH   | Full development workflow      |
+| `validate.*commit`            | Orchestration| MEDIUM | Security+Quality validation    |
+| `debug\|bug.*unknown`         | Orchestration| HIGH   | Root cause investigation       |
+
+**Never Suggest For:**
+- Architecture decisions requiring human judgment
+- Security-critical without review
+- Performance optimization (needs profiling first)
+
+---
+
+## Interactive Menu
+
+### Step 1: Delegation Choice
+
+Use AskUserQuestion with:
+- question: "This task can be delegated. How would you like to proceed?"
+- header: "Execution"
+- options:
+  - "Delegate (Recommended)" — Execute via optimal backend. Saves main session tokens and uses cost-efficient models.
+  - "Work in main session" — Execute in current Claude session. Better for tasks requiring discussion or complex context.
+
+**If user selects "Delegate"** → Continue to Step 2
+**If user selects "Work in main session"** → Execute task normally (don't delegate)
+
+### Step 2: Backend Selection
+
+Use AskUserQuestion with:
+- question: "Which backend should handle this task?"
+- header: "Backend"
+- options:
+  - "Auto-select (Recommended)" — Analyzes task keywords and selects optimal backend/profile automatically.
+  - "GLM - Cost-optimized" — Fast model for tests, typos, formatting [LOW COST]
+  - "Gemini - Reasoning" — Analysis, thinking, architecture tasks [MEDIUM COST]
+  - "Qwen - Quality" — Code quality, pattern detection [MEDIUM COST]
+  - "Multi-Agent Orchestration" — Direct Gemini/Qwen collaboration for complex tasks (review, feature dev, debugging) [HIGH COST]
+
+---
+
+## Auto-Selection Logic
+
+**Configuration-Driven:** All pattern matching is defined in [config.yaml](config.yaml), not hardcoded.
+
+### Configuration Structure
+
+The skill reads `config.yaml` to determine:
+1. **Available backends** (CCS profiles + Orchestration workflows)
+2. **Pattern mappings** (task keywords → backend selection)
+3. **Priority order** (Orchestration workflows checked before CCS)
+4. **Default fallback** (when no pattern matches)
+
+---
+
+## Orchestration Workflow Selection (Autonomous)
+
+When `backend: 'orchestration'` is selected, **Claude autonomously** chooses the appropriate workflow and orchestrates between `gemini` and `qwen` CLI tools.
+
+### Selection Process
+
+1. **Load config** - Read workflow definitions from `config.yaml`
+2. **Match patterns** - Determine which orchestration pattern (collaborative, handshake, troubleshoot) applies.
+3. **Execute turn protocol** - Use CLI commands sequentially:
+   - `gemini -p "..."`
+   - `qwen "..."`
+   - `gemini -r latest -p "..."` (to refine)
+
+### Turn Protocols
+
+| Workflow | Protocol |
+| :--- | :--- |
+| **handshake** | 1 turn: Agent A (Gemini) proposes -> Agent B (Qwen) validates. |
+| **collaborative** | 3 turns: Gemini designs -> Qwen critiques -> Gemini refines. |
+| **troubleshoot** | 4 turns: Gemini hypothesis -> Qwen verification -> Gemini root cause -> Final synthesis. |
+
+---
+
+## Execution Flow
+
+### For Direct Invocation (`/delegation [task]` or `/delegate [task]`)
+
+1. **Parse override flag** (if present: `--glm`, `--gemini`, `--orchestrate`, etc.)
+2. **Auto-select backend** using keyword-based logic.
+3. **Route to appropriate backend** (see sections below).
+4. **Report results**: Backend, Workflow (if Orchestration), Cost indicator, Duration.
+
+---
+
+### CCS / GLM Execution
+
+CCS wraps the `claude` CLI and **only works with GLM**. It requires a PTY for output and is blocked by the `CLAUDECODE` nested-session guard — always run via tmux:
+
+```bash
+tmux new-session -d -s ccs_task "env -u CLAUDECODE ccs glm -p '{task}' > /tmp/ccs_out.txt 2>&1"
+sleep 30  # or poll until session exits
+cat /tmp/ccs_out.txt
+```
+
+**If the task requires file modifications**, add `--dangerously-skip-permissions`:
+
+```bash
+tmux new-session -d -s ccs_task "env -u CLAUDECODE ccs glm --dangerously-skip-permissions -p '{task}' > /tmp/ccs_out.txt 2>&1"
+```
+
+---
+
+### Gemini CLI Execution
+
+Gemini is a **direct CLI** — no tmux workaround needed:
+
+```bash
+gemini -p "task description"
+```
+
+**If the task requires file modifications**, add `-y` to auto-approve all tool calls:
+
+```bash
+gemini -y -p "task description"
+```
+
+---
+
+### Qwen CLI Execution
+
+Qwen is a **direct CLI** — no tmux workaround needed:
+
+```bash
+qwen "task description"
+```
+
+**If the task requires file modifications**, add `-y` to auto-approve all tool calls:
+
+```bash
+qwen -y "task description"
+```
+
+---
+
+### Orchestration Execution
+
+Multi-turn sequences use Gemini and Qwen **direct CLIs**. Add `-y` to all turns when modifications are expected:
+
+```bash
+gemini -y -p "..."            # Turn 1
+qwen -y "..."                 # Turn 2
+gemini -y -r latest -p "..."  # Turn 3 (refine)
+```
+
+---
+
+## Examples
+
+### Auto-Selection Examples
+
+**CCS Simple:**
+- `/delegate add unit tests for UserService` → CCS (GLM)
+- `/delegate think about the best database schema` → CCS (Gemini)
+
+**Orchestration Workflows:**
+- `/delegate review this code for security issues` → Orchestration (parallel-review)
+- `/delegate implement OAuth authentication feature` → Orchestration (feature-design)
+- `/delegate debug crash on startup` → Orchestration (bug-hunt)
+
+---
+
+## Notes
+
+### Version 7.0.0 - Direct Orchestration
+- **Independent of unitAI**: Now uses direct `gemini` and `qwen` CLI calls.
+- **Unified backends**: CCS (cost-optimized) + Direct Orchestration.
+- **Config-driven**: All behavior defined in `config.yaml`.
+- **Reference**: Uses patterns from [orchestrating-agents](../orchestrating-agents/SKILL.md).