@taodigital/app-brain 0.0.0-stage → 1.2.0

package/src/traceability.ts

@@ -0,0 +1,477 @@
+/**
+ * Traceability matrix + alignment report.
+ *
+ * Chain:  Jira story / requirement  →  acceptance criteria  →  test cases (primary + additional links)
+ *         →  scripts (annotation present?)  →  alignment (AI score + deterministic step coverage).
+ *
+ * Builders are pure (testable); loaders fetch tenant-scoped rows and call them.
+ */
+import { withTenant } from '@taodigital/database';
+
+// ─── Link helpers ────────────────────────────────────────────────────────────
+
+const UNLINKED = new Set(['', 'REQ-UNKNOWN', 'UNKNOWN', 'N/A']);
+
+export function isRealReqId(v: unknown): v is string {
+  return typeof v === 'string' && !UNLINKED.has(v.trim().toUpperCase());
+}
+
+/** Primary traceTo followed by additional links, de-duplicated, placeholders removed. */
+export function linkedReqIds(tc: { traceTo?: string | null; traceToExtra?: unknown }): string[] {
+  const extra = Array.isArray(tc.traceToExtra) ? (tc.traceToExtra as unknown[]) : [];
+  const all = [tc.traceTo, ...extra].filter(isRealReqId).map((s) => s.trim());
+  return [...new Set(all)];
+}
+
+export function caseTracesTo(tc: { traceTo?: string | null; traceToExtra?: unknown }, reqId: string): boolean {
+  return linkedReqIds(tc).includes(reqId);
+}
+
+// ─── Acceptance-criterion matching ───────────────────────────────────────────
+
+const AC_STOP = new Set([
+  'the', 'a', 'an', 'to', 'of', 'on', 'in', 'into', 'and', 'or', 'with', 'for', 'from', 'then', 'that', 'is', 'are', 'be',
+  'should', 'will', 'shall', 'can', 'it', 'its', 'this', 'these', 'those', 'at', 'by', 'as', 'user', 'given', 'when', 'but',
+  'so', 'now', 'has', 'have', 'had', 'does', 'not', 'all', 'any', 'able', 'must', 'page', 'screen', 'system', 'application',
+]);
+
+function acTokenize(text: string): Set<string> {
+  const out = new Set<string>();
+  for (const raw of text.toLowerCase().replace(/([a-z0-9])([A-Z])/g, '$1 $2').split(/[^a-z0-9]+/)) {
+    let w = raw;
+    if (w.length < 3 || AC_STOP.has(w)) continue;
+    if (w.length > 5 && w.endsWith('ing')) w = w.slice(0, -3);
+    else if (w.length > 4 && w.endsWith('ed')) w = w.slice(0, -2);
+    else if (w.length > 3 && w.endsWith('s') && !w.endsWith('ss')) w = w.slice(0, -1);
+    if (!AC_STOP.has(w)) out.add(w);
+  }
+  return out;
+}
+
+function stepText(s: unknown): string {
+  if (typeof s === 'string') return s;
+  if (s && typeof s === 'object') {
+    const o = s as Record<string, unknown>;
+    return [o.action, o.data, o.expected, o.text].filter((v) => v != null && typeof v !== 'object').join(' ');
+  }
+  return '';
+}
+
+function caseCorpus(tc: { title?: string; steps?: unknown; expectedResult?: string | null; preconditions?: string | null }): string {
+  const steps = Array.isArray(tc.steps) ? tc.steps.map(stepText) : [];
+  return [tc.title, tc.preconditions, tc.expectedResult, ...steps].filter(Boolean).join(' ');
+}
+
+/**
+ * Deterministic AC → test-case match: a case addresses an AC when it shares ≥ 40% of the AC's
+ * content tokens (and ≥ 2 tokens, or ≥ 1 when the AC itself has ≤ 2 tokens).
+ */
+export function matchAcceptanceCriterion(
+  ac: string,
+  cases: Array<{ id: string; ref?: string | null; title?: string; steps?: unknown; expectedResult?: string | null; preconditions?: string | null }>,
+): { covered: boolean; confidence: number; caseRefs: string[] } {
+  const tokens = acTokenize(ac);
+  if (tokens.size === 0) return { covered: false, confidence: 0, caseRefs: [] };
+  const needed = tokens.size <= 2 ? 1 : 2;
+  const hits: Array<{ ref: string; ratio: number }> = [];
+  for (const tc of cases) {
+    const corpus = acTokenize(caseCorpus(tc));
+    let n = 0;
+    for (const t of tokens) if (corpus.has(t)) n++;
+    const ratio = n / tokens.size;
+    if (n >= needed && ratio >= 0.4) hits.push({ ref: tc.ref ?? tc.id, ratio });
+  }
+  hits.sort((a, b) => b.ratio - a.ratio);
+  return {
+    covered: hits.length > 0,
+    confidence: hits.length ? Math.round(hits[0].ratio * 100) / 100 : 0,
+    caseRefs: hits.map((h) => h.ref),
+  };
+}
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface TraceScriptInfo {
+  language: string;
+  /** null when the script body is not available (e.g. stored in object storage). */
+  annotated: boolean | null;
+  aiScore: number | null;
+  aligned: boolean | null;
+  stepCoveragePct: number | null;
+  verifiedAt: string | null;
+}
+
+export interface TraceCaseInput {
+  id: string;
+  ref: string | null;
+  title: string;
+  kind: string;
+  status: string;
+  suiteId: string;
+  steps: unknown;
+  expectedResult: string | null;
+  preconditions: string | null;
+  traceTo: string | null;
+  traceToExtra: unknown;
+  scenarioId: string | null;
+  suspect: boolean;
+  suspectReason: string | null;
+  scripts: TraceScriptInfo[];
+}
+
+export interface TraceRequirementInput {
+  id: string;
+  reqId: string;
+  title: string;
+  priority: string;
+  status: string;
+  source: string;
+  acceptanceCriteria: unknown;
+  externalMeta: any;
+  updatedAt?: Date | string | null;
+}
+
+export interface TraceScenarioInput { id: string; requirementId: string; title: string; status: string }
+
+export interface TraceabilityMatrix {
+  generatedAt: string;
+  summary: {
+    requirements: number;
+    requirementsCovered: number;
+    requirementsPartial: number;
+    requirementsUntested: number;
+    requirementsWithScripts: number;
+    acTotal: number;
+    acCovered: number;
+    acCoveragePct: number | null;
+    testCases: number;
+    testCasesLinked: number;
+    orphanTestCases: number;
+    brokenLinks: number;
+    suspectTestCases: number;
+    scripts: number;
+    scriptsMissingAnnotation: number;
+    scriptsAligned: number;
+  };
+  requirements: Array<{
+    reqId: string;
+    title: string;
+    priority: string;
+    status: string;
+    source: string;
+    jira: { url?: string; status?: string; epic?: string; labels: string[]; links: string[] } | null;
+    coverageState: 'covered' | 'partial' | 'untested';
+    acCoveragePct: number | null;
+    hasSuspect: boolean;
+    acceptanceCriteria: Array<{ index: number; text: string; covered: boolean; confidence: number; testCases: string[] }>;
+    scenarios: Array<{ id: string; title: string; status: string }>;
+    testCases: Array<{
+      id: string; ref: string | null; title: string; kind: string; status: string;
+      linkType: 'primary' | 'additional'; scenarioId: string | null;
+      suspect: boolean; suspectReason: string | null; scripts: TraceScriptInfo[];
+    }>;
+  }>;
+  orphans: Array<{ id: string; ref: string | null; title: string; traceTo: string | null; reason: 'no-link' | 'placeholder' }>;
+  brokenLinks: Array<{ id: string; ref: string | null; title: string; reqId: string }>;
+}
+
+const ALIGN_THRESHOLD = 75;
+export const EXPORT_GATE_MIN = 60;
+
+function acList(raw: unknown): string[] {
+  return Array.isArray(raw) ? raw.map((v) => String(v)).filter((s) => s.trim()) : [];
+}
+
+function jiraInfo(meta: any, source: string) {
+  if (!meta || typeof meta !== 'object') return source === 'JIRA_IMPORT' ? { labels: [], links: [] } : null;
+  return {
+    url: meta.url ?? undefined,
+    status: meta.status ?? undefined,
+    epic: meta.epic?.key ? `${meta.epic.key}${meta.epic.summary ? ` — ${meta.epic.summary}` : ''}` : (typeof meta.epic === 'string' ? meta.epic : undefined),
+    labels: Array.isArray(meta.labels) ? meta.labels.map(String) : [],
+    links: Array.isArray(meta.links) ? meta.links.map((l: any) => `${l.type ?? 'relates'}: ${l.key ?? l}`) : [],
+  };
+}
+
+// ─── Matrix builder ──────────────────────────────────────────────────────────
+
+export function buildTraceabilityMatrix(input: {
+  requirements: TraceRequirementInput[];
+  testCases: TraceCaseInput[];
+  scenarios: TraceScenarioInput[];
+}): TraceabilityMatrix {
+  const active = input.testCases.filter((t) => t.status !== 'RETIRED');
+  const reqIds = new Set(input.requirements.map((r) => r.reqId));
+  const reqDbIdToReqId = new Map(input.requirements.map((r) => [r.id, r.reqId]));
+
+  const rows: TraceabilityMatrix['requirements'] = input.requirements.map((r) => {
+    const linked = active.filter((t) => caseTracesTo(t, r.reqId));
+    const acs = acList(r.acceptanceCriteria).map((text, i) => {
+      const m = matchAcceptanceCriterion(text, linked);
+      return { index: i + 1, text, covered: m.covered, confidence: m.confidence, testCases: m.caseRefs };
+    });
+    const acCovered = acs.filter((a) => a.covered).length;
+    const acCoveragePct = acs.length ? Math.round((acCovered / acs.length) * 1000) / 10 : null;
+    const coverageState: 'covered' | 'partial' | 'untested' =
+      linked.length === 0 ? 'untested' : acs.length === 0 || acCovered === acs.length ? 'covered' : 'partial';
+    return {
+      reqId: r.reqId,
+      title: r.title,
+      priority: r.priority,
+      status: r.status,
+      source: r.source,
+      jira: jiraInfo(r.externalMeta, r.source),
+      coverageState,
+      acCoveragePct,
+      hasSuspect: linked.some((t) => t.suspect),
+      acceptanceCriteria: acs,
+      scenarios: input.scenarios
+        .filter((s) => reqDbIdToReqId.get(s.requirementId) === r.reqId)
+        .map((s) => ({ id: s.id, title: s.title, status: s.status })),
+      testCases: linked.map((t) => ({
+        id: t.id, ref: t.ref, title: t.title, kind: t.kind, status: t.status,
+        linkType: (t.traceTo === r.reqId ? 'primary' : 'additional') as 'primary' | 'additional',
+        scenarioId: t.scenarioId, suspect: t.suspect, suspectReason: t.suspectReason, scripts: t.scripts,
+      })),
+    };
+  });
+
+  const orphans: TraceabilityMatrix['orphans'] = [];
+  const brokenLinks: TraceabilityMatrix['brokenLinks'] = [];
+  for (const t of active) {
+    const ids = linkedReqIds(t);
+    if (ids.length === 0) {
+      orphans.push({ id: t.id, ref: t.ref, title: t.title, traceTo: t.traceTo, reason: t.traceTo ? 'placeholder' : 'no-link' });
+      continue;
+    }
+    for (const id of ids) if (!reqIds.has(id)) brokenLinks.push({ id: t.id, ref: t.ref, title: t.title, reqId: id });
+  }
+
+  const allAc = rows.flatMap((r) => r.acceptanceCriteria);
+  const acCovered = allAc.filter((a) => a.covered).length;
+  const scriptsAll = active.flatMap((t) => t.scripts);
+  const linkedCases = active.filter((t) => linkedReqIds(t).some((id) => reqIds.has(id)));
+
+  return {
+    generatedAt: new Date().toISOString(),
+    summary: {
+      requirements: rows.length,
+      requirementsCovered: rows.filter((r) => r.coverageState === 'covered').length,
+      requirementsPartial: rows.filter((r) => r.coverageState === 'partial').length,
+      requirementsUntested: rows.filter((r) => r.coverageState === 'untested').length,
+      requirementsWithScripts: rows.filter((r) => r.testCases.some((t) => t.scripts.length > 0)).length,
+      acTotal: allAc.length,
+      acCovered,
+      acCoveragePct: allAc.length ? Math.round((acCovered / allAc.length) * 1000) / 10 : null,
+      testCases: active.length,
+      testCasesLinked: linkedCases.length,
+      orphanTestCases: orphans.length,
+      brokenLinks: brokenLinks.length,
+      suspectTestCases: active.filter((t) => t.suspect).length,
+      scripts: scriptsAll.length,
+      scriptsMissingAnnotation: scriptsAll.filter((s) => s.annotated === false).length,
+      scriptsAligned: scriptsAll.filter((s) => (s.aiScore ?? -1) >= ALIGN_THRESHOLD).length,
+    },
+    requirements: rows,
+    orphans,
+    brokenLinks,
+  };
+}
+
+// ─── Alignment report ────────────────────────────────────────────────────────
+
+export interface AlignmentRowInput {
+  testCaseId: string;
+  ref: string | null;
+  title: string;
+  traceTo: string | null;
+  language: string;
+  score: number;
+  aligned: boolean;
+  issues: unknown;
+  stepCoveragePct: number | null;
+  stepCoverage: any;
+  verifiedAt: Date | string | null;
+}
+
+export interface AlignmentReport {
+  generatedAt: string;
+  methodology: { aiScore: string; stepCoverage: string; alignedThreshold: number; exportGate: number };
+  summary: {
+    scripts: number;
+    avgAiScore: number | null;
+    avgStepCoveragePct: number | null;
+    alignedCount: number;
+    passRatePct: number | null;
+    belowExportGate: number;
+    distribution: Record<'0-39' | '40-59' | '60-74' | '75-89' | '90-100', number>;
+  };
+  rows: Array<{
+    testCaseId: string; ref: string | null; title: string; traceTo: string | null; language: string;
+    aiScore: number; aligned: boolean; stepCoveragePct: number | null;
+    totalSteps: number | null; coveredSteps: number | null;
+    assertionCoveragePct: number | null;
+    uncoveredSteps: Array<{ index: number; step: string }>;
+    perStep: Array<{ index: number; step: string; covered: boolean; confidence: number; matchedLine?: number; matchedStatement?: string }>;
+    issues: string[]; verifiedAt: string | null;
+  }>;
+}
+
+function avg(nums: number[]): number | null {
+  return nums.length ? Math.round((nums.reduce((a, b) => a + b, 0) / nums.length) * 10) / 10 : null;
+}
+
+export function buildAlignmentReport(rows: AlignmentRowInput[]): AlignmentReport {
+  const outRows: AlignmentReport['rows'] = rows.map((r) => {
+    const sc = r.stepCoverage && typeof r.stepCoverage === 'object' ? r.stepCoverage : null;
+    const perStep = Array.isArray(sc?.perStep) ? sc.perStep : [];
+    return {
+      testCaseId: r.testCaseId, ref: r.ref, title: r.title, traceTo: r.traceTo, language: r.language,
+      aiScore: r.score, aligned: r.score >= ALIGN_THRESHOLD, stepCoveragePct: r.stepCoveragePct,
+      totalSteps: sc?.totalSteps ?? null, coveredSteps: sc?.coveredSteps ?? null,
+      assertionCoveragePct: sc?.assertionCoverage?.pct ?? null,
+      uncoveredSteps: perStep.filter((p: any) => !p.covered).map((p: any) => ({ index: p.index, step: p.step })),
+      perStep,
+      issues: Array.isArray(r.issues) ? (r.issues as unknown[]).map(String) : [],
+      verifiedAt: r.verifiedAt ? new Date(r.verifiedAt).toISOString() : null,
+    };
+  }).sort((a, b) => a.aiScore - b.aiScore);
+
+  const dist = { '0-39': 0, '40-59': 0, '60-74': 0, '75-89': 0, '90-100': 0 } as AlignmentReport['summary']['distribution'];
+  for (const r of outRows) {
+    const s = r.aiScore;
+    dist[s < 40 ? '0-39' : s < 60 ? '40-59' : s < 75 ? '60-74' : s < 90 ? '75-89' : '90-100']++;
+  }
+  const aligned = outRows.filter((r) => r.aligned).length;
+  return {
+    generatedAt: new Date().toISOString(),
+    methodology: {
+      aiScore: 'LLM auditor rubric per script: step coverage 40, assertion correctness 30, locator quality 20, no violations 10, minus penalties for anti-patterns. 0–100.',
+      stepCoverage: 'Deterministic: test-case steps with a matching script statement ÷ total steps (token-overlap-v1). Same input always gives the same result.',
+      alignedThreshold: ALIGN_THRESHOLD,
+      exportGate: EXPORT_GATE_MIN,
+    },
+    summary: {
+      scripts: outRows.length,
+      avgAiScore: avg(outRows.map((r) => r.aiScore)),
+      avgStepCoveragePct: avg(outRows.map((r) => r.stepCoveragePct).filter((v): v is number => typeof v === 'number')),
+      alignedCount: aligned,
+      passRatePct: outRows.length ? Math.round((aligned / outRows.length) * 1000) / 10 : null,
+      belowExportGate: outRows.filter((r) => r.aiScore < EXPORT_GATE_MIN).length,
+      distribution: dist,
+    },
+    rows: outRows,
+  };
+}
+
+// ─── CSV ─────────────────────────────────────────────────────────────────────
+
+function csvCell(v: unknown): string {
+  const s = v == null ? '' : String(v);
+  return /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+export function traceabilityToCsv(m: TraceabilityMatrix): string {
+  const header = ['Requirement', 'Requirement Title', 'Priority', 'Source', 'Jira Status', 'Coverage', 'AC #', 'Acceptance Criterion', 'AC Covered', 'AC Test Cases',
+    'Test Case', 'Test Case Title', 'Link', 'TC Status', 'Suspect', 'Script Language', 'Script Annotated', 'AI Score', 'Step Coverage %'];
+  const lines: string[] = [header.join(',')];
+  for (const r of m.requirements) {
+    const base = [r.reqId, r.title, r.priority, r.source, r.jira?.status ?? '', r.coverageState];
+    const acs = r.acceptanceCriteria.length ? r.acceptanceCriteria : [null];
+    const tcs = r.testCases.length ? r.testCases : [null];
+    const n = Math.max(acs.length, tcs.length);
+    for (let i = 0; i < n; i++) {
+      const ac = acs[i] ?? null;
+      const tc = tcs[i] ?? null;
+      const sc = tc?.scripts[0];
+      lines.push([
+        ...base,
+        ac?.index ?? '', ac?.text ?? '', ac ? (ac.covered ? 'yes' : 'NO') : '', ac?.testCases.join('; ') ?? '',
+        tc?.ref ?? tc?.id ?? '', tc?.title ?? '', tc?.linkType ?? '', tc?.status ?? '', tc ? (tc.suspect ? 'YES' : 'no') : '',
+        sc?.language ?? '', sc ? (sc.annotated === null ? 'n/a' : sc.annotated ? 'yes' : 'NO') : '', sc?.aiScore ?? '', sc?.stepCoveragePct ?? '',
+      ].map(csvCell).join(','));
+    }
+  }
+  for (const o of m.orphans) lines.push(['(orphan)', '', '', '', '', 'unlinked', '', '', '', '', o.ref ?? o.id, o.title, o.reason, '', '', '', '', '', ''].map(csvCell).join(','));
+  return lines.join('\n');
+}
+
+export function alignmentReportToCsv(rep: AlignmentReport): string {
+  const header = ['Test Case', 'Title', 'Requirement', 'Language', 'AI Score', 'Aligned (>=75)', 'Step Coverage %', 'Steps Covered', 'Total Steps', 'Assertion Coverage %', 'Uncovered Steps', 'Issues', 'Verified At'];
+  const lines = [header.join(',')];
+  for (const r of rep.rows) {
+    lines.push([
+      r.ref ?? r.testCaseId, r.title, r.traceTo ?? '', r.language, r.aiScore, r.aligned ? 'yes' : 'no', r.stepCoveragePct ?? '',
+      r.coveredSteps ?? '', r.totalSteps ?? '', r.assertionCoveragePct ?? '',
+      r.uncoveredSteps.map((u) => `#${u.index} ${u.step}`).join(' | '), r.issues.join(' | '), r.verifiedAt ?? '',
+    ].map(csvCell).join(','));
+  }
+  return lines.join('\n');
+}
+
+// ─── Loaders ─────────────────────────────────────────────────────────────────
+
+export async function loadTraceabilityMatrix(tenantId: string, projectId: string): Promise<TraceabilityMatrix> {
+  const data = await withTenant(tenantId, async (tx: any) => {
+    const [requirements, testCases, scenarios, scripts, alignments] = await Promise.all([
+      tx.requirement.findMany({ where: { tenantId, projectId }, orderBy: { reqId: 'asc' } }),
+      tx.testCase.findMany({
+        where: { tenantId, projectId },
+        select: { id: true, ref: true, title: true, kind: true, status: true, suiteId: true, steps: true, expectedResult: true, preconditions: true, traceTo: true, traceToExtra: true, scenarioId: true, suspect: true, suspectReason: true },
+      }),
+      tx.scenario.findMany({ where: { tenantId, projectId }, select: { id: true, requirementId: true, title: true, status: true } }),
+      tx.testScript.findMany({ where: { tenantId, projectId }, select: { testCaseId: true, language: true, code: true, codeKey: true } }),
+      tx.alignmentResult.findMany({ where: { tenantId, projectId }, select: { testCaseId: true, language: true, score: true, aligned: true, stepCoveragePct: true, verifiedAt: true } }),
+    ]);
+    return { requirements, testCases, scenarios, scripts, alignments };
+  });
+
+  const alignKey = (id: string, lang: string) => `${id}::${lang}`;
+  const alignMap = new Map<string, any>(data.alignments.map((a: any) => [alignKey(a.testCaseId, a.language), a]));
+  const scriptsByCase = new Map<string, any[]>();
+  for (const s of data.scripts) {
+    if (!scriptsByCase.has(s.testCaseId)) scriptsByCase.set(s.testCaseId, []);
+    scriptsByCase.get(s.testCaseId)!.push(s);
+  }
+
+  const testCases: TraceCaseInput[] = data.testCases.map((t: any) => {
+    const ids = linkedReqIds(t);
+    const scripts: TraceScriptInfo[] = (scriptsByCase.get(t.id) ?? []).map((s: any) => {
+      const a = alignMap.get(alignKey(t.id, s.language));
+      const hasBody = typeof s.code === 'string' && s.code.length > 0;
+      return {
+        language: s.language,
+        annotated: hasBody ? ids.some((id) => s.code.toLowerCase().includes(id.toLowerCase())) : (s.codeKey ? null : false),
+        aiScore: a?.score ?? null,
+        aligned: a ? a.score >= ALIGN_THRESHOLD : null,
+        stepCoveragePct: a?.stepCoveragePct ?? null,
+        verifiedAt: a?.verifiedAt ? new Date(a.verifiedAt).toISOString() : null,
+      };
+    });
+    return { ...t, traceToExtra: t.traceToExtra ?? [], scripts };
+  });
+
+  return buildTraceabilityMatrix({ requirements: data.requirements, testCases, scenarios: data.scenarios });
+}
+
+export async function loadAlignmentReport(tenantId: string, projectId: string): Promise<AlignmentReport> {
+  const rows = await withTenant(tenantId, async (tx: any) => {
+    const alignments = await tx.alignmentResult.findMany({ where: { tenantId, projectId } });
+    const ids = [...new Set<string>(alignments.map((a: any) => a.testCaseId))];
+    const cases = ids.length
+      ? await tx.testCase.findMany({ where: { tenantId, id: { in: ids } }, select: { id: true, ref: true, title: true, traceTo: true } })
+      : [];
+    const byId = new Map<string, any>(cases.map((c: any) => [c.id, c]));
+    return alignments
+      .filter((a: any) => byId.has(a.testCaseId))
+      .map((a: any): AlignmentRowInput => {
+        const c = byId.get(a.testCaseId);
+        return {
+          testCaseId: a.testCaseId, ref: c.ref, title: c.title, traceTo: c.traceTo, language: a.language,
+          score: a.score, aligned: a.aligned, issues: a.issues, stepCoveragePct: a.stepCoveragePct ?? null,
+          stepCoverage: a.stepCoverage ?? null, verifiedAt: a.verifiedAt,
+        };
+      });
+  });
+  return buildAlignmentReport(rows);
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts"]
+}