xtrm-tools 2.1.5 → 2.1.6

package/hooks/main-guard.mjs

@@ -43,7 +43,16 @@ function deny(reason) {
   process.exit(2);
 }
 
-const WRITE_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+const WRITE_TOOLS = new Set([
+  'Edit',
+  'Write',
+  'MultiEdit',
+  'NotebookEdit',
+  'mcp__serena__rename_symbol',
+  'mcp__serena__replace_symbol_body',
+  'mcp__serena__insert_after_symbol',
+  'mcp__serena__insert_before_symbol',
+]);
 
 if (WRITE_TOOLS.has(tool)) {
   deny(

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "xtrm-tools",
-  "version": "2.1.5",
+  "version": "2.1.6",
   "description": "Claude Code tools installer (skills, hooks, MCP servers)",
   "license": "MIT",
   "type": "module",
+  "workspaces": [
+    "cli"
+  ],
   "bin": {
     "xtrm": "cli/dist/index.cjs"
   },
@@ -29,10 +32,12 @@
     "url": "https://github.com/Jaggerxtrm/xtrm-tools/issues"
   },
   "scripts": {
-    "build": "npm run build --prefix cli",
+    "build": "npm run build --workspace cli",
+    "typecheck": "npm run typecheck --workspace cli",
     "start": "node cli/dist/index.cjs",
     "lint": "echo 'No linting configured'",
-    "test": "echo 'No tests configured'"
+    "test": "npm test --workspace cli",
+    "prepublishOnly": "npm run build"
   },
   "engines": {
     "node": ">=18.0.0"

package/project-skills/py-quality-gate/.claude/hooks/quality-check.py

@@ -218,9 +218,22 @@ def parse_json_input() -> dict:
         sys.exit(1)
 
 def extract_file_path(input_data: dict) -> str | None:
-    """Extract file path from tool input"""
+    """Extract file path from tool input, including Serena relative_path."""
     tool_input = input_data.get('tool_input', {})
-    return tool_input.get('file_path') or tool_input.get('path')
+    file_path = (
+        tool_input.get('file_path')
+        or tool_input.get('path')
+        or tool_input.get('relative_path')
+    )
+    if not file_path:
+        return None
+
+    # Serena tools pass relative_path relative to the project root.
+    if not os.path.isabs(file_path):
+        project_root = os.environ.get('CLAUDE_PROJECT_DIR') or os.getcwd()
+        return str(Path(project_root) / file_path)
+
+    return file_path
 
 def main():
     """Main entry point"""

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/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,
+  })
+}

package/project-skills/tdd-guard/reporters/jest/src/JestReporter.test.ts

@@ -0,0 +1,302 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { JestReporter } from './JestReporter'
+import {
+  FileStorage,
+  MemoryStorage,
+  Config as TDDConfig,
+  DEFAULT_DATA_DIR,
+} from 'tdd-guard'
+import path from 'node:path'
+import {
+  createTest,
+  createTestResult,
+  createAggregatedResult,
+  createUnhandledError,
+  createModuleError,
+  createTestResultWithModuleError,
+} from './JestReporter.test-data'
+
+describe('JestReporter', () => {
+  let sut: ReturnType<typeof setupJestReporter>
+
+  beforeEach(() => {
+    sut = setupJestReporter()
+  })
+
+  describe('constructor', () => {
+    it('uses FileStorage by default', () => {
+      const reporter = new JestReporter()
+      expect(reporter['storage']).toBeInstanceOf(FileStorage)
+    })
+
+    it('accepts Storage instance in reporterOptions', () => {
+      const storage = new MemoryStorage()
+      const globalConfig = undefined
+      const reporterOptions = { storage }
+      const reporter = new JestReporter(globalConfig, reporterOptions)
+      expect(reporter['storage']).toBe(storage)
+    })
+
+    it('accepts projectRoot string in reporterOptions', () => {
+      const rootPath = '/some/project/root'
+      const globalConfig = undefined
+      const reporterOptions = { projectRoot: rootPath }
+      const reporter = new JestReporter(globalConfig, reporterOptions)
+
+      // Verify the storage is configured with the correct path
+      const fileStorage = reporter['storage'] as FileStorage
+      const config = fileStorage['config'] as TDDConfig
+      const expectedDataDir = path.join(
+        rootPath,
+        ...DEFAULT_DATA_DIR.split('/')
+      )
+      expect(config.dataDir).toBe(expectedDataDir)
+    })
+  })
+
+  describe('onTestResult', () => {
+    it('collects test results', () => {
+      const test = createTest()
+      const testResult = createTestResult()
+
+      sut.reporter.onTestResult(test, testResult)
+
+      expect(sut.reporter['testModules'].size).toBe(1)
+    })
+  })
+
+  describe('onRunComplete', () => {
+    it('saves test results to storage', async () => {
+      const test = createTest()
+      const testResult = createTestResult()
+      const aggregatedResult = createAggregatedResult()
+
+      // Collect test results first
+      sut.reporter.onTestResult(test, testResult)
+
+      // Run complete
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify results were saved
+      const parsed = await sut.getParsedData()
+      expect(parsed).toBeTruthy()
+      expect(parsed.testModules).toHaveLength(1)
+    })
+
+    it('includes test case details in output', async () => {
+      const test = createTest()
+      const testResult = createTestResult()
+      const aggregatedResult = createAggregatedResult()
+
+      // Collect test results
+      sut.reporter.onTestResult(test, testResult)
+
+      // Run complete
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify test details are included
+      const parsed = await sut.getParsedData()
+      const module = parsed.testModules[0]
+      expect(module.tests).toHaveLength(1)
+      expect(module.tests[0].name).toBe('should pass')
+      expect(module.tests[0].fullName).toBe('Example Suite should pass')
+      expect(module.tests[0].state).toBe('passed')
+    })
+
+    it('includes error details for failed tests', async () => {
+      const test = createTest()
+      const failedTestResult = createTestResult({ numFailingTests: 1 })
+      const aggregatedResult = createAggregatedResult()
+
+      // Collect test results
+      sut.reporter.onTestResult(test, failedTestResult)
+
+      // Run complete
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify error details are included
+      const parsed = await sut.getParsedData()
+      const module = parsed.testModules[0]
+      const failedTest = module.tests[0]
+      expect(failedTest.state).toBe('failed')
+      expect(failedTest.errors).toBeDefined()
+      expect(failedTest.errors).toHaveLength(1)
+      expect(failedTest.errors[0].message).toBe('expected 2 to be 3')
+    })
+
+    it('handles empty test runs', async () => {
+      // Run complete without any tests
+      await sut.reporter.onRunComplete(new Set(), createAggregatedResult())
+
+      // Verify empty output
+      const parsed = await sut.getParsedData()
+      expect(parsed.testModules).toEqual([])
+    })
+
+    it('includes unhandled errors in output', async () => {
+      const error = createUnhandledError()
+      const aggregatedResult = createAggregatedResult({
+        runExecError: error,
+      })
+
+      // Run complete with unhandled error
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      // Verify unhandled errors are included
+      const parsed = await sut.getParsedData()
+      expect(parsed.unhandledErrors).toBeDefined()
+      expect(parsed.unhandledErrors).toHaveLength(1)
+      expect(parsed.unhandledErrors[0].message).toBe(
+        'Cannot find module "./helpers"'
+      )
+      expect(parsed.unhandledErrors[0].name).toBe('Error')
+      expect(parsed.unhandledErrors[0].stack).toContain('imported from')
+    })
+
+    it('includes test run reason when tests pass', async () => {
+      const test = createTest()
+      const testResult = createTestResult()
+      const aggregatedResult = createAggregatedResult({
+        success: true,
+        numFailedTests: 0,
+      })
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      expect(parsed.reason).toBe('passed')
+    })
+
+    it('handles SerializableError without name property', async () => {
+      const aggregatedResult = createAggregatedResult({
+        runExecError: {
+          message: 'Module not found',
+          stack: 'at test.js:1:1',
+        },
+      })
+
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      expect(parsed.unhandledErrors[0].message).toBe('Module not found')
+      expect(parsed.unhandledErrors[0].name).toBe('Error')
+      expect(parsed.unhandledErrors[0].stack).toBe('at test.js:1:1')
+    })
+
+    it('includes module import errors as failed tests', async () => {
+      const test = createTest()
+      const testResult = createTestResultWithModuleError()
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const module = parsed.testModules[0]
+      expect(module.tests).toHaveLength(1)
+
+      const importErrorTest = module.tests[0]
+      expect(importErrorTest.name).toBe('Module failed to load (Error)')
+      expect(importErrorTest.fullName).toBe('Module failed to load (Error)')
+      expect(importErrorTest.state).toBe('failed')
+      expect(importErrorTest.errors).toHaveLength(1)
+      expect(importErrorTest.errors[0].message).toBe(
+        "Cannot find module './non-existent-module'"
+      )
+    })
+
+    it('preserves error stack trace from module import errors', async () => {
+      const test = createTest()
+      const moduleError = createModuleError({
+        message: "Cannot find module './helpers'",
+        stack:
+          "Error: Cannot find module './helpers'\n    at Function.Module._resolveFilename",
+        name: 'Error',
+      })
+      const testResult = createTestResultWithModuleError({
+        testExecError: moduleError,
+      })
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const importErrorTest = parsed.testModules[0].tests[0]
+
+      expect(importErrorTest.errors[0].stack).toBe(
+        "Error: Cannot find module './helpers'\n    at Function.Module._resolveFilename"
+      )
+      expect(importErrorTest.errors[0].name).toBe('Error')
+    })
+
+    it('uses error type in test name for module import errors', async () => {
+      const test = createTest()
+      const testResult = createTestResultWithModuleError({
+        testExecError: createModuleError({
+          message: 'Module parse failed',
+          stack: 'SyntaxError: Unexpected token',
+          name: 'SyntaxError',
+        }),
+      })
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const importErrorTest = parsed.testModules[0].tests[0]
+
+      expect(importErrorTest.name).toBe('Module failed to load (SyntaxError)')
+      expect(importErrorTest.fullName).toBe(
+        'Module failed to load (SyntaxError)'
+      )
+    })
+
+    it('handles SerializableError with type field for module import errors', async () => {
+      const test = createTest()
+      const testResult = createTestResultWithModuleError({
+        testExecError: createModuleError({
+          message: 'Module error',
+          stack: 'at test.js:1',
+          type: 'ReferenceError',
+          code: 'ERR_MODULE_NOT_FOUND',
+        }),
+      })
+      const aggregatedResult = createAggregatedResult()
+
+      sut.reporter.onTestResult(test, testResult)
+      await sut.reporter.onRunComplete(new Set(), aggregatedResult)
+
+      const parsed = await sut.getParsedData()
+      const importErrorTest = parsed.testModules[0].tests[0]
+
+      expect(importErrorTest.name).toBe(
+        'Module failed to load (ReferenceError)'
+      )
+      expect(importErrorTest.errors[0].name).toBe('ReferenceError')
+      expect(importErrorTest.errors[0].operator).toBe('ERR_MODULE_NOT_FOUND')
+    })
+  })
+})
+
+// Test setup helper function
+function setupJestReporter() {
+  const storage = new MemoryStorage()
+  const globalConfig = undefined
+  const reporterOptions = { storage }
+  const reporter = new JestReporter(globalConfig, reporterOptions)
+
+  // Helper to get parsed test data
+  const getParsedData = async () => {
+    const savedData = await storage.getTest()
+    return savedData ? JSON.parse(savedData) : null
+  }
+
+  return {
+    reporter,
+    storage,
+    getParsedData,
+  }
+}