vibe-coder-mcp/build/tools/vibe-task-manager/types/metadata-types.d.ts

Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.

export interface BaseMetadata {
    createdAt: Date;
    updatedAt: Date;
    createdBy: string;
    updatedBy?: string;
    version: number;
    changeHistory?: MetadataChange[];
    lifecycle: EntityLifecycle;
    attributes: Record<string, MetadataValue>;
}
export interface TaskMetadata extends BaseMetadata {
    tags: TagCollection;
    complexity: ComplexityMetadata;
    performance: PerformanceMetadata;
    quality: QualityMetadata;
    collaboration: CollaborationMetadata;
    integration: IntegrationMetadata;
}
export interface EpicMetadata extends BaseMetadata {
    tags: TagCollection;
    scope: ScopeMetadata;
    progress: ProgressMetadata;
    resources: ResourceMetadata;
}
export interface ProjectMetadata extends BaseMetadata {
    tags: TagCollection;
    classification: ProjectClassification;
    business: BusinessMetadata;
    technical: TechnicalMetadata;
    governance: GovernanceMetadata;
}
export interface TagCollection {
    functional: FunctionalTag[];
    technical: TechnicalTag[];
    business: BusinessTag[];
    process: ProcessTag[];
    quality: QualityTag[];
    custom: CustomTag[];
    generated: GeneratedTag[];
}
export interface BaseTag {
    id: string;
    value: string;
    category: TagCategory;
    confidence: number;
    source: TagSource;
    createdAt: Date;
    parentId?: string;
    metadata?: Record<string, unknown>;
}
export interface FunctionalTag extends BaseTag {
    category: 'functional';
    domain: 'auth' | 'api' | 'ui' | 'database' | 'security' | 'integration' | 'workflow' | 'analytics' | string;
    specificity: 'general' | 'specific' | 'detailed';
}
export interface TechnicalTag extends BaseTag {
    category: 'technical';
    stack: 'frontend' | 'backend' | 'database' | 'infrastructure' | 'tooling' | string;
    complexity: 'simple' | 'moderate' | 'complex' | 'critical';
}
export interface BusinessTag extends BaseTag {
    category: 'business';
    priority: 'low' | 'medium' | 'high' | 'critical';
    impact: 'local' | 'feature' | 'system' | 'strategic';
}
export interface ProcessTag extends BaseTag {
    category: 'process';
    stage: 'planning' | 'development' | 'testing' | 'review' | 'deployment' | 'maintenance';
    type: 'sequential' | 'parallel' | 'conditional' | 'iterative';
}
export interface QualityTag extends BaseTag {
    category: 'quality';
    dimension: 'performance' | 'reliability' | 'usability' | 'maintainability' | 'security' | 'accessibility';
    level: 'basic' | 'standard' | 'enhanced' | 'premium';
}
export interface CustomTag extends BaseTag {
    category: 'custom';
    customCategory: string;
    purpose?: string;
}
export interface GeneratedTag extends BaseTag {
    category: 'generated';
    method: 'llm_analysis' | 'pattern_matching' | 'ml_classification' | 'heuristic';
    generatedAt: Date;
    validated: boolean;
}
export type TagCategory = 'functional' | 'technical' | 'business' | 'process' | 'quality' | 'custom' | 'generated';
export type TagSource = 'user' | 'system' | 'ai' | 'integration' | 'migration' | 'template';
export type EntityLifecycle = 'draft' | 'active' | 'in_progress' | 'completed' | 'archived' | 'deprecated';
export type MetadataValue = string | number | boolean | Date | object | null;
export interface MetadataChange {
    timestamp: Date;
    changedBy: string;
    type: 'create' | 'update' | 'delete' | 'tag_added' | 'tag_removed' | 'attribute_changed';
    field: string;
    previousValue?: MetadataValue;
    newValue?: MetadataValue;
    reason?: string;
}
export interface ComplexityMetadata {
    overallScore: number;
    technical: number;
    business: number;
    integration: number;
    factors: ComplexityFactor[];
    analysis: {
        computedAt: Date;
        method: string;
        confidence: number;
    };
}
export interface ComplexityFactor {
    name: string;
    weight: number;
    description: string;
    category: 'technical' | 'business' | 'integration' | 'process';
}
export interface PerformanceMetadata {
    estimatedTime: number;
    actualTime?: number;
    targets: {
        responseTime?: number;
        throughput?: number;
        memoryUsage?: number;
        cpuUsage?: number;
    };
    metrics: {
        efficiency: number;
        resourceUtilization: number;
        scalability: number;
    };
}
export interface QualityMetadata {
    score: number;
    dimensions: {
        codeQuality: number;
        testCoverage: number;
        documentation: number;
        maintainability: number;
        reliability: number;
    };
    gates: QualityGate[];
    standards: string[];
}
export interface QualityGate {
    name: string;
    criteria: string;
    status: 'passed' | 'failed' | 'pending' | 'skipped';
    result?: {
        value: number;
        threshold: number;
        message: string;
    };
}
export interface CollaborationMetadata {
    assignees: string[];
    reviewers: string[];
    stakeholders: string[];
    patterns: {
        pairProgramming: boolean;
        codeReview: boolean;
        mobProgramming: boolean;
    };
    channels: string[];
}
export interface IntegrationMetadata {
    externalSystems: string[];
    dependencies: {
        internal: string[];
        external: string[];
        optional: string[];
    };
    integrationPoints: IntegrationPoint[];
    contracts: string[];
}
export interface IntegrationPoint {
    name: string;
    type: 'api' | 'database' | 'queue' | 'webhook' | 'file' | 'stream';
    direction: 'inbound' | 'outbound' | 'bidirectional';
    criticality: 'low' | 'medium' | 'high' | 'critical';
}
export interface ScopeMetadata {
    definition: string;
    boundaries: string[];
    includes: string[];
    excludes: string[];
    changes: ScopeChange[];
}
export interface ScopeChange {
    timestamp: Date;
    type: 'addition' | 'removal' | 'modification';
    description: string;
    impact: 'low' | 'medium' | 'high';
    approvedBy: string;
}
export interface ProgressMetadata {
    percentage: number;
    milestones: Milestone[];
    tracking: {
        method: 'manual' | 'automated' | 'hybrid';
        frequency: 'daily' | 'weekly' | 'milestone';
        lastUpdated: Date;
    };
    blockers: Blocker[];
}
export interface Milestone {
    name: string;
    description: string;
    targetDate: Date;
    completedDate?: Date;
    status: 'pending' | 'in_progress' | 'completed' | 'delayed';
    criteria: string[];
}
export interface Blocker {
    id: string;
    description: string;
    type: 'technical' | 'resource' | 'external' | 'dependency' | 'approval';
    severity: 'low' | 'medium' | 'high' | 'critical';
    status: 'open' | 'in_progress' | 'resolved';
    resolution?: string;
    createdAt: Date;
    resolvedAt?: Date;
}
export interface ResourceMetadata {
    allocated: {
        people: number;
        budget: number;
        tools: string[];
        timeframe: {
            start: Date;
            end: Date;
        };
    };
    utilization: {
        actual: number;
        planned: number;
        efficiency: number;
    };
    constraints: string[];
}
export interface ProjectClassification {
    type: 'greenfield' | 'brownfield' | 'maintenance' | 'research' | 'migration';
    size: 'small' | 'medium' | 'large' | 'enterprise';
    domain: string[];
    methodologies: string[];
    riskLevel: 'low' | 'medium' | 'high' | 'critical';
}
export interface BusinessMetadata {
    objectives: string[];
    successMetrics: SuccessMetric[];
    stakeholders: StakeholderInfo[];
    value: {
        financial: number;
        strategic: number;
        operational: number;
    };
    market: {
        segment: string;
        competition: string[];
        opportunities: string[];
    };
}
export interface SuccessMetric {
    name: string;
    type: 'kpi' | 'okr' | 'metric' | 'target';
    target: number;
    current?: number;
    unit: string;
    frequency: 'daily' | 'weekly' | 'monthly' | 'quarterly';
}
export interface StakeholderInfo {
    name: string;
    role: string;
    influence: 'low' | 'medium' | 'high';
    interest: 'low' | 'medium' | 'high';
    communication: string[];
}
export interface TechnicalMetadata {
    architecture: string[];
    stack: {
        frontend: string[];
        backend: string[];
        database: string[];
        infrastructure: string[];
        tools: string[];
    };
    constraints: TechnicalConstraint[];
    performance: {
        responseTime: number;
        throughput: number;
        availability: number;
        scalability: string;
    };
    security: {
        classification: 'public' | 'internal' | 'confidential' | 'restricted';
        compliance: string[];
        threats: string[];
    };
}
export interface TechnicalConstraint {
    type: 'platform' | 'technology' | 'performance' | 'security' | 'compliance';
    description: string;
    impact: 'low' | 'medium' | 'high';
    mitigation: string[];
}
export interface GovernanceMetadata {
    approvals: ApprovalWorkflow[];
    compliance: ComplianceRequirement[];
    audit: AuditEntry[];
    risk: RiskAssessment;
    changeControl: {
        process: string;
        approvers: string[];
        documentation: string[];
    };
}
export interface ApprovalWorkflow {
    name: string;
    type: 'sequential' | 'parallel' | 'conditional';
    steps: ApprovalStep[];
    status: 'pending' | 'in_progress' | 'approved' | 'rejected';
}
export interface ApprovalStep {
    name: string;
    approver: string;
    status: 'pending' | 'approved' | 'rejected';
    approvedAt?: Date;
    comments?: string;
}
export interface ComplianceRequirement {
    name: string;
    framework: string;
    level: 'mandatory' | 'recommended' | 'optional';
    status: 'compliant' | 'non_compliant' | 'pending' | 'not_applicable';
    evidence: string[];
}
export interface AuditEntry {
    timestamp: Date;
    user: string;
    action: string;
    entity: {
        type: 'task' | 'epic' | 'project';
        id: string;
    };
    details: Record<string, unknown>;
    result: 'success' | 'failure' | 'partial';
}
export interface RiskAssessment {
    overallScore: number;
    categories: {
        technical: number;
        business: number;
        security: number;
        operational: number;
    };
    risks: IdentifiedRisk[];
    mitigation: RiskMitigation[];
    assessedAt: Date;
    nextReview: Date;
}
export interface IdentifiedRisk {
    id: string;
    description: string;
    category: 'technical' | 'business' | 'security' | 'operational';
    probability: 'low' | 'medium' | 'high';
    impact: 'low' | 'medium' | 'high';
    score: number;
    owner: string;
}
export interface RiskMitigation {
    riskId: string;
    strategy: 'avoid' | 'mitigate' | 'transfer' | 'accept';
    actions: string[];
    owner: string;
    timeline: {
        start: Date;
        end: Date;
    };
    status: 'planned' | 'in_progress' | 'completed' | 'deferred';
}
//# sourceMappingURL=metadata-types.d.ts.map