@opensip-tools/fitness 1.0.4

package/src/targets/__tests__/loader.test.ts

@@ -0,0 +1,170 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { ValidationError } from '@opensip-tools/core';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { loadTargetsConfig } from '../loader.js';
+
+let testDir: string;
+
+beforeEach(() => {
+   
+  testDir = mkdtempSync(join(tmpdir(), 'opensip-targets-loader-'));
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe('loadTargetsConfig', () => {
+  it('loads a minimal targets config', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: Source
+    include:
+      - "src/**/*.ts"
+`,
+    );
+    const { registry, config } = loadTargetsConfig(testDir);
+    expect(registry.has('src')).toBe(true);
+    expect(config.globalExcludes).toEqual([]);
+  });
+
+  it('applies default exclude patterns when none provided', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: Source
+    include: ["src/**"]
+`,
+    );
+    const { registry } = loadTargetsConfig(testDir);
+    const target = registry.getAll().find((t) => t.config.name === 'src');
+    expect(target?.config.exclude).toContain('**/node_modules/**');
+  });
+
+  it('preserves custom exclude patterns when provided', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: Source
+    include: ["src/**"]
+    exclude:
+      - "src/legacy/**"
+`,
+    );
+    const { registry } = loadTargetsConfig(testDir);
+    const target = registry.getAll().find((t) => t.config.name === 'src');
+    expect(target?.config.exclude).toEqual(['src/legacy/**']);
+  });
+
+  it('parses globalExcludes', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `globalExcludes:
+  - "**/docs/**"
+targets:
+  src:
+    description: x
+    include: ["src/**"]
+`,
+    );
+    const { config } = loadTargetsConfig(testDir);
+    expect(config.globalExcludes).toEqual(['**/docs/**']);
+  });
+
+  it('parses checkOverrides as string and as array', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: x
+    include: ["src/**"]
+  tests:
+    description: y
+    include: ["test/**"]
+checkOverrides:
+  no-console-log: src
+  multi-target: [src, tests]
+`,
+    );
+    const { config } = loadTargetsConfig(testDir);
+    expect(config.checkOverrides['no-console-log']).toBe('src');
+    expect(config.checkOverrides['multi-target']).toEqual(['src', 'tests']);
+  });
+
+  it('throws when checkOverrides references an unknown target', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: x
+    include: ["src/**"]
+checkOverrides:
+  some-check: nonexistent
+`,
+    );
+    expect(() => loadTargetsConfig(testDir)).toThrow(/unknown target/);
+  });
+
+  it('parses plugins block with all keys', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  src:
+    description: x
+    include: ["src/**"]
+plugins:
+  fit: ["@a/b"]
+  sim: ["@c/d"]
+  checkPackages: ["@e/f"]
+  autoDiscoverChecks: false
+`,
+    );
+    const { config } = loadTargetsConfig(testDir);
+    expect(config.plugins?.fit).toEqual(['@a/b']);
+    expect(config.plugins?.sim).toEqual(['@c/d']);
+    expect(config.plugins?.checkPackages).toEqual(['@e/f']);
+    expect(config.plugins?.autoDiscoverChecks).toBe(false);
+  });
+
+  it('throws ValidationError when target name is not kebab-case', () => {
+    writeFileSync(
+      join(testDir, 'opensip-tools.config.yml'),
+      `targets:
+  Bad_Name:
+    description: x
+    include: ["y"]
+`,
+    );
+    expect(() => loadTargetsConfig(testDir)).toThrow(ValidationError);
+  });
+
+  it('throws when the config file is missing', () => {
+    expect(() => loadTargetsConfig(testDir)).toThrow();
+  });
+
+  it('throws ValidationError when YAML is malformed', () => {
+    writeFileSync(join(testDir, 'opensip-tools.config.yml'), 'targets: [unbalanced\n');
+    expect(() => loadTargetsConfig(testDir)).toThrow(ValidationError);
+  });
+
+  it('respects an explicit --config path', () => {
+    writeFileSync(
+      join(testDir, 'custom.yml'),
+      `targets:
+  custom:
+    description: x
+    include: ["x"]
+`,
+    );
+    const { registry } = loadTargetsConfig(testDir, join(testDir, 'custom.yml'));
+    expect(registry.has('custom')).toBe(true);
+  });
+});

package/src/targets/__tests__/resolver.test.ts

@@ -0,0 +1,74 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { resolveTargetFiles } from '../resolver.js';
+
+import type { Target } from '../types.js';
+
+let testDir: string;
+
+const stub = (include: string[], exclude: string[] = []): Target => ({
+  config: { name: 't', description: 't', include, exclude },
+});
+
+beforeEach(() => {
+   
+  testDir = mkdtempSync(join(tmpdir(), 'opensip-resolver-'));
+  mkdirSync(join(testDir, 'src'), { recursive: true });
+  mkdirSync(join(testDir, 'src', 'sub'), { recursive: true });
+  mkdirSync(join(testDir, 'tests'), { recursive: true });
+  writeFileSync(join(testDir, 'src', 'a.ts'), '');
+  writeFileSync(join(testDir, 'src', 'b.ts'), '');
+  writeFileSync(join(testDir, 'src', 'sub', 'c.ts'), '');
+  writeFileSync(join(testDir, 'src', 'a.test.ts'), '');
+  writeFileSync(join(testDir, 'tests', 'd.ts'), '');
+});
+
+afterEach(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe('resolveTargetFiles', () => {
+  it('expands include globs to absolute paths', () => {
+    const files = resolveTargetFiles([stub(['src/**/*.ts'])], testDir);
+    expect(files.length).toBeGreaterThan(0);
+    expect(files.every((f) => f.startsWith(testDir))).toBe(true);
+  });
+
+  it('respects exclude globs', () => {
+    const files = resolveTargetFiles([stub(['src/**/*.ts'], ['**/*.test.ts'])], testDir);
+    expect(files.some((f) => f.endsWith('.test.ts'))).toBe(false);
+    expect(files.some((f) => f.endsWith('a.ts'))).toBe(true);
+  });
+
+  it('deduplicates files matching multiple targets', () => {
+    const files = resolveTargetFiles(
+      [stub(['src/*.ts']), stub(['src/**/*.ts'])],
+      testDir,
+    );
+    const unique = new Set(files);
+    expect(files.length).toBe(unique.size);
+  });
+
+  it('returns sorted output', () => {
+    const files = resolveTargetFiles([stub(['src/**/*.ts'])], testDir);
+    const sorted = [...files].sort();
+    expect(files).toEqual(sorted);
+  });
+
+  it('returns empty when nothing matches', () => {
+    expect(resolveTargetFiles([stub(['nonexistent/**'])], testDir)).toEqual([]);
+  });
+
+  it('combines results across multiple targets', () => {
+    const files = resolveTargetFiles(
+      [stub(['src/a.ts']), stub(['tests/d.ts'])],
+      testDir,
+    );
+    expect(files.some((f) => f.endsWith('a.ts'))).toBe(true);
+    expect(files.some((f) => f.endsWith('d.ts'))).toBe(true);
+  });
+});

package/src/targets/__tests__/target-registry.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+
+import { TargetRegistry } from '../target-registry.js';
+
+import type { Target } from '../types.js';
+
+const stub = (name: string, opts: { tags?: string[]; languages?: string[]; concerns?: string[] } = {}): Target => ({
+  config: {
+    name,
+    description: name,
+    include: [`${name}/**`],
+    exclude: [],
+    ...(opts.tags && { tags: opts.tags }),
+    ...(opts.languages && { languages: opts.languages }),
+    ...(opts.concerns && { concerns: opts.concerns }),
+  },
+});
+
+describe('TargetRegistry', () => {
+  it('register adds new targets and returns this for chaining', () => {
+    const reg = new TargetRegistry();
+    const result = reg.register(stub('a')).register(stub('b'));
+    expect(result).toBe(reg);
+    expect(reg.size).toBe(2);
+  });
+
+  it('register silently skips duplicate names', () => {
+    const reg = new TargetRegistry();
+    reg.register(stub('a'));
+    reg.register(stub('a'));
+    expect(reg.size).toBe(1);
+  });
+
+  it('getByName / has lookups', () => {
+    const reg = new TargetRegistry();
+    const a = stub('a');
+    reg.register(a);
+    expect(reg.getByName('a')).toBe(a);
+    expect(reg.getByName('nope')).toBeUndefined();
+    expect(reg.has('a')).toBe(true);
+    expect(reg.has('nope')).toBe(false);
+  });
+
+  it('getAll returns the live set, but a fresh array each call', () => {
+    const reg = new TargetRegistry();
+    reg.register(stub('a'));
+    const snapshot = reg.getAll();
+    expect(snapshot).toHaveLength(1);
+    (snapshot as Target[]).pop();
+    expect(reg.getAll()).toHaveLength(1); // not affected
+  });
+
+  it('getByTag filters by config.tags', () => {
+    const reg = new TargetRegistry();
+    reg.register(stub('a', { tags: ['fast'] }));
+    reg.register(stub('b', { tags: ['slow'] }));
+    reg.register(stub('c'));
+    expect(reg.getByTag('fast').map((t) => t.config.name)).toEqual(['a']);
+  });
+
+  describe('findByScope', () => {
+    it('returns targets whose languages intersect when both sides specify', () => {
+      const reg = new TargetRegistry();
+      reg.register(stub('ts', { languages: ['typescript'], concerns: ['backend'] }));
+      reg.register(stub('rs', { languages: ['rust'], concerns: ['backend'] }));
+      const matched = reg.findByScope(['typescript'], ['backend']);
+      expect(matched.map((t) => t.config.name)).toEqual(['ts']);
+    });
+
+    it('treats empty check languages as "matches any"', () => {
+      const reg = new TargetRegistry();
+      reg.register(stub('ts', { languages: ['typescript'], concerns: ['backend'] }));
+      reg.register(stub('rs', { languages: ['rust'], concerns: ['backend'] }));
+      expect(reg.findByScope([], ['backend'])).toHaveLength(2);
+    });
+
+    it('treats targets with no languages as "matches any check language"', () => {
+      const reg = new TargetRegistry();
+      reg.register(stub('any-lang', { concerns: ['backend'] })); // no languages
+      expect(reg.findByScope(['typescript'], ['backend'])).toHaveLength(1);
+    });
+
+    it('treats empty check concerns as "matches any"', () => {
+      const reg = new TargetRegistry();
+      reg.register(stub('ts', { languages: ['typescript'], concerns: ['backend'] }));
+      expect(reg.findByScope(['typescript'], [])).toHaveLength(1);
+    });
+
+    it('requires both dimensions to match', () => {
+      const reg = new TargetRegistry();
+      reg.register(stub('ts-frontend', { languages: ['typescript'], concerns: ['frontend'] }));
+      expect(reg.findByScope(['typescript'], ['backend'])).toEqual([]);
+    });
+  });
+
+  it('clear removes everything', () => {
+    const reg = new TargetRegistry();
+    reg.register(stub('a'));
+    reg.clear();
+    expect(reg.size).toBe(0);
+    expect(reg.getAll()).toEqual([]);
+  });
+});

package/src/targets/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Target system barrel export
+ *
+ * Public API for config-driven targets:
+ * - loadTargetsConfig() — Load from opensip-tools.config.yml
+ * - resolveTargetFiles() — Expand globs, deduplicate
+ */
+
+// Loader
+export { loadTargetsConfig } from './loader.js'
+
+// Resolver
+export { resolveTargetFiles } from './resolver.js'

package/src/targets/loader.ts

@@ -0,0 +1,214 @@
+// @fitness-ignore-file batch-operation-limits -- iterates bounded collections (config entries, registry items, or small analysis results)
+/**
+ * @fileoverview Target config loader
+ *
+ * Loads target configuration from opensip-tools.config.yml in the project root.
+ * Validates with Zod and populates a TargetRegistry.
+ */
+
+import { readFileSync, statSync } from 'node:fs'
+
+import { PROJECT_CONFIG_FILENAME, resolveProjectConfigPath , ValidationError, SystemError } from '@opensip-tools/core'
+import yaml from 'js-yaml'
+import { z } from 'zod'
+
+
+import { TargetRegistry } from './target-registry.js'
+
+import type { TargetConfig, TargetsConfig } from './types.js'
+
+const YAML_FILENAME = PROJECT_CONFIG_FILENAME
+const DEFAULT_EXCLUDES: readonly string[] = ['**/node_modules/**', '**/dist/**']
+
+// =============================================================================
+// YAML schemas
+// =============================================================================
+
+const TargetEntrySchema = z.object({
+  description: z.string().min(1, 'description is required'),
+  include: z.array(z.string()).min(1, 'at least one include pattern is required'),
+  exclude: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  languages: z.array(z.string()).optional(),
+  concerns: z.array(z.string()).optional(),
+})
+
+const CheckTargetValueSchema = z.union([
+  z.string(),
+  z.array(z.string()).min(1),
+])
+
+const PluginsSchema = z.object({
+  fit: z.array(z.string()).optional(),
+  sim: z.array(z.string()).optional(),
+  asm: z.array(z.string()).optional(),
+  lang: z.array(z.string()).optional(),
+  checkPackages: z.array(z.string()).optional(),
+  autoDiscoverChecks: z.boolean().optional(),
+}).optional()
+
+const TargetsFileSchema = z.object({
+  targets: z.record(
+    z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, 'target name must be kebab-case'),
+    TargetEntrySchema,
+  ),
+  globalExcludes: z.array(z.string()).optional(),
+  checkOverrides: z.record(z.string(), CheckTargetValueSchema).optional(),
+  plugins: PluginsSchema,
+})
+
+// =============================================================================
+// Build registry + config from parsed data
+// =============================================================================
+
+/** @throws {ValidationError} When checkOverrides references an unknown target */
+// eslint-disable-next-line sonarjs/cognitive-complexity -- inherent complexity: registry population + cross-validation
+function buildFromParsed(
+  targets: Record<string, { description: string; include: readonly string[]; exclude?: readonly string[]; tags?: readonly string[]; languages?: readonly string[]; concerns?: readonly string[] }>,
+  rawGlobalExcludes: readonly string[] | undefined,
+  rawCheckOverrides: Record<string, string | readonly string[]> | undefined,
+  sourceLabel: string,
+  rawPlugins?: {
+    fit?: readonly string[]
+    sim?: readonly string[]
+    asm?: readonly string[]
+    lang?: readonly string[]
+    checkPackages?: readonly string[]
+    autoDiscoverChecks?: boolean
+  },
+): { registry: TargetRegistry; config: TargetsConfig } {
+  const registry = new TargetRegistry()
+
+  for (const [name, entry] of Object.entries(targets)) {
+    const config: TargetConfig = Object.freeze({
+      name,
+      description: entry.description,
+      include: Object.freeze([...entry.include]),
+      exclude: Object.freeze([...(entry.exclude ?? DEFAULT_EXCLUDES)]),
+      ...(entry.tags && { tags: Object.freeze([...entry.tags]) }),
+      ...(entry.languages && { languages: Object.freeze([...entry.languages]) }),
+      ...(entry.concerns && { concerns: Object.freeze([...entry.concerns]) }),
+    })
+    registry.register(Object.freeze({ config }))
+  }
+
+  const checkOverrides: Record<string, string | readonly string[]> = {}
+  if (rawCheckOverrides) {
+    for (const [checkSlug, targetRef] of Object.entries(rawCheckOverrides)) {
+      const targetNames = typeof targetRef === 'string' ? [targetRef] : targetRef
+      for (const name of targetNames) {
+        if (!registry.has(name)) {
+          // @fitness-ignore-next-line result-pattern-consistency -- infrastructure boundary, throw is appropriate
+          throw new ValidationError(
+            `${sourceLabel}: checkOverrides['${checkSlug}'] references unknown target '${name}'. ` +
+            `Available targets: ${registry.getAll().map((t) => t.config.name).join(', ')}`,
+            { code: 'ERRORS.TARGETS.UNKNOWN_TARGET' },
+          )
+        }
+      }
+      checkOverrides[checkSlug] = typeof targetRef === 'string' ? targetRef : Object.freeze([...targetRef])
+    }
+  }
+
+  const plugins = rawPlugins
+    ? Object.freeze({
+        ...(rawPlugins.fit && { fit: Object.freeze([...rawPlugins.fit]) }),
+        ...(rawPlugins.sim && { sim: Object.freeze([...rawPlugins.sim]) }),
+        ...(rawPlugins.asm && { asm: Object.freeze([...rawPlugins.asm]) }),
+        ...(rawPlugins.lang && { lang: Object.freeze([...rawPlugins.lang]) }),
+        ...(rawPlugins.checkPackages && { checkPackages: Object.freeze([...rawPlugins.checkPackages]) }),
+        ...(rawPlugins.autoDiscoverChecks !== undefined && { autoDiscoverChecks: rawPlugins.autoDiscoverChecks }),
+      })
+    : undefined
+
+  const config: TargetsConfig = Object.freeze({
+    globalExcludes: Object.freeze(rawGlobalExcludes ? [...rawGlobalExcludes] : []),
+    checkOverrides: Object.freeze(checkOverrides),
+    ...(plugins && { plugins }),
+  })
+
+  return { registry, config }
+}
+
+// =============================================================================
+// YAML config loader
+// =============================================================================
+
+const MAX_FILE_SIZE = 10 * 1024 * 1024 // 10 MB
+
+/** @throws {ValidationError} When the file is too large, missing, or unreadable */
+function readYamlFile(filePath: string): string {
+  try {
+    const stats = statSync(filePath)
+    if (stats.size > MAX_FILE_SIZE) {
+      throw new SystemError(`File too large (${stats.size} bytes, max ${MAX_FILE_SIZE}): ${filePath}`, { code: 'SYSTEM.FILE.TOO_LARGE' })
+    }
+    return readFileSync(filePath, 'utf8')
+  } catch (error) {
+    if (error instanceof ValidationError || error instanceof SystemError) throw error
+    throw new ValidationError(
+      `${YAML_FILENAME} not found at ${filePath}. Create one to define your targets.`,
+      { operation: 'load', loader: 'targets' },
+    )
+  }
+}
+
+/** @throws {ValidationError} When the YAML is malformed */
+function parseYamlContent(raw: string): unknown {
+  try {
+    return yaml.load(raw)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new ValidationError(`${YAML_FILENAME} contains invalid YAML: ${message}`, {
+      operation: 'load',
+      loader: 'targets',
+      cause: error instanceof Error ? error : undefined,
+    })
+  }
+}
+
+/**
+ * @throws {ValidationError} When the file is missing or contains invalid YAML
+ * @throws {ValidationError} When the file fails schema validation
+ */
+function loadYamlConfig(filePath: string): { registry: TargetRegistry; config: TargetsConfig } {
+  const raw = readYamlFile(filePath)
+  const parsed = parseYamlContent(raw)
+
+  const result = TargetsFileSchema.safeParse(parsed)
+  if (!result.success) {
+    const issues = result.error.issues
+      .map((i) => `  ${i.path.join('.')}: ${i.message}`)
+      .join('\n')
+    // @fitness-ignore-next-line result-pattern-consistency -- infrastructure boundary, throw is appropriate
+    throw new ValidationError(`${YAML_FILENAME} validation failed:\n${issues}`, {
+      code: 'ERRORS.TARGETS.VALIDATION_FAILED',
+    })
+  }
+
+  return buildFromParsed(
+    result.data.targets,
+    result.data.globalExcludes,
+    result.data.checkOverrides,
+    YAML_FILENAME,
+    result.data.plugins,
+  )
+}
+
+// =============================================================================
+// Public API
+// =============================================================================
+
+/**
+ * Load full targets config including per-check target overrides.
+ * Resolves via the shared project-config resolver.
+ * @throws {ValidationError} When no targets config file is found or it cannot be loaded
+ * @throws {ValidationError} When the config file fails schema validation
+ */
+export function loadTargetsConfig(
+  rootDir: string,
+  explicitPath?: string,
+): { registry: TargetRegistry; config: TargetsConfig } {
+  const yamlPath = resolveProjectConfigPath(rootDir, explicitPath)
+  return loadYamlConfig(yamlPath)
+}

package/src/targets/resolver.ts

@@ -0,0 +1,44 @@
+// @fitness-ignore-file batch-operation-limits -- iterates bounded collections (config entries, registry items, or small analysis results)
+/**
+ * @fileoverview Target file resolver
+ *
+ * Expands target glob patterns to concrete file paths,
+ * deduplicating across multiple targets.
+ */
+
+import { resolve } from 'node:path'
+
+import { globSync } from 'glob'
+
+import type { Target } from './types.js'
+
+/**
+ * Resolve multiple targets to a deduplicated list of file paths.
+ *
+ * Expands include globs, filters out exclude globs, and deduplicates
+ * across all targets so no file is processed twice.
+ *
+ * @param targets - Targets to resolve
+ * @param rootDir - Project root for glob resolution
+ * @returns Sorted, deduplicated array of absolute file paths
+ */
+export function resolveTargetFiles(targets: readonly Target[], rootDir: string): string[] {
+  const files = new Set<string>()
+
+  for (const target of targets) {
+    const { include, exclude } = target.config
+
+    for (const pattern of include) {
+      const matches = globSync(pattern, {
+        cwd: rootDir,
+        ignore: [...exclude],
+        absolute: true,
+      })
+      for (const match of matches) {
+        files.add(resolve(match))
+      }
+    }
+  }
+
+  return [...files].sort()
+}