xtrm-tools 2.1.5 → 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/service-skills-set/install-service-skills.py

@@ -55,6 +55,7 @@ SETTINGS_HOOKS = {
 
 MARKER_DOC       = "# [jaggers] doc-reminder"
 MARKER_STALENESS = "# [jaggers] skill-staleness"
+MARKER_CHAIN     = "# [jaggers] chain-githooks"
 
 
 def get_project_root() -> Path:
@@ -126,25 +127,54 @@ def install_git_hooks(project_root: Path) -> None:
          f"\n{MARKER_STALENESS}\nif command -v python3 &>/dev/null && [ -f \"{staleness_script}\" ]; then\n    python3 \"{staleness_script}\" || true\nfi\n"),
     ]
 
-    changed = False
     for hook_path, marker, snippet in snippets:
         content = hook_path.read_text(encoding="utf-8")
         if marker not in content:
             hook_path.write_text(content + snippet, encoding="utf-8")
             print(f"{GREEN}  ✓{NC} {hook_path.relative_to(project_root)}")
-            changed = True
         else:
             print(f"{YELLOW}  ○{NC} already installed: {hook_path.name}")
 
-    if changed:
-        git_dir = project_root / ".git" / "hooks"
-        git_dir.mkdir(parents=True, exist_ok=True)
-        for src, name in ((pre_commit, "pre-commit"), (pre_push, "pre-push")):
-            if src.exists():
-                dest = git_dir / name
-                shutil.copy2(src, dest)
-                dest.chmod(0o755)
-        print(f"{GREEN}  ✓{NC} activated in .git/hooks/")
+    hooks_path = ""
+    try:
+        r = subprocess.run(
+            ["git", "config", "--get", "core.hooksPath"],
+            cwd=project_root,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+        if r.returncode == 0:
+            hooks_path = r.stdout.strip()
+    except Exception:
+        hooks_path = ""
+
+    active_hooks_dir = (Path(hooks_path) if Path(hooks_path).is_absolute() else project_root / hooks_path) if hooks_path else (project_root / ".git" / "hooks")
+    activation_targets = {project_root / ".git" / "hooks", active_hooks_dir}
+
+    for hooks_dir in activation_targets:
+        hooks_dir.mkdir(parents=True, exist_ok=True)
+        for name, source_hook in (("pre-commit", pre_commit), ("pre-push", pre_push)):
+            target_hook = hooks_dir / name
+            if not target_hook.exists():
+                target_hook.write_text("#!/usr/bin/env bash\n", encoding="utf-8")
+            target_hook.chmod(0o755)
+
+            if target_hook.resolve() == source_hook.resolve():
+                continue
+
+            chain_snippet = (
+                f"\n{MARKER_CHAIN}\n"
+                f"if [ -x \"{source_hook}\" ]; then\n"
+                f"    \"{source_hook}\" \"$@\"\n"
+                "fi\n"
+            )
+            target_content = target_hook.read_text(encoding="utf-8")
+            if MARKER_CHAIN not in target_content:
+                target_hook.write_text(target_content + chain_snippet, encoding="utf-8")
+
+    print(f"{GREEN}  ✓{NC} activated in .git/hooks/")
 
 
 def main() -> None:

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/tdd-guard/reporters/jest/src/JestReporter.test-data.ts

@@ -0,0 +1,199 @@
+import type { Test, TestResult, AggregatedResult } from '@jest/reporters'
+import type { Config } from '@jest/types'
+
+// Create a minimal snapshot object that satisfies the type requirements
+const createSnapshot = (): TestResult['snapshot'] =>
+  ({
+    added: 0,
+    didUpdate: false,
+    failure: false,
+    filesAdded: 0,
+    filesRemoved: 0,
+    filesRemovedList: [],
+    filesUnmatched: 0,
+    filesUpdated: 0,
+    matched: 0,
+    total: 0,
+    unchecked: 0,
+    uncheckedKeysByFile: [],
+    unmatched: 0,
+    updated: 0,
+    // Additional properties that might be required by different versions
+    fileDeleted: false,
+    uncheckedKeys: [],
+  }) as TestResult['snapshot']
+
+// Create a minimal snapshot summary for AggregatedResult
+const createSnapshotSummary = (): AggregatedResult['snapshot'] =>
+  ({
+    added: 0,
+    didUpdate: false,
+    failure: false,
+    filesAdded: 0,
+    filesRemoved: 0,
+    filesRemovedList: [],
+    filesUnmatched: 0,
+    filesUpdated: 0,
+    matched: 0,
+    total: 0,
+    unchecked: 0,
+    uncheckedKeysByFile: [],
+    unmatched: 0,
+    updated: 0,
+  }) as AggregatedResult['snapshot']
+
+// Create a minimal Test object
+export function createTest(overrides?: Partial<Test>): Test {
+  // For test purposes, we create minimal mock implementations
+  const mockContext = {
+    config: {} as Config.ProjectConfig,
+    hasteFS: {} as never, // Using never since we don't access these properties
+    moduleMap: {} as never, // Using never since we don't access these properties
+    resolver: {} as never, // Using never since we don't access these properties
+  }
+
+  return {
+    context: mockContext,
+    duration: 100,
+    path: '/test/example.test.ts',
+    ...overrides,
+  } as Test
+}
+
+// Create a minimal TestResult object
+export function createTestResult(overrides?: Partial<TestResult>): TestResult {
+  const base: TestResult = {
+    leaks: false,
+    numFailingTests: 0,
+    numPassingTests: 1,
+    numPendingTests: 0,
+    numTodoTests: 0,
+    openHandles: [],
+    perfStats: {
+      end: 1000,
+      runtime: 100,
+      slow: false,
+      start: 900,
+      loadTestEnvironmentEnd: 950,
+      loadTestEnvironmentStart: 920,
+      setupAfterEnvEnd: 980,
+      setupAfterEnvStart: 960,
+      setupFilesEnd: 940,
+      setupFilesStart: 930,
+    },
+    skipped: false,
+    snapshot: createSnapshot(),
+    testExecError: undefined,
+    testFilePath: '/test/example.test.ts',
+    testResults: [
+      {
+        ancestorTitles: ['Example Suite'],
+        duration: 5,
+        failureDetails: [],
+        failureMessages: [],
+        fullName: 'Example Suite should pass',
+        invocations: 1,
+        location: undefined,
+        numPassingAsserts: 0,
+        retryReasons: [],
+        status: 'passed',
+        title: 'should pass',
+      },
+    ],
+    ...overrides,
+  }
+
+  // If test is failing, update the test results
+  if (overrides?.numFailingTests && overrides.numFailingTests > 0) {
+    base.testResults = [
+      {
+        ancestorTitles: ['Example Suite'],
+        duration: 5,
+        failureDetails: [{}],
+        failureMessages: ['expected 2 to be 3'],
+        fullName: 'Example Suite should fail',
+        invocations: 1,
+        location: undefined,
+        numPassingAsserts: 0,
+        retryReasons: [],
+        status: 'failed',
+        title: 'should fail',
+      },
+    ]
+  }
+
+  return base
+}
+
+// Create a minimal AggregatedResult object
+export function createAggregatedResult(
+  overrides?: Partial<AggregatedResult>
+): AggregatedResult {
+  return {
+    numFailedTestSuites: 0,
+    numFailedTests: 0,
+    numPassedTestSuites: 1,
+    numPassedTests: 1,
+    numPendingTestSuites: 0,
+    numPendingTests: 0,
+    numRuntimeErrorTestSuites: 0,
+    numTodoTests: 0,
+    numTotalTestSuites: 1,
+    numTotalTests: 1,
+    openHandles: [],
+    runExecError: undefined,
+    snapshot: createSnapshotSummary(),
+    startTime: Date.now(),
+    success: true,
+    testResults: [],
+    wasInterrupted: false,
+    ...overrides,
+  }
+}
+
+export function createUnhandledError(
+  overrides: Partial<{ name: string; message: string; stack: string }> = {}
+): AggregatedResult['runExecError'] {
+  return {
+    message: overrides.message ?? 'Cannot find module "./helpers"',
+    stack:
+      overrides.stack ??
+      "Error: Cannot find module './helpers' imported from '/src/example.test.ts'",
+    ...(overrides.name && { name: overrides.name }),
+    // SerializableError might have additional properties but these are the required ones
+  }
+}
+
+// Create a module error (testExecError) for import failures
+export function createModuleError(
+  overrides: Partial<{
+    name: string
+    message: string
+    stack: string
+    type: string
+    code: string
+  }> = {}
+): TestResult['testExecError'] {
+  return {
+    message: overrides.message ?? "Cannot find module './non-existent-module'",
+    stack:
+      overrides.stack ??
+      "Error: Cannot find module './non-existent-module'\n    at Resolver.resolveModule",
+    ...(overrides.name && { name: overrides.name }),
+    ...(overrides.type && { type: overrides.type }),
+    ...(overrides.code && { code: overrides.code }),
+  }
+}
+
+// Create a TestResult with module import error
+export function createTestResultWithModuleError(
+  overrides?: Partial<TestResult>
+): TestResult {
+  return createTestResult({
+    testExecError: createModuleError(),
+    testResults: [], // No test results when module fails to load
+    numFailingTests: 0,
+    numPassingTests: 0,
+    ...overrides,
+  })
+}