vibe-coder-mcp
Version:
Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.
208 lines • 6.56 kB
TypeScript
import { EventEmitter } from 'events';
import { AtomicTask, Project, TaskStatus, TaskPriority } from '../types/task.js';
import { EnhancedError } from '../utils/enhanced-errors.js';
import { Result } from './unified-lifecycle-manager.js';
export type StorageId = string & {
readonly __brand: 'StorageId';
};
export type TransactionId = string & {
readonly __brand: 'TransactionId';
};
export type BackupId = string & {
readonly __brand: 'BackupId';
};
export type CacheKey = string & {
readonly __brand: 'CacheKey';
};
export declare function createStorageId(id: string): StorageId;
export declare function createTransactionId(id: string): TransactionId;
export declare function createBackupId(id: string): BackupId;
export declare function createCacheKey(key: string): CacheKey;
export type StorageFormat = 'json' | 'yaml' | 'binary' | 'compressed';
export type StorageOperation = 'create' | 'read' | 'update' | 'delete' | 'list' | 'search';
export type StorageEntity = 'task' | 'project' | 'dependency' | 'epic' | 'graph';
export type TransactionStatus = 'pending' | 'committed' | 'rolled_back' | 'failed';
export interface CacheConfig {
enabled: boolean;
maxSize: number;
ttlSeconds: number;
compressionEnabled: boolean;
persistToDisk: boolean;
}
export interface BackupConfig {
enabled: boolean;
intervalMinutes: number;
maxBackups: number;
compressionEnabled: boolean;
encryptionEnabled: boolean;
remoteBackupEnabled: boolean;
}
export interface StorageTransaction {
id: TransactionId;
status: TransactionStatus;
operations: StorageOperation[];
entities: StorageEntity[];
startTime: Date;
endTime?: Date;
rollbackData: Map<string, unknown>;
metadata: {
initiator: string;
reason: string;
priority: 'low' | 'medium' | 'high';
};
}
export interface CacheEntry<T = unknown> {
key: CacheKey;
value: T;
createdAt: Date;
expiresAt: Date;
accessCount: number;
lastAccessed: Date;
size: number;
compressed: boolean;
}
export interface StorageBackup {
id: BackupId;
createdAt: Date;
size: number;
entities: StorageEntity[];
compressed: boolean;
encrypted: boolean;
checksum: string;
metadata: {
version: string;
creator: string;
description: string;
};
}
export interface StorageStatistics {
totalOperations: number;
operationsByType: Record<StorageOperation, number>;
operationsByEntity: Record<StorageEntity, number>;
averageResponseTime: number;
cacheHitRate: number;
storageSize: number;
activeTransactions: number;
totalBackups: number;
errorRate: number;
}
export interface TaskIndex {
tasks: Array<{
id: string;
title: string;
status: TaskStatus;
priority: TaskPriority;
projectId: string;
epicId: string;
estimatedHours: number;
createdAt: Date;
updatedAt: Date;
}>;
lastUpdated: string;
version: string;
}
export interface ProjectIndex {
projects: Array<{
id: string;
name: string;
createdAt: Date;
updatedAt: Date;
}>;
lastUpdated: string;
version: string;
}
export interface DependencyIndex {
dependencies: Array<{
id: string;
fromTaskId: string;
toTaskId: string;
type: string;
critical: boolean;
createdAt: Date;
}>;
lastUpdated: string;
version: string;
}
export interface EpicIndex {
epics: string[];
lastUpdated: string;
version: string;
}
export interface UnifiedStorageEngineConfig {
dataDirectory: string;
format: StorageFormat;
cache: CacheConfig;
backup: BackupConfig;
performance: {
batchSize: number;
maxConcurrentOperations: number;
enableCompression: boolean;
enableEncryption: boolean;
};
monitoring: {
enableMetrics: boolean;
metricsInterval: number;
enableAuditLog: boolean;
enablePerformanceTracking: boolean;
};
}
export declare class UnifiedStorageEngine extends EventEmitter {
private static instance;
private readonly config;
private readonly dataDirectory;
private initialized;
private readonly cache;
private readonly transactions;
private readonly backups;
private taskIndex;
private projectIndex;
private dependencyIndex;
private epicIndex;
private operationCount;
private operationsByType;
private operationsByEntity;
private totalResponseTime;
private cacheHits;
private cacheRequests;
private backupTimer;
private cacheCleanupTimer;
private metricsTimer;
private constructor();
static getInstance(config?: UnifiedStorageEngineConfig): UnifiedStorageEngine;
static resetInstance(): void;
initialize(): Promise<Result<void, EnhancedError>>;
private createDirectoryStructure;
private loadIndexes;
private startBackgroundProcesses;
createTask(task: AtomicTask): Promise<Result<AtomicTask, EnhancedError>>;
getTask(taskId: string): Promise<Result<AtomicTask, EnhancedError>>;
updateTask(taskId: string, updates: Partial<AtomicTask>): Promise<Result<AtomicTask, EnhancedError>>;
deleteTask(taskId: string): Promise<Result<void, EnhancedError>>;
listTasks(projectId?: string): Promise<Result<AtomicTask[], EnhancedError>>;
taskExists(taskId: string): Promise<boolean>;
createProject(project: Project): Promise<Result<Project, EnhancedError>>;
getProject(projectId: string): Promise<Result<Project, EnhancedError>>;
projectExists(projectId: string): Promise<boolean>;
updateProject(projectId: string, updates: Partial<Project>): Promise<Result<Project, EnhancedError>>;
deleteProject(projectId: string): Promise<Result<void, EnhancedError>>;
listProjects(): Promise<Result<Project[], EnhancedError>>;
private setCache;
private getCache;
private cleanupCache;
private evictOldestCacheEntries;
private performBackup;
private cleanupOldBackups;
private saveTaskIndex;
private saveProjectIndex;
private fileExists;
private copyDirectory;
private removeDirectory;
private getDirectorySize;
private calculateChecksum;
private trackOperation;
private collectMetrics;
getStatistics(): StorageStatistics;
dispose(): void;
}
export declare function createDefaultStorageConfig(): UnifiedStorageEngineConfig;
//# sourceMappingURL=unified-storage-engine.d.ts.map