@nahisaho/musubix-core 1.0.0

package/dist/traceability/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/traceability/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EAUzB,2BAA2B,GAC5B,MAAM,cAAc,CAAC;AAEtB,mDAAmD;AAEnD,OAAO,EACL,cAAc,EACd,oBAAoB,EAUpB,qBAAqB,GACtB,MAAM,aAAa,CAAC"}

package/dist/traceability/manager.d.ts

@@ -0,0 +1,266 @@
+/**
+ * Traceability Manager
+ *
+ * Manages bidirectional traceability between requirements, design, and code
+ *
+ * @packageDocumentation
+ * @module traceability/manager
+ *
+ * @see REQ-TRA-001 - Bidirectional Traceability
+ * @see Article IV - Traceability Requirements
+ */
+/**
+ * Traceable artifact types
+ */
+export type ArtifactType = 'requirement' | 'design' | 'code' | 'test' | 'task' | 'documentation';
+/**
+ * Trace link types
+ */
+export type TraceLinkType = 'derives' | 'implements' | 'satisfies' | 'verifies' | 'decomposes' | 'relates' | 'conflicts';
+/**
+ * Traceable artifact
+ */
+export interface TraceableArtifact {
+    /** Unique identifier */
+    id: string;
+    /** Artifact type */
+    type: ArtifactType;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Version */
+    version?: string;
+    /** Status */
+    status: ArtifactStatus;
+    /** Source file/location */
+    source?: {
+        file: string;
+        line?: number;
+        column?: number;
+    };
+    /** Metadata */
+    metadata?: Record<string, unknown>;
+    /** Created timestamp */
+    createdAt: string;
+    /** Updated timestamp */
+    updatedAt: string;
+}
+/**
+ * Artifact status
+ */
+export type ArtifactStatus = 'draft' | 'active' | 'deprecated' | 'deleted';
+/**
+ * Trace link between artifacts
+ */
+export interface TraceLink {
+    /** Link identifier */
+    id: string;
+    /** Source artifact ID */
+    sourceId: string;
+    /** Target artifact ID */
+    targetId: string;
+    /** Link type */
+    type: TraceLinkType;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Is manually verified */
+    verified: boolean;
+    /** Rationale for link */
+    rationale?: string;
+    /** Created by (user/system) */
+    createdBy: string;
+    /** Created timestamp */
+    createdAt: string;
+}
+/**
+ * Traceability matrix entry
+ */
+export interface MatrixEntry {
+    /** Requirement ID */
+    requirementId: string;
+    /** Design artifacts */
+    designs: string[];
+    /** Code artifacts */
+    code: string[];
+    /** Test artifacts */
+    tests: string[];
+    /** Coverage score (0-1) */
+    coverage: number;
+    /** Status */
+    status: 'covered' | 'partial' | 'uncovered';
+}
+/**
+ * Traceability gap
+ */
+export interface TraceabilityGap {
+    /** Artifact with gap */
+    artifactId: string;
+    /** Gap type */
+    gapType: 'no-parent' | 'no-child' | 'no-test' | 'no-impl';
+    /** Severity */
+    severity: 'high' | 'medium' | 'low';
+    /** Description */
+    description: string;
+    /** Suggestions */
+    suggestions: string[];
+}
+/**
+ * Traceability report
+ */
+export interface TraceabilityReport {
+    /** Generated timestamp */
+    generatedAt: string;
+    /** Total artifacts */
+    totalArtifacts: number;
+    /** Total links */
+    totalLinks: number;
+    /** Coverage statistics */
+    coverage: {
+        requirements: CoverageStats;
+        designs: CoverageStats;
+        code: CoverageStats;
+        tests: CoverageStats;
+    };
+    /** Identified gaps */
+    gaps: TraceabilityGap[];
+    /** Matrix (requirements view) */
+    matrix: MatrixEntry[];
+}
+/**
+ * Coverage statistics
+ */
+export interface CoverageStats {
+    /** Total items */
+    total: number;
+    /** Covered items */
+    covered: number;
+    /** Partial items */
+    partial: number;
+    /** Uncovered items */
+    uncovered: number;
+    /** Coverage percentage */
+    percentage: number;
+}
+/**
+ * Traceability Manager configuration
+ */
+export interface TraceabilityConfig {
+    /** Auto-detect links from code comments */
+    autoDetect: boolean;
+    /** Minimum confidence for auto-detected links */
+    autoDetectThreshold: number;
+    /** Require verification for links */
+    requireVerification: boolean;
+    /** Gap detection severity levels */
+    gapSeverity: {
+        noParent: 'high' | 'medium' | 'low';
+        noChild: 'high' | 'medium' | 'low';
+        noTest: 'high' | 'medium' | 'low';
+        noImpl: 'high' | 'medium' | 'low';
+    };
+}
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_TRACEABILITY_CONFIG: TraceabilityConfig;
+/**
+ * Traceability Manager
+ *
+ * Manages artifacts and their trace links
+ */
+export declare class TraceabilityManager {
+    private config;
+    private artifacts;
+    private links;
+    private artifactsByType;
+    constructor(config?: Partial<TraceabilityConfig>);
+    /**
+     * Register an artifact
+     */
+    registerArtifact(artifact: TraceableArtifact): void;
+    /**
+     * Register multiple artifacts
+     */
+    registerArtifacts(artifacts: TraceableArtifact[]): void;
+    /**
+     * Get artifact by ID
+     */
+    getArtifact(id: string): TraceableArtifact | undefined;
+    /**
+     * Get artifacts by type
+     */
+    getArtifactsByType(type: ArtifactType): TraceableArtifact[];
+    /**
+     * Create a trace link
+     */
+    createLink(sourceId: string, targetId: string, type: TraceLinkType, options?: {
+        confidence?: number;
+        rationale?: string;
+        createdBy?: string;
+        verified?: boolean;
+    }): TraceLink;
+    /**
+     * Get links from an artifact
+     */
+    getLinksFrom(artifactId: string): TraceLink[];
+    /**
+     * Get links to an artifact
+     */
+    getLinksTo(artifactId: string): TraceLink[];
+    /**
+     * Get all links for an artifact (both directions)
+     */
+    getAllLinks(artifactId: string): TraceLink[];
+    /**
+     * Find path between two artifacts
+     */
+    findPath(fromId: string, toId: string, maxDepth?: number): string[] | null;
+    /**
+     * Get downstream artifacts (artifacts that depend on this one)
+     */
+    getDownstream(artifactId: string): TraceableArtifact[];
+    /**
+     * Get upstream artifacts (artifacts this one depends on)
+     */
+    getUpstream(artifactId: string): TraceableArtifact[];
+    /**
+     * Generate traceability matrix
+     */
+    generateMatrix(): MatrixEntry[];
+    /**
+     * Detect traceability gaps
+     */
+    detectGaps(): TraceabilityGap[];
+    /**
+     * Generate traceability report
+     */
+    generateReport(): TraceabilityReport;
+    /**
+     * Auto-detect links from code annotations
+     */
+    autoDetectLinks(codeContent: string, codeArtifactId: string): TraceLink[];
+    /**
+     * Export to JSON
+     */
+    toJSON(): {
+        artifacts: TraceableArtifact[];
+        links: TraceLink[];
+    };
+    /**
+     * Import from JSON
+     */
+    fromJSON(data: {
+        artifacts: TraceableArtifact[];
+        links: TraceLink[];
+    }): void;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Create traceability manager instance
+ */
+export declare function createTraceabilityManager(config?: Partial<TraceabilityConfig>): TraceabilityManager;
+//# sourceMappingURL=manager.d.ts.map

package/dist/traceability/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/traceability/manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,aAAa,GACb,QAAQ,GACR,MAAM,GACN,MAAM,GACN,MAAM,GACN,eAAe,CAAC;AAEpB;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,YAAY,GACZ,WAAW,GACX,UAAU,GACV,YAAY,GACZ,SAAS,GACT,WAAW,CAAC;AAEhB;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,wBAAwB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,oBAAoB;IACpB,IAAI,EAAE,YAAY,CAAC;IACnB,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa;IACb,MAAM,EAAE,cAAc,CAAC;IACvB,2BAA2B;IAC3B,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,eAAe;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,wBAAwB;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,QAAQ,GACR,YAAY,GACZ,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,sBAAsB;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,wBAAwB;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,qBAAqB;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,uBAAuB;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,qBAAqB;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,qBAAqB;IACrB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2BAA2B;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa;IACb,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe;IACf,OAAO,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;IAC1D,eAAe;IACf,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACpC,kBAAkB;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,sBAAsB;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,QAAQ,EAAE;QACR,YAAY,EAAE,aAAa,CAAC;QAC5B,OAAO,EAAE,aAAa,CAAC;QACvB,IAAI,EAAE,aAAa,CAAC;QACpB,KAAK,EAAE,aAAa,CAAC;KACtB,CAAC;IACF,sBAAsB;IACtB,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,iCAAiC;IACjC,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,kBAAkB;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,sBAAsB;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,0BAA0B;IAC1B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,2CAA2C;IAC3C,UAAU,EAAE,OAAO,CAAC;IACpB,iDAAiD;IACjD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,qCAAqC;IACrC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,oCAAoC;IACpC,WAAW,EAAE;QACX,QAAQ,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;QACpC,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;QACnC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;QAClC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;KACnC,CAAC;CACH;AAED;;GAEG;AACH,eAAO,MAAM,2BAA2B,EAAE,kBAUzC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,eAAe,CAAwC;gBAEnD,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC;IAUhD;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI;IAKnD;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,IAAI;IAMvD;;OAEG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAItD;;OAEG;IACH,kBAAkB,CAAC,IAAI,EAAE,YAAY,GAAG,iBAAiB,EAAE;IAO3D;;OAEG;IACH,UAAU,CACR,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE;QACR,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,GACA,SAAS;IA2BZ;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE;IAK7C;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE;IAK3C;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE;IAK5C;;OAEG;IACH,QAAQ,CACN,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAAU,GACnB,MAAM,EAAE,GAAG,IAAI;IAgClB;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAqBtD;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAqBpD;;OAEG;IACH,cAAc,IAAI,WAAW,EAAE;IAsC/B;;OAEG;IACH,UAAU,IAAI,eAAe,EAAE;IA0E/B;;OAEG;IACH,cAAc,IAAI,kBAAkB;IA2CpC;;OAEG;IACH,eAAe,CACb,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,GACrB,SAAS,EAAE;IAsCd;;OAEG;IACH,MAAM,IAAI;QACR,SAAS,EAAE,iBAAiB,EAAE,CAAC;QAC/B,KAAK,EAAE,SAAS,EAAE,CAAC;KACpB;IAOD;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE;QACb,SAAS,EAAE,iBAAiB,EAAE,CAAC;QAC/B,KAAK,EAAE,SAAS,EAAE,CAAC;KACpB,GAAG,IAAI;IASR;;OAEG;IACH,KAAK,IAAI,IAAI;CAOd;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GACnC,mBAAmB,CAErB"}

package/dist/traceability/manager.js

@@ -0,0 +1,412 @@
+/**
+ * Traceability Manager
+ *
+ * Manages bidirectional traceability between requirements, design, and code
+ *
+ * @packageDocumentation
+ * @module traceability/manager
+ *
+ * @see REQ-TRA-001 - Bidirectional Traceability
+ * @see Article IV - Traceability Requirements
+ */
+/**
+ * Default configuration
+ */
+export const DEFAULT_TRACEABILITY_CONFIG = {
+    autoDetect: true,
+    autoDetectThreshold: 0.7,
+    requireVerification: false,
+    gapSeverity: {
+        noParent: 'low',
+        noChild: 'medium',
+        noTest: 'high',
+        noImpl: 'high',
+    },
+};
+/**
+ * Traceability Manager
+ *
+ * Manages artifacts and their trace links
+ */
+export class TraceabilityManager {
+    config;
+    artifacts = new Map();
+    links = new Map();
+    artifactsByType = new Map();
+    constructor(config) {
+        this.config = { ...DEFAULT_TRACEABILITY_CONFIG, ...config };
+        // Initialize type index
+        const types = ['requirement', 'design', 'code', 'test', 'task', 'documentation'];
+        for (const type of types) {
+            this.artifactsByType.set(type, new Set());
+        }
+    }
+    /**
+     * Register an artifact
+     */
+    registerArtifact(artifact) {
+        this.artifacts.set(artifact.id, artifact);
+        this.artifactsByType.get(artifact.type)?.add(artifact.id);
+    }
+    /**
+     * Register multiple artifacts
+     */
+    registerArtifacts(artifacts) {
+        for (const artifact of artifacts) {
+            this.registerArtifact(artifact);
+        }
+    }
+    /**
+     * Get artifact by ID
+     */
+    getArtifact(id) {
+        return this.artifacts.get(id);
+    }
+    /**
+     * Get artifacts by type
+     */
+    getArtifactsByType(type) {
+        const ids = this.artifactsByType.get(type) ?? new Set();
+        return Array.from(ids)
+            .map((id) => this.artifacts.get(id))
+            .filter((a) => a !== undefined);
+    }
+    /**
+     * Create a trace link
+     */
+    createLink(sourceId, targetId, type, options) {
+        const source = this.artifacts.get(sourceId);
+        const target = this.artifacts.get(targetId);
+        if (!source) {
+            throw new Error(`Source artifact not found: ${sourceId}`);
+        }
+        if (!target) {
+            throw new Error(`Target artifact not found: ${targetId}`);
+        }
+        const link = {
+            id: `${sourceId}-${type}-${targetId}`,
+            sourceId,
+            targetId,
+            type,
+            confidence: options?.confidence ?? 1.0,
+            verified: options?.verified ?? !this.config.requireVerification,
+            rationale: options?.rationale,
+            createdBy: options?.createdBy ?? 'system',
+            createdAt: new Date().toISOString(),
+        };
+        this.links.set(link.id, link);
+        return link;
+    }
+    /**
+     * Get links from an artifact
+     */
+    getLinksFrom(artifactId) {
+        return Array.from(this.links.values())
+            .filter((link) => link.sourceId === artifactId);
+    }
+    /**
+     * Get links to an artifact
+     */
+    getLinksTo(artifactId) {
+        return Array.from(this.links.values())
+            .filter((link) => link.targetId === artifactId);
+    }
+    /**
+     * Get all links for an artifact (both directions)
+     */
+    getAllLinks(artifactId) {
+        return Array.from(this.links.values())
+            .filter((link) => link.sourceId === artifactId || link.targetId === artifactId);
+    }
+    /**
+     * Find path between two artifacts
+     */
+    findPath(fromId, toId, maxDepth = 5) {
+        const visited = new Set();
+        const queue = [
+            { id: fromId, path: [fromId] },
+        ];
+        while (queue.length > 0) {
+            const { id, path } = queue.shift();
+            if (id === toId) {
+                return path;
+            }
+            if (path.length >= maxDepth || visited.has(id)) {
+                continue;
+            }
+            visited.add(id);
+            // Get connected artifacts
+            const links = this.getAllLinks(id);
+            for (const link of links) {
+                const nextId = link.sourceId === id ? link.targetId : link.sourceId;
+                if (!visited.has(nextId)) {
+                    queue.push({ id: nextId, path: [...path, nextId] });
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Get downstream artifacts (artifacts that depend on this one)
+     */
+    getDownstream(artifactId) {
+        const downstream = new Set();
+        const queue = [artifactId];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const links = this.getLinksFrom(current);
+            for (const link of links) {
+                if (!downstream.has(link.targetId)) {
+                    downstream.add(link.targetId);
+                    queue.push(link.targetId);
+                }
+            }
+        }
+        return Array.from(downstream)
+            .map((id) => this.artifacts.get(id))
+            .filter((a) => a !== undefined);
+    }
+    /**
+     * Get upstream artifacts (artifacts this one depends on)
+     */
+    getUpstream(artifactId) {
+        const upstream = new Set();
+        const queue = [artifactId];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const links = this.getLinksTo(current);
+            for (const link of links) {
+                if (!upstream.has(link.sourceId)) {
+                    upstream.add(link.sourceId);
+                    queue.push(link.sourceId);
+                }
+            }
+        }
+        return Array.from(upstream)
+            .map((id) => this.artifacts.get(id))
+            .filter((a) => a !== undefined);
+    }
+    /**
+     * Generate traceability matrix
+     */
+    generateMatrix() {
+        const requirements = this.getArtifactsByType('requirement');
+        const matrix = [];
+        for (const req of requirements) {
+            const downstream = this.getDownstream(req.id);
+            const designs = downstream
+                .filter((a) => a.type === 'design')
+                .map((a) => a.id);
+            const code = downstream
+                .filter((a) => a.type === 'code')
+                .map((a) => a.id);
+            const tests = downstream
+                .filter((a) => a.type === 'test')
+                .map((a) => a.id);
+            // Calculate coverage
+            let coverage = 0;
+            if (designs.length > 0)
+                coverage += 0.3;
+            if (code.length > 0)
+                coverage += 0.4;
+            if (tests.length > 0)
+                coverage += 0.3;
+            matrix.push({
+                requirementId: req.id,
+                designs,
+                code,
+                tests,
+                coverage,
+                status: coverage >= 0.9 ? 'covered' : coverage > 0 ? 'partial' : 'uncovered',
+            });
+        }
+        return matrix;
+    }
+    /**
+     * Detect traceability gaps
+     */
+    detectGaps() {
+        const gaps = [];
+        // Check requirements
+        for (const req of this.getArtifactsByType('requirement')) {
+            // No downstream links
+            if (this.getLinksFrom(req.id).length === 0) {
+                gaps.push({
+                    artifactId: req.id,
+                    gapType: 'no-child',
+                    severity: this.config.gapSeverity.noChild,
+                    description: `Requirement ${req.id} has no implementing artifacts`,
+                    suggestions: [
+                        'Create design elements that satisfy this requirement',
+                        'Link existing design or code to this requirement',
+                    ],
+                });
+            }
+            // No test coverage
+            const downstream = this.getDownstream(req.id);
+            const hasTest = downstream.some((a) => a.type === 'test');
+            if (!hasTest) {
+                gaps.push({
+                    artifactId: req.id,
+                    gapType: 'no-test',
+                    severity: this.config.gapSeverity.noTest,
+                    description: `Requirement ${req.id} has no test coverage`,
+                    suggestions: [
+                        'Create tests that verify this requirement',
+                        'Link existing tests to this requirement chain',
+                    ],
+                });
+            }
+        }
+        // Check code artifacts
+        for (const code of this.getArtifactsByType('code')) {
+            const upstream = this.getLinksTo(code.id);
+            if (upstream.length === 0) {
+                gaps.push({
+                    artifactId: code.id,
+                    gapType: 'no-parent',
+                    severity: this.config.gapSeverity.noParent,
+                    description: `Code ${code.id} is not linked to any requirement`,
+                    suggestions: [
+                        'Link this code to a requirement it implements',
+                        'Create a requirement for this functionality',
+                    ],
+                });
+            }
+        }
+        // Check designs without implementation
+        for (const design of this.getArtifactsByType('design')) {
+            const downstream = this.getDownstream(design.id);
+            const hasImpl = downstream.some((a) => a.type === 'code');
+            if (!hasImpl) {
+                gaps.push({
+                    artifactId: design.id,
+                    gapType: 'no-impl',
+                    severity: this.config.gapSeverity.noImpl,
+                    description: `Design ${design.id} has no implementation`,
+                    suggestions: [
+                        'Implement this design in code',
+                        'Link existing code to this design',
+                    ],
+                });
+            }
+        }
+        return gaps;
+    }
+    /**
+     * Generate traceability report
+     */
+    generateReport() {
+        const matrix = this.generateMatrix();
+        const gaps = this.detectGaps();
+        const calculateStats = (type) => {
+            const artifacts = this.getArtifactsByType(type);
+            let covered = 0;
+            let partial = 0;
+            for (const artifact of artifacts) {
+                const links = this.getAllLinks(artifact.id);
+                if (links.length > 1) {
+                    covered++;
+                }
+                else if (links.length === 1) {
+                    partial++;
+                }
+            }
+            const total = artifacts.length;
+            return {
+                total,
+                covered,
+                partial,
+                uncovered: total - covered - partial,
+                percentage: total > 0 ? ((covered + partial * 0.5) / total) * 100 : 0,
+            };
+        };
+        return {
+            generatedAt: new Date().toISOString(),
+            totalArtifacts: this.artifacts.size,
+            totalLinks: this.links.size,
+            coverage: {
+                requirements: calculateStats('requirement'),
+                designs: calculateStats('design'),
+                code: calculateStats('code'),
+                tests: calculateStats('test'),
+            },
+            gaps,
+            matrix,
+        };
+    }
+    /**
+     * Auto-detect links from code annotations
+     */
+    autoDetectLinks(codeContent, codeArtifactId) {
+        if (!this.config.autoDetect) {
+            return [];
+        }
+        const detectedLinks = [];
+        // Pattern: @see REQ-XXX, @implements REQ-XXX, @satisfies DES-XXX
+        const patterns = [
+            { regex: /@see\s+(REQ-\w+)/gi, type: 'relates' },
+            { regex: /@implements\s+(REQ-\w+)/gi, type: 'implements' },
+            { regex: /@satisfies\s+(DES-\w+)/gi, type: 'satisfies' },
+            { regex: /@verifies\s+(REQ-\w+)/gi, type: 'verifies' },
+        ];
+        for (const { regex, type } of patterns) {
+            let match;
+            while ((match = regex.exec(codeContent)) !== null) {
+                const targetId = match[1];
+                if (this.artifacts.has(targetId)) {
+                    try {
+                        const link = this.createLink(codeArtifactId, targetId, type, {
+                            confidence: this.config.autoDetectThreshold,
+                            rationale: 'Auto-detected from code annotation',
+                            createdBy: 'auto-detect',
+                            verified: false,
+                        });
+                        detectedLinks.push(link);
+                    }
+                    catch {
+                        // Link creation failed (e.g., duplicate)
+                    }
+                }
+            }
+        }
+        return detectedLinks;
+    }
+    /**
+     * Export to JSON
+     */
+    toJSON() {
+        return {
+            artifacts: Array.from(this.artifacts.values()),
+            links: Array.from(this.links.values()),
+        };
+    }
+    /**
+     * Import from JSON
+     */
+    fromJSON(data) {
+        for (const artifact of data.artifacts) {
+            this.registerArtifact(artifact);
+        }
+        for (const link of data.links) {
+            this.links.set(link.id, link);
+        }
+    }
+    /**
+     * Clear all data
+     */
+    clear() {
+        this.artifacts.clear();
+        this.links.clear();
+        for (const set of this.artifactsByType.values()) {
+            set.clear();
+        }
+    }
+}
+/**
+ * Create traceability manager instance
+ */
+export function createTraceabilityManager(config) {
+    return new TraceabilityManager(config);
+}
+//# sourceMappingURL=manager.js.map