aiwg
Version:
Deployment tool and support utility for AI context. Copies agents, skills, commands, rules, and behaviors into the paths each AI platform reads (Claude Code, Codex, Copilot, Cursor, Warp, OpenClaw, and 6 more) so one source of truth works across 10 platfo
205 lines • 6.23 kB
TypeScript
/**
* Traceability Checker - Maintain 100% bidirectional traceability
* from requirements → code → tests → deployment
*
* Features:
* - Bidirectional tracing (requirements ↔ code ↔ tests)
* - Orphan detection (requirements without code, code without requirements)
* - Coverage analysis (percentage of requirements traced)
* - Gap identification (missing code, tests, documentation)
* - Matrix generation (CSV, Excel, Markdown, HTML)
* - Construction gate validation (100% P0 requirements traced)
*
* Performance targets:
* - NFR-TRACE-001: ID extraction <1min for 1000 files
* - NFR-TRACE-05: Matrix generation <30s for 1000 requirements
*/
import { TraceabilityMatrix } from './matrix-generator.js';
export interface Requirement {
id: string;
type: 'use-case' | 'nfr' | 'user-story' | 'feature' | 'acceptance-criteria';
title: string;
priority?: 'P0' | 'P1' | 'P2';
filePath: string;
}
export interface CodeReference {
filePath: string;
requirementIds: string[];
lineNumbers: number[];
}
export interface TestReference {
filePath: string;
requirementIds: string[];
testNames: string[];
}
export interface ScanResult {
requirements: Map<string, Requirement>;
code: Map<string, CodeReference>;
tests: Map<string, TestReference>;
scanTime: number;
}
export interface TraceabilityLink {
requirementId: string;
type: 'use-case' | 'nfr' | 'user-story' | 'feature' | 'acceptance-criteria';
linkedItems: LinkedItem[];
coverage: CoverageMetrics;
lastVerified: Date;
}
export interface LinkedItem {
type: 'code' | 'test' | 'documentation' | 'deployment';
path: string;
lineNumber?: number;
verified: boolean;
confidence: number;
}
export interface CoverageMetrics {
hasCode: boolean;
hasTests: boolean;
hasDocumentation: boolean;
hasDeployment: boolean;
completeness: number;
}
export interface TraceabilityReport {
totalRequirements: number;
tracedRequirements: number;
coveragePercentage: number;
orphanedRequirements: string[];
orphanedCode: string[];
orphanedTests: string[];
gapsByRequirement: Map<string, string[]>;
matrix: TraceabilityMatrix;
}
export interface VerificationResult {
verified: boolean;
issues: string[];
warnings: string[];
}
export interface OrphanReport {
orphanedRequirements: string[];
orphanedCode: string[];
orphanedTests: string[];
severity: Map<string, 'critical' | 'warning' | 'info'>;
}
export interface CoverageReport {
percentage: number;
byType: Map<string, number>;
byPriority: Map<string, number>;
gaps: GapAnalysis;
}
export interface GapAnalysis {
requirementsWithoutCode: string[];
requirementsWithoutTests: string[];
requirementsWithoutDocumentation: string[];
codeWithoutRequirements: string[];
testsWithoutRequirements: string[];
}
export interface ValidationResult {
passed: boolean;
coverage: number;
threshold: number;
issues: string[];
}
export interface GateValidationResult {
passed: boolean;
p0Coverage: number;
p1Coverage: number;
issues: string[];
warnings: string[];
}
/**
* TraceabilityChecker - Main class for traceability analysis
*/
export declare class TraceabilityChecker {
private projectPath;
private idExtractor;
private matrixGenerator;
private requirements;
private codeReferences;
private testReferences;
constructor(projectPath: string);
/**
* Scan requirements directory for requirement IDs
*/
scanRequirements(requirementsPath?: string): Promise<Map<string, Requirement>>;
/**
* Scan code directory for requirement IDs
*/
scanCode(codePath?: string): Promise<Map<string, CodeReference>>;
/**
* Scan test directory for requirement IDs
*/
scanTests(testPath?: string): Promise<Map<string, TestReference>>;
/**
* Scan all directories (requirements, code, tests)
*/
scanAll(): Promise<ScanResult>;
/**
* Build traceability links from scan results
*/
buildTraceabilityLinks(): Promise<Map<string, TraceabilityLink>>;
/**
* Verify links integrity
*/
verifyLinks(links: Map<string, TraceabilityLink>): Promise<VerificationResult>;
/**
* Detect orphaned requirements, code, and tests
*/
detectOrphans(): Promise<OrphanReport>;
/**
* Calculate overall coverage
*/
calculateCoverage(): Promise<CoverageReport>;
/**
* Calculate coverage by requirement type
*/
calculateCoverageByType(type: 'use-case' | 'nfr'): Promise<Map<string, number>>;
/**
* Identify gaps in traceability
*/
identifyGaps(): Promise<GapAnalysis>;
/**
* Generate traceability matrix
*/
generateMatrix(): Promise<TraceabilityMatrix>;
/**
* Export matrix to file
*/
exportMatrix(format: 'csv' | 'excel' | 'markdown' | 'html', outputPath?: string): Promise<string>;
/**
* Generate comprehensive traceability report
*/
generateReport(): Promise<TraceabilityReport>;
/**
* Generate gap report (markdown format)
*/
generateGapReport(): Promise<string>;
/**
* Export report to file
*/
exportReport(format: 'markdown' | 'json' | 'html', outputPath?: string): Promise<string>;
/**
* Validate traceability against threshold
*/
validateTraceability(threshold: number): Promise<ValidationResult>;
/**
* Check Construction gate criteria (100% P0 requirements traced)
*/
checkConstructionGate(): Promise<GateValidationResult>;
/**
* Add a traceability link manually
*/
addLink(requirementId: string, linkedItem: LinkedItem): Promise<void>;
/**
* Remove a traceability link
*/
removeLink(requirementId: string, itemPath: string): Promise<void>;
/**
* Update a traceability link
*/
updateLink(requirementId: string, itemPath: string, updates: Partial<LinkedItem>): Promise<void>;
private extractTitle;
private extractPriority;
private extractTestNames;
private calculateCoverageForRequirements;
}
//# sourceMappingURL=traceability-checker.d.ts.map