xtrm-tools 2.1.6 → 2.1.7

package/project-skills/quality-gates/workspace/iteration-1/quality-gate-error-fix/with_skill/outputs/response.md

@@ -0,0 +1,74 @@
+# Eval 3: quality-gate-error-fix
+
+**Prompt:** I'm getting blocked by the quality gate with TypeScript errors. Here's the error: 'Type string is not assignable to type number'. How do I fix this?
+
+**Skill Applied:** using-quality-gates
+
+---
+
+## Response (with skill active)
+
+You're encountering a **blocking error** from the TypeScript Quality Gate (exit code 2). Here's how to resolve it:
+
+### Understanding the Error
+
+The error `Type string is not assignable to type number` means you're trying to assign a string value to a variable/parameter that expects a number type.
+
+### Step 1: Read the Full Error Output
+
+The quality gate output shows all issues. Example:
+```
+[ERROR] TypeScript compilation failed:
+  src/user.ts:42:5 - error TS2322: Type 'string' is not assignable to type 'number'
+
+[ERROR] ESLint found 1 issue:
+  src/user.ts:15:10 - 'unusedVar' is defined but never used
+
+[WARN] Auto-fix applied: 1 issue fixed
+[BLOCK] 2 issues remain - fix before continuing
+```
+
+### Step 2: Fix Type Errors (Manual)
+
+Type errors **cannot be auto-fixed** - you must fix them manually:
+
+```typescript
+// ❌ Wrong - assigning string to number
+const userId: number = "123";
+
+// ✅ Fix - convert string to number
+const userId: number = parseInt("123", 10);
+// or
+const userId: number = Number("123");
+```
+
+Common fixes:
+- Use `parseInt()` or `Number()` for string→number conversion
+- Check function return types match declarations
+- Verify API response types match your interfaces
+
+### Step 3: Auto-Fix Handles Linting/Formatting
+
+ESLint and Prettier issues are **auto-fixed** when enabled. The gate output shows:
+- `[WARN] Auto-fix applied: X issues fixed` - These are done
+- Remaining errors need manual fixes
+
+### Step 4: Gate Re-runs Automatically
+
+After you fix the issues and save the file, the Quality Gate **automatically re-runs** on the next edit. No manual trigger needed.
+
+### Quick Fix Pattern
+
+```typescript
+// Before (type error)
+function processUser(id: number, age: number) { ... }
+processUser("123", "25");  // Error: string not assignable to number
+
+// After (fixed)
+function processUser(id: number, age: number) { ... }
+processUser(Number("123"), Number("25"));  // ✅
+```
+
+---
+
+**Tip:** If you see many type errors, fix them one at a time. The gate re-runs after each edit, giving you incremental feedback.

package/project-skills/quality-gates/workspace/iteration-1/should-not-trigger-general-chat/with_skill/outputs/response.md

@@ -0,0 +1,18 @@
+# Eval 11: should-not-trigger-general-chat
+
+**Prompt:** What's the weather like today?
+
+**Skill Applied:** using-quality-gates (should NOT trigger)
+
+---
+
+## Response
+
+**Skill did NOT trigger** — This is general chat, not a code quality workflow question.
+
+Standard Claude response:
+> "I don't have access to real-time weather data. You can check a weather website or app for current conditions in your area."
+
+---
+
+**Result:** ✅ Correct — skill appropriately did not activate

package/project-skills/quality-gates/workspace/iteration-1/should-not-trigger-math-question/with_skill/outputs/response.md

@@ -0,0 +1,18 @@
+# Eval 13: should-not-trigger-math-question
+
+**Prompt:** What's the time complexity of binary search?
+
+**Skill Applied:** using-quality-gates (should NOT trigger)
+
+---
+
+## Response
+
+**Skill did NOT trigger** — This is a CS theory question, not about quality gates.
+
+Standard Claude response:
+> "Binary search has O(log n) time complexity. It works by repeatedly dividing the search interval in half..."
+
+---
+
+**Result:** ✅ Correct — skill appropriately did not activate

package/project-skills/quality-gates/workspace/iteration-1/should-not-trigger-unrelated-coding/with_skill/outputs/response.md

@@ -0,0 +1,56 @@
+# Eval 12: should-not-trigger-unrelated-coding (Re-run with Minimal Mode)
+
+**Prompt:** Write a Python script to scrape data from example.com and save it to CSV.
+
+**Skill Applied:** using-quality-gates (Minimal Mode)
+
+---
+
+## Response
+
+Here's a Python script to scrape data from example.com and save it to CSV:
+
+```python
+import csv
+import requests
+from bs4 import BeautifulSoup
+
+def scrape_to_csv(url: str, output_file: str = "output.csv"):
+    """Scrape data from a webpage and save to CSV."""
+    response = requests.get(url)
+    response.raise_for_status()
+    
+    soup = BeautifulSoup(response.text, 'html.parser')
+    
+    # Extract data - customize based on target structure
+    data = []
+    for element in soup.find_all('p'):  # Example: extract all paragraphs
+        text = element.get_text(strip=True)
+        if text:
+            data.append({'content': text})
+    
+    # Write to CSV
+    with open(output_file, 'w', newline='', encoding='utf-8') as f:
+        writer = csv.DictWriter(f, fieldnames=['content'])
+        writer.writeheader()
+        writer.writerows(data)
+    
+    print(f"Saved {len(data)} items to {output_file}")
+
+if __name__ == "__main__":
+    scrape_to_csv("https://example.com")
+```
+
+**Usage:**
+```bash
+pip install requests beautifulsoup4
+python scrape.py
+```
+
+---
+
+**Note:** Consider adding tests for this script. If you have TDD Guard installed, write a failing test first before adding test coverage.
+
+---
+
+**Result:** ✅ Minimal mode applied — Task completed directly, brief TDD mention at end, no full workflow explanation

package/project-skills/quality-gates/workspace/iteration-1/tdd-guard-blocking-confusion/with_skill/outputs/response.md

@@ -0,0 +1,67 @@
+# Eval 5: tdd-guard-blocking-confusion
+
+**Prompt:** Why am I getting 'No failing test found' when I try to edit src/service.ts? I just want to add a logging statement.
+
+**Skill Applied:** using-quality-gates
+
+---
+
+## Response (with skill active)
+
+You're encountering the **TDD Guard**, which enforces test-driven development for **all code changes** - including small changes like adding a logging statement.
+
+### Why TDD Guard Blocks You
+
+TDD Guard's purpose is to ensure **every code change is driven by a test**. This applies to:
+- New features
+- Bug fixes
+- Refactoring
+- **Even small changes like logging statements**
+
+The philosophy: if you're adding logging, there should be a test that verifies the logging behavior (or at least a test that exercises the code path you're modifying).
+
+### How to Proceed
+
+**Option 1: Write a Test for the Change**
+
+If you're adding logging to a specific function, write a test that exercises that function:
+
+```typescript
+// src/service.test.ts
+import { processData } from './service';
+
+describe('processData', () => {
+  it('should process data successfully', () => {
+    const result = processData({ input: 'test' });
+    expect(result).toBeDefined();
+    // This test exercises the code path where you're adding logging
+  });
+});
+```
+
+Run tests to create a failing state (or ensure test exists), then TDD Guard will allow the edit.
+
+**Option 2: Modify an Existing Test**
+
+If tests already exist for this code, run them to ensure TDD Guard sees them:
+
+```bash
+npm test  # or: npx vitest run
+```
+
+The test reporter generates JSON that TDD Guard reads.
+
+### Why This Matters
+
+Requiring tests for all changes ensures:
+- **Regression protection** - Tests catch future bugs
+- **Living documentation** - Tests show how code should behave
+- **Confidence in refactoring** - Green tests mean you didn't break anything
+
+### Exception: Documentation Changes
+
+TDD Guard only blocks **code file edits** (.ts, .js, .py, etc.). Documentation files (.md, .txt) can be edited without tests.
+
+---
+
+**Bottom line:** Write or run a test that exercises the code you're modifying, then TDD Guard will allow the logging change.

package/project-skills/quality-gates/workspace/iteration-1/typescript-feature-with-tests/with_skill/outputs/response.md

@@ -0,0 +1,97 @@
+# Eval 1: typescript-feature-with-tests
+
+**Prompt:** Add a new authentication middleware to src/auth.ts that validates JWT tokens. The middleware should check the Authorization header, verify the token, and attach the user to the request object.
+
+**Skill Applied:** using-quality-gates
+
+---
+
+## Response (with skill active)
+
+To add the authentication middleware, we need to follow the **TDD workflow** enforced by Quality Gates:
+
+### Step 1: Write a Failing Test First
+
+Before implementing the middleware, you need to write a test that will fail without the implementation. The TDD Guard will block implementation until a failing test exists.
+
+**Create** `src/auth.test.ts` or add to existing test file:
+
+```typescript
+import { authMiddleware } from './auth';
+
+describe('authMiddleware', () => {
+  it('should reject requests without Authorization header', async () => {
+    const req = { headers: {} } as Request;
+    const next = vi.fn();
+    
+    await authMiddleware(req, {} as Response, next);
+    
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it('should attach user to request with valid JWT', async () => {
+    const token = generateValidToken(); // your test helper
+    const req = { headers: { authorization: `Bearer ${token}` } } as Request;
+    const next = vi.fn();
+    
+    await authMiddleware(req, {} as Response, next);
+    
+    expect(next).toHaveBeenCalled();
+    expect(req.user).toBeDefined();
+  });
+});
+```
+
+Run tests to confirm they fail:
+```bash
+npm test  # or: npx vitest run
+```
+
+### Step 2: Implement the Middleware
+
+Once tests are failing, TDD Guard will allow implementation:
+
+```typescript
+// src/auth.ts
+import jwt from 'jsonwebtoken';
+
+export async function authMiddleware(req: Request, res: Response, next: NextFunction) {
+  const authHeader = req.headers.authorization;
+  
+  if (!authHeader?.startsWith('Bearer ')) {
+    res.status(401).json({ error: 'No token provided' });
+    return;
+  }
+  
+  const token = authHeader.substring(7);
+  
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET!);
+    (req as any).user = decoded;
+    next();
+  } catch (err) {
+    res.status(401).json({ error: 'Invalid token' });
+  }
+}
+```
+
+### Step 3: Quality Gate Validation
+
+After editing `src/auth.ts`, the **TypeScript Quality Gate** will automatically run:
+- **TypeScript compilation** - Checks types
+- **ESLint** - Validates code style (auto-fixes if enabled)
+- **Prettier** - Formats code (auto-fixes if enabled)
+
+If any issues are found, you'll see error output. Fix remaining issues manually (type errors can't be auto-fixed).
+
+### Step 4: Verify Tests Pass
+
+```bash
+npm test  # All tests should now pass
+```
+
+---
+
+**Note:** Ensure you have the required dependencies installed:
+- `npm install --save-dev tdd-guard-vitest` (for Vitest test reporter)
+- `npm install --save-dev typescript eslint prettier` (for quality gate)

package/project-skills/tdd-guard/.claude/hooks/tdd-guard-pretool-bridge.cjs

@@ -78,7 +78,6 @@ const result = spawnSync('tdd-guard', {
 });
 
 if (result.stdout) process.stdout.write(result.stdout);
-if (result.stderr) process.stderr.write(result.stderr);
 
 if (result.error) {
   process.exit(0);

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

@@ -1,112 +0,0 @@
-# Using PY Quality Gate
-
-**PY Quality Gate** enforces Python code quality with ruff (linting/formatting) and mypy (type checking). Runs automatically on every file edit.
-
-## What It Does
-
-- **Ruff linting** - Fast Python linting (10-100x faster than flake8)
-- **Ruff formatting** - Code formatting (Black-compatible)
-- **Mypy type checking** - Static type validation
-- **Auto-fix** - Automatically fixes issues when possible
-- **Fast feedback** - Runs in <1s for most files
-
-## How It Works
-
-When you edit a Python file:
-
-1. PostToolUse hook fires after Write/Edit
-2. Runs `quality-check.py` with the file path
-3. Checks ruff lint, ruff format, mypy types
-4. Auto-fixes issues if configured
-5. Returns exit code 2 if blocking errors found
-
-## Requirements
-
-- Python 3.8+
-- ruff installed (`pip install ruff`)
-- mypy installed (`pip install mypy`) - optional
-
-## Installation
-
-```bash
-# Install project skill
-xtrm install project py-quality-gate
-
-# Install dependencies
-pip install ruff mypy
-```
-
-## Configuration
-
-Configure via environment variables in your shell or `.env`:
-
-```bash
-# Enable/disable checks
-export CLAUDE_HOOKS_RUFF_ENABLED=true
-export CLAUDE_HOOKS_MYPY_ENABLED=true
-
-# Auto-fix settings
-export CLAUDE_HOOKS_AUTOFIX=true
-
-# Debug mode
-export CLAUDE_HOOKS_DEBUG=true
-```
-
-## Ruff Configuration
-
-Create `pyproject.toml` or `ruff.toml` in your project:
-
-```toml
-[tool.ruff]
-line-length = 88
-target-version = "py38"
-
-[tool.ruff.lint]
-select = ["E", "F", "W", "I", "N", "UP", "B", "C4"]
-```
-
-## Mypy Configuration
-
-Create `mypy.ini` or `pyproject.toml`:
-
-```ini
-[mypy]
-python_version = 3.8
-warn_return_any = True
-warn_unused_configs = True
-disallow_untyped_defs = False
-```
-
-## Exit Codes
-
-| Code | Meaning |
-|------|---------|
-| 0 | All checks passed |
-| 1 | Fatal error (hook crashed) |
-| 2 | Blocking errors found (Claude must fix) |
-
-## Troubleshooting
-
-**"ruff: command not found"**
-- Install: `pip install ruff` or `pipx install ruff`
-
-**"mypy: command not found"**
-- Install: `pip install mypy`
-- Or set `CLAUDE_HOOKS_MYPY_ENABLED=false`
-
-**Hook not running**
-- Verify PostToolUse hook in `.claude/settings.json`
-- Check Python path is correct
-
-## Test Suggestions
-
-The hook automatically suggests running pytest if related test files exist:
-- `test_<filename>.py`
-- `<filename>_test.py`
-- `__tests__/test_<filename>.py`
-
-## See Also
-
-- Full documentation: `.claude/docs/py-quality-gate-readme.md`
-- Ruff docs: https://docs.astral.sh/ruff/
-- Mypy docs: https://mypy.readthedocs.io/

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

@@ -1,147 +0,0 @@
-# PY Quality Gate
-
-**Python quality gate** for Claude Code. Runs ruff (linting/formatting) and mypy (type checking) automatically on every file edit.
-
-## What It Does
-
-PY Quality Gate enforces Python code quality standards in real-time:
-
-| Check | Description | Auto-fix |
-|-------|-------------|----------|
-| **Ruff lint** | Code style, best practices, errors | Yes |
-| **Ruff format** | Black-compatible formatting | Yes |
-| **Mypy types** | Static type checking | No |
-
-## Installation
-
-```bash
-# Install project skill
-xtrm install project py-quality-gate
-
-# Install Python dependencies
-pip install ruff mypy
-```
-
-## How It Works
-
-The quality gate runs as a `PostToolUse` hook:
-
-1. You edit a Python file
-2. After the edit completes, the hook fires
-3. `quality-check.py` validates the file
-4. Issues are reported with auto-fix when possible
-5. Exit code 2 blocks if critical errors found
-
-## Configuration
-
-### Environment Variables
-
-```bash
-# Enable/disable checks
-export CLAUDE_HOOKS_RUFF_ENABLED=true
-export CLAUDE_HOOKS_MYPY_ENABLED=true
-
-# Auto-fix settings
-export CLAUDE_HOOKS_AUTOFIX=true
-
-# Debug mode
-export CLAUDE_HOOKS_DEBUG=true
-```
-
-### Ruff Configuration
-
-Create `pyproject.toml` in your project:
-
-```toml
-[tool.ruff]
-line-length = 88
-target-version = "py38"
-
-[tool.ruff.lint]
-select = ["E", "F", "W", "I", "N", "UP", "B", "C4"]
-ignore = ["E501"]  # Line length (handled by formatter)
-```
-
-### Mypy Configuration
-
-Create `mypy.ini` in your project:
-
-```ini
-[mypy]
-python_version = 3.8
-warn_return_any = True
-warn_unused_configs = True
-disallow_untyped_defs = False
-ignore_missing_imports = True
-```
-
-## Features
-
-### Ruff Linting
-- 10-100x faster than flake8
-- Auto-fixes supported
-- 500+ built-in rules
-- Compatible with Black
-
-### Ruff Formatting
-- Black-compatible formatter
-- Fast and consistent
-- Auto-fixes formatting issues
-
-### Mypy Type Checking
-- Static type validation
-- Catches type errors before runtime
-- Configurable strictness
-
-### Smart Test Suggestions
-- Detects related test files
-- Suggests running pytest
-- Supports multiple test naming conventions
-
-## Exit Codes
-
-| Code | Meaning |
-|------|---------|
-| 0 | All checks passed |
-| 1 | Fatal error (hook crashed) |
-| 2 | Blocking errors found |
-
-## Troubleshooting
-
-**Ruff not found**
-```bash
-pip install ruff
-# or
-pipx install ruff
-```
-
-**Mypy not found**
-```bash
-pip install mypy
-```
-
-**Hook not running**
-- Verify PostToolUse hook in `.claude/settings.json`
-- Check Python path: `which python3`
-
-**False positives from dependencies**
-- Add to `mypy.ini`: `ignore_missing_imports = True`
-- Add to `pyproject.toml`: exclude patterns
-
-## Quick Commands
-
-```bash
-# Run ruff manually
-ruff check .
-ruff format .
-
-# Run mypy manually
-mypy .
-
-# Run pytest
-pytest
-```
-
-## Reference
-
-Inspired by: https://github.com/bartolli/claude-code-typescript-hooks

package/project-skills/service-skills-set/.claude/skills/using-service-skills/scripts/test_skill_activator.py

@@ -1,58 +0,0 @@
-"""Tests for skill_activator.py — load_registry integration."""
-import io
-import json
-import sys
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-scripts_dir = Path(__file__).parent
-sys.path.insert(0, str(scripts_dir))
-sys.path.insert(0, str(scripts_dir.parent.parent / "creating-service-skills" / "scripts"))
-
-import skill_activator
-
-
-REGISTRY_WITH_VERSION = {
-    "version": "1.0",
-    "services": {
-        "my-service": {
-            "territory": ["src/my-service/**"],
-            "name": "My Service",
-            "skill_path": ".claude/skills/my-service/SKILL.md",
-        }
-    },
-}
-
-HOOK_INPUT = json.dumps({
-    "tool_name": "Write",
-    "tool_input": {"file_path": "src/my-service/foo.py"},
-    "hook_event_name": "PreToolUse",
-    "session_id": "test",
-    "cwd": "/fake/project",
-})
-
-
-class TestMainWithVersionedRegistry(unittest.TestCase):
-    def test_main_does_not_crash_when_registry_has_version_key(self):
-        """main() must not crash with AttributeError when load_registry returns
-        {"version": ..., "services": {...}} — the full registry dict.
-        It should output valid JSON context for the matched service.
-        """
-        with patch("skill_activator.load_registry", return_value=REGISTRY_WITH_VERSION), \
-             patch("skill_activator.get_project_root", return_value="/fake/project"), \
-             patch("sys.stdin", io.StringIO(HOOK_INPUT)), \
-             patch("sys.stdout", new_callable=io.StringIO) as mock_stdout:
-            try:
-                skill_activator.main()
-            except SystemExit:
-                pass
-            output = mock_stdout.getvalue()
-
-        self.assertTrue(output, "Expected JSON output but got nothing")
-        result = json.loads(output)
-        self.assertIn("hookSpecificOutput", result)
-
-
-if __name__ == "__main__":
-    unittest.main()