@opensip-tools/checks-cpp 1.0.4

package/.turbo/turbo-typecheck.log

@@ -0,0 +1,4 @@
+
+> @opensip-tools/checks-cpp@1.0.4 typecheck /Users/sb/Documents/Code/opensip-ai/opensip-tools/packages/fitness/checks-cpp
+> tsc --noEmit
+

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opensip-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@opensip-tools/checks-cpp",
+  "version": "1.0.4",
+  "license": "MIT",
+  "description": "C/C++ fitness checks (clang-tidy backed)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/opensip-ai/opensip-tools.git",
+    "directory": "packages/fitness/checks-cpp"
+  },
+  "homepage": "https://github.com/opensip-ai/opensip-tools",
+  "bugs": {
+    "url": "https://github.com/opensip-ai/opensip-tools/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "@opensip-tools/fitness": "1.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}

package/src/__tests__/clang-tidy.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest'
+
+import { parseClangTidyOutput } from '../checks/clang-tidy-passthrough.js'
+
+describe('parseClangTidyOutput', () => {
+  it('parses a single warning with a lint name', () => {
+    const out = `/abs/path/foo.cpp:42:10: warning: do not use 'goto' [hicpp-avoid-goto]`
+    const violations = parseClangTidyOutput(out, '', 0, ['/abs/path/foo.cpp'], '/abs')
+    expect(violations).toHaveLength(1)
+    expect(violations[0]?.severity).toBe('warning')
+    expect(violations[0]?.line).toBe(42)
+    expect(violations[0]?.message).toContain('hicpp-avoid-goto')
+  })
+
+  it('parses errors with severity error', () => {
+    const out = `/x/y.cpp:5:1: error: expected ';' [clang-diagnostic-error]`
+    const violations = parseClangTidyOutput(out, '', 1, ['/x/y.cpp'], '/x')
+    expect(violations).toHaveLength(1)
+    expect(violations[0]?.severity).toBe('error')
+  })
+
+  it('skips note: lines (notes are continuations of prior diagnostics)', () => {
+    const out = [
+      '/x/y.cpp:5:1: warning: prefer enum class [modernize-use-enum-class]',
+      '/x/y.cpp:5:1: note: change here',
+    ].join('\n')
+    const violations = parseClangTidyOutput(out, '', 0, [], '/x')
+    expect(violations).toHaveLength(1)
+  })
+
+  it('handles diagnostics without a lint name', () => {
+    const out = `/a/b.cpp:1:1: warning: bare warning`
+    const violations = parseClangTidyOutput(out, '', 0, [], '/a')
+    expect(violations).toHaveLength(1)
+    expect(violations[0]?.message).toBe('bare warning')
+  })
+
+  it('returns empty array on empty stdout', () => {
+    expect(parseClangTidyOutput('', '', 0, [], '/x')).toHaveLength(0)
+  })
+
+  it('returns multiple violations for multi-line output', () => {
+    const out = [
+      '/x/y.cpp:1:1: warning: a [check-a]',
+      '/x/y.cpp:5:1: warning: b [check-b]',
+      '/x/y.cpp:9:1: error: c [check-c]',
+    ].join('\n')
+    const violations = parseClangTidyOutput(out, '', 0, [], '/x')
+    expect(violations).toHaveLength(3)
+    expect(violations[0]?.line).toBe(1)
+    expect(violations[1]?.line).toBe(5)
+    expect(violations[2]?.line).toBe(9)
+  })
+})

package/src/__tests__/parse.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+
+import { parseClangTidyOutput } from '../checks/clang-tidy-passthrough.js';
+
+describe('parseClangTidyOutput', () => {
+  it('parses a warning line with a [check-name] tag', () => {
+    const out = parseClangTidyOutput(
+      'src/foo.cpp:42:10: warning: unused variable [misc-unused]',
+      '',
+      0,
+      [],
+      '',
+    );
+    expect(out).toHaveLength(1);
+    expect(out[0]?.severity).toBe('warning');
+    expect(out[0]?.line).toBe(42);
+    expect(out[0]?.message).toContain('[misc-unused]');
+    expect(out[0]?.message).toContain('unused variable');
+  });
+
+  it('parses an error line', () => {
+    const out = parseClangTidyOutput(
+      'src/x.cpp:5:1: error: something exploded [bugprone-foo]',
+      '',
+      0,
+      [],
+      '',
+    );
+    expect(out[0]?.severity).toBe('error');
+  });
+
+  it('parses a line without a [check-name] tag', () => {
+    const out = parseClangTidyOutput('src/y.cpp:1:1: warning: unparsed', '', 0, [], '');
+    expect(out).toHaveLength(1);
+    expect(out[0]?.message).toBe('unparsed');
+  });
+
+  it('skips note: lines', () => {
+    const out = parseClangTidyOutput(
+      'src/a.cpp:1:1: warning: w [misc]\nsrc/a.cpp:1:1: note: more info',
+      '',
+      0,
+      [],
+      '',
+    );
+    expect(out).toHaveLength(1);
+  });
+
+  it('skips lines that do not match the expected format', () => {
+    const out = parseClangTidyOutput(
+      'random output\n2 warnings generated.\n',
+      '',
+      0,
+      [],
+      '',
+    );
+    expect(out).toEqual([]);
+  });
+
+  it('handles empty output', () => {
+    expect(parseClangTidyOutput('', '', 0, [], '')).toEqual([]);
+  });
+
+  it('parses multiple diagnostics', () => {
+    const stdout = 'a.cpp:1:1: warning: w1 [m1]\nb.cpp:2:2: error: e1 [m2]';
+    const out = parseClangTidyOutput(stdout, '', 0, [], '');
+    expect(out).toHaveLength(2);
+    expect(out[0]?.severity).toBe('warning');
+    expect(out[1]?.severity).toBe('error');
+  });
+});

package/src/checks/clang-tidy-passthrough.ts

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview clang-tidy passthrough check.
+ *
+ * Runs `clang-tidy` against the matched files and surfaces its
+ * diagnostics as opensip-tools violations. The user's `.clang-tidy`
+ * config (if present) controls which lints fire — we don't override
+ * it. Use `--checks=...` in the args if you want a fixed lint set.
+ */
+import { defineCheck, type CheckViolation } from '@opensip-tools/fitness'
+
+// eslint-disable-next-line sonarjs/slow-regex -- input is one bounded line of clang-tidy output; no real ReDoS exposure
+const CLANG_TIDY_LINE = /^(.+?):(\d+):(\d+):\s+(warning|error|note):\s+(.+?)(?:\s+\[([\w\-,.]+)\])?$/
+
+/**
+ * Pure parser for clang-tidy stdout. Accepts the diagnostic format:
+ *   path/to/file.cpp:LINE:COL: warning: <message> [check-name]
+ * Returns one CheckViolation per warning/error line. `note:` lines
+ * are attached to the prior diagnostic when possible (kept simple
+ * for MVP — current implementation skips them).
+ */
+export function parseClangTidyOutput(
+  stdout: string,
+  _stderr: string,
+  _exitCode: number,
+  _files: readonly string[],
+  _cwd: string,
+): CheckViolation[] {
+  const violations: CheckViolation[] = []
+  const lines = stdout.split('\n')
+  for (const line of lines) {
+    const match = CLANG_TIDY_LINE.exec(line)
+    if (!match) continue
+    const lineStr = match[2]
+    const severity = match[4]
+    const message = match[5]
+    const lintName = match[6]
+    if (severity === 'note') continue
+    violations.push({
+      message: lintName ? `[${lintName}] ${message}` : message ?? 'clang-tidy diagnostic',
+      severity: severity === 'error' ? 'error' : 'warning',
+      line: lineStr ? Number.parseInt(lineStr, 10) : 1,
+      suggestion: 'See clang-tidy docs for the named lint',
+    })
+  }
+  return violations
+}
+
+export const clangTidyPassthrough = defineCheck({
+  id: 'e1f2a3b4-9876-4321-eeee-500000000001',
+  slug: 'cpp-clang-tidy',
+  description: 'Run clang-tidy and surface its diagnostics as opensip-tools violations',
+  scope: { languages: ['cpp'], concerns: [] },
+  tags: ['quality', 'cpp'],
+  command: {
+    bin: 'clang-tidy',
+    args: (files) => [...files, '--quiet'],
+    parseOutput: parseClangTidyOutput,
+    // clang-tidy returns 1 when warnings are emitted with -warnings-as-errors,
+    // but with --quiet and default config, exit 0 means clean run.
+    // Diagnostics are present on stdout regardless.
+    expectedExitCodes: [0, 1],
+  },
+})

package/src/index.ts

@@ -0,0 +1,10 @@
+import { clangTidyPassthrough } from './checks/clang-tidy-passthrough.js'
+
+export const checks = [clangTidyPassthrough] as const
+export { clangTidyPassthrough, parseClangTidyOutput } from './checks/clang-tidy-passthrough.js'
+
+export const metadata = {
+  name: '@opensip-tools/checks-cpp',
+  version: '0.6.1',
+  description: 'C/C++ fitness checks (clang-tidy backed)',
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+  test: {
+    include: ['src/**/*.test.ts'],
+    coverage: {
+      include: ['src/**'],
+      exclude: ['src/**/*.test.ts', 'src/**/__tests__/**', 'src/index.ts'],
+    },
+  },
+});