claude-flow-novice 2.15.3 → 2.15.4

package/dist/lib/database-service/correlation.js

@@ -0,0 +1,329 @@
+/**
+ * Correlation Key Utilities
+ *
+ * Provides correlation key generation and parsing for cross-database lookups.
+ * Part of Task 0.4: Database Query Abstraction Layer (MVP)
+ *
+ * Format: {type}:{id}:{entity}:{subtype}
+ * Examples:
+ *   - task:abc123:agent:backend-developer
+ *   - task:abc123:skill:auth-validation
+ *   - agent:agent-456:execution:iteration-1
+ */ /**
+ * Build correlation key string
+ */ export function buildCorrelationKey(key) {
+    const parts = [
+        key.type,
+        key.id
+    ];
+    if (key.entity) {
+        parts.push(key.entity);
+    }
+    if (key.subtype) {
+        parts.push(key.subtype);
+    }
+    return parts.join(':');
+}
+/**
+ * Parse correlation key string
+ */ export function parseCorrelationKey(keyString) {
+    const parts = keyString.split(':');
+    if (parts.length < 2) {
+        return null;
+    }
+    const [type, id, entity, subtype] = parts;
+    if (!isValidKeyType(type)) {
+        return null;
+    }
+    return {
+        type: type,
+        id,
+        entity,
+        subtype
+    };
+}
+/**
+ * Check if correlation key type is valid
+ */ function isValidKeyType(type) {
+    return [
+        'task',
+        'agent',
+        'skill',
+        'execution'
+    ].includes(type);
+}
+/**
+ * Build task correlation key
+ */ export function buildTaskKey(taskId, entity) {
+    return buildCorrelationKey({
+        type: 'task',
+        id: taskId,
+        entity
+    });
+}
+/**
+ * Build agent correlation key
+ */ export function buildAgentKey(agentId, entity) {
+    return buildCorrelationKey({
+        type: 'agent',
+        id: agentId,
+        entity
+    });
+}
+/**
+ * Build skill correlation key
+ */ export function buildSkillKey(skillId, entity) {
+    return buildCorrelationKey({
+        type: 'skill',
+        id: skillId,
+        entity
+    });
+}
+/**
+ * Build execution correlation key
+ */ export function buildExecutionKey(executionId, entity) {
+    return buildCorrelationKey({
+        type: 'execution',
+        id: executionId,
+        entity
+    });
+}
+/**
+ * Extract task ID from correlation key
+ */ export function extractTaskId(keyString) {
+    const key = parseCorrelationKey(keyString);
+    return key && key.type === 'task' ? key.id : null;
+}
+/**
+ * Extract agent ID from correlation key
+ */ export function extractAgentId(keyString) {
+    const key = parseCorrelationKey(keyString);
+    return key && key.type === 'agent' ? key.id : null;
+}
+/**
+ * Check if correlation key matches pattern
+ */ export function matchesPattern(keyString, pattern) {
+    const key = parseCorrelationKey(keyString);
+    if (!key) {
+        return false;
+    }
+    if (pattern.type && key.type !== pattern.type) {
+        return false;
+    }
+    if (pattern.id && key.id !== pattern.id) {
+        return false;
+    }
+    if (pattern.entity && key.entity !== pattern.entity) {
+        return false;
+    }
+    if (pattern.subtype && key.subtype !== pattern.subtype) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Entity type mapping for cross-database queries
+ */ export const ENTITY_TYPE_MAP = {
+    agent: [
+        'execution',
+        'result',
+        'metadata'
+    ],
+    skill: [
+        'invocation',
+        'result',
+        'metadata'
+    ],
+    task: [
+        'agent',
+        'skill',
+        'artifact',
+        'event'
+    ],
+    execution: [
+        'step',
+        'log',
+        'metric'
+    ]
+};
+/**
+ * Generate wildcard pattern string for Redis SCAN operations
+ *
+ * @example
+ * ```typescript
+ * buildWildcardPattern({ type: 'task', id: '*', entity: 'agent' })
+ * // Returns: "task:*:agent"
+ *
+ * buildWildcardPattern({ type: '*', id: 'abc123' })
+ * // Returns: "*:abc123"
+ * ```
+ */ export function buildWildcardPattern(pattern) {
+    const parts = [];
+    parts.push(pattern.type || '*');
+    parts.push(pattern.id || '*');
+    if (pattern.entity !== undefined) {
+        parts.push(pattern.entity);
+    }
+    if (pattern.subtype !== undefined) {
+        parts.push(pattern.subtype);
+    }
+    return parts.join(':');
+}
+/**
+ * Validate correlation key with detailed error messages
+ *
+ * @param keyString - Correlation key string to validate
+ * @returns Validation errors (empty array if valid)
+ */ export function validateCorrelationKey(keyString) {
+    const errors = [];
+    // Check for null/undefined
+    if (!keyString || typeof keyString !== 'string') {
+        errors.push({
+            code: 'MISSING_REQUIRED',
+            message: 'Correlation key must be a non-empty string',
+            value: String(keyString)
+        });
+        return errors;
+    }
+    // Check format (minimum 2 parts: type:id)
+    const parts = keyString.split(':');
+    if (parts.length < 2) {
+        errors.push({
+            code: 'INVALID_FORMAT',
+            message: 'Correlation key must have at least 2 parts (type:id)',
+            value: keyString
+        });
+        return errors;
+    }
+    const [type, id, entity, subtype] = parts;
+    // Validate type
+    if (![
+        'task',
+        'agent',
+        'skill',
+        'execution'
+    ].includes(type)) {
+        errors.push({
+            code: 'INVALID_TYPE',
+            message: `Invalid correlation type. Must be one of: task, agent, skill, execution`,
+            field: 'type',
+            value: type
+        });
+    }
+    // Validate ID (non-empty)
+    if (!id || id.trim() === '') {
+        errors.push({
+            code: 'MISSING_REQUIRED',
+            message: 'Correlation ID cannot be empty',
+            field: 'id',
+            value: id
+        });
+    }
+    // Validate entity (if present, check against type map)
+    if (entity && type && isValidKeyType(type)) {
+        const validEntities = ENTITY_TYPE_MAP[type];
+        if (validEntities && !validEntities.includes(entity)) {
+            errors.push({
+                code: 'INVALID_PATTERN',
+                message: `Invalid entity '${entity}' for type '${type}'. Valid entities: ${validEntities.join(', ')}`,
+                field: 'entity',
+                value: entity
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Check if correlation key is valid
+ *
+ * @param keyString - Correlation key to check
+ * @returns True if valid, false otherwise
+ */ export function isValidCorrelationKey(keyString) {
+    return validateCorrelationKey(keyString).length === 0;
+}
+/**
+ * Get entity types for a correlation key type
+ *
+ * @param type - Correlation key type
+ * @returns Array of valid entity types
+ */ export function getEntityTypes(type) {
+    return ENTITY_TYPE_MAP[type] || [];
+}
+/**
+ * Build multiple correlation keys in batch
+ *
+ * @param keys - Array of correlation key parts
+ * @returns Array of correlation key strings
+ *
+ * @example
+ * ```typescript
+ * buildBatch([
+ *   { type: 'task', id: 'task-1', entity: 'agent' },
+ *   { type: 'task', id: 'task-1', entity: 'skill' },
+ * ])
+ * // Returns: ['task:task-1:agent', 'task:task-1:skill']
+ * ```
+ */ export function buildBatch(keys) {
+    return keys.map(buildCorrelationKey);
+}
+/**
+ * Parse multiple correlation keys in batch
+ *
+ * @param keyStrings - Array of correlation key strings
+ * @returns Array of parsed correlation keys (nulls filtered out)
+ */ export function parseBatch(keyStrings) {
+    return keyStrings.map(parseCorrelationKey).filter((key)=>key !== null);
+}
+/**
+ * Match correlation key against wildcard pattern
+ *
+ * @param keyString - Correlation key to match
+ * @param pattern - Wildcard pattern
+ * @returns True if key matches pattern
+ *
+ * @example
+ * ```typescript
+ * matchesWildcard('task:abc123:agent:backend', {
+ *   type: 'task',
+ *   id: '*',
+ *   entity: 'agent'
+ * }) // Returns: true
+ *
+ * matchesWildcard('agent:xyz:execution', {
+ *   type: 'task'
+ * }) // Returns: false
+ * ```
+ */ export function matchesWildcard(keyString, pattern) {
+    const key = parseCorrelationKey(keyString);
+    if (!key) {
+        return false;
+    }
+    // Check type
+    if (pattern.type && pattern.type !== '*' && key.type !== pattern.type) {
+        return false;
+    }
+    // Check ID
+    if (pattern.id && pattern.id !== '*' && key.id !== pattern.id) {
+        return false;
+    }
+    // Check entity
+    if (pattern.entity !== undefined && pattern.entity !== '*' && key.entity !== pattern.entity) {
+        return false;
+    }
+    // Check subtype
+    if (pattern.subtype !== undefined && pattern.subtype !== '*' && key.subtype !== pattern.subtype) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Filter correlation keys by wildcard pattern
+ *
+ * @param keyStrings - Array of correlation keys
+ * @param pattern - Wildcard pattern to filter by
+ * @returns Filtered array of keys matching pattern
+ */ export function filterByPattern(keyStrings, pattern) {
+    return keyStrings.filter((key)=>matchesWildcard(key, pattern));
+}
+
+//# sourceMappingURL=correlation.js.map

package/dist/lib/database-service/correlation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/database-service/correlation.ts"],"sourcesContent":["/**\r\n * Correlation Key Utilities\r\n *\r\n * Provides correlation key generation and parsing for cross-database lookups.\r\n * Part of Task 0.4: Database Query Abstraction Layer (MVP)\r\n *\r\n * Format: {type}:{id}:{entity}:{subtype}\r\n * Examples:\r\n *   - task:abc123:agent:backend-developer\r\n *   - task:abc123:skill:auth-validation\r\n *   - agent:agent-456:execution:iteration-1\r\n */\r\n\r\nimport { CorrelationKey } from './types.js';\r\n\r\n/**\r\n * Build correlation key string\r\n */\r\nexport function buildCorrelationKey(key: CorrelationKey): string {\r\n  const parts = [key.type, key.id];\r\n\r\n  if (key.entity) {\r\n    parts.push(key.entity);\r\n  }\r\n\r\n  if (key.subtype) {\r\n    parts.push(key.subtype);\r\n  }\r\n\r\n  return parts.join(':');\r\n}\r\n\r\n/**\r\n * Parse correlation key string\r\n */\r\nexport function parseCorrelationKey(keyString: string): CorrelationKey | null {\r\n  const parts = keyString.split(':');\r\n\r\n  if (parts.length < 2) {\r\n    return null;\r\n  }\r\n\r\n  const [type, id, entity, subtype] = parts;\r\n\r\n  if (!isValidKeyType(type)) {\r\n    return null;\r\n  }\r\n\r\n  return {\r\n    type: type as CorrelationKey['type'],\r\n    id,\r\n    entity,\r\n    subtype,\r\n  };\r\n}\r\n\r\n/**\r\n * Check if correlation key type is valid\r\n */\r\nfunction isValidKeyType(type: string): type is CorrelationKey['type'] {\r\n  return ['task', 'agent', 'skill', 'execution'].includes(type);\r\n}\r\n\r\n/**\r\n * Build task correlation key\r\n */\r\nexport function buildTaskKey(taskId: string, entity?: string): string {\r\n  return buildCorrelationKey({\r\n    type: 'task',\r\n    id: taskId,\r\n    entity,\r\n  });\r\n}\r\n\r\n/**\r\n * Build agent correlation key\r\n */\r\nexport function buildAgentKey(agentId: string, entity?: string): string {\r\n  return buildCorrelationKey({\r\n    type: 'agent',\r\n    id: agentId,\r\n    entity,\r\n  });\r\n}\r\n\r\n/**\r\n * Build skill correlation key\r\n */\r\nexport function buildSkillKey(skillId: string, entity?: string): string {\r\n  return buildCorrelationKey({\r\n    type: 'skill',\r\n    id: skillId,\r\n    entity,\r\n  });\r\n}\r\n\r\n/**\r\n * Build execution correlation key\r\n */\r\nexport function buildExecutionKey(executionId: string, entity?: string): string {\r\n  return buildCorrelationKey({\r\n    type: 'execution',\r\n    id: executionId,\r\n    entity,\r\n  });\r\n}\r\n\r\n/**\r\n * Extract task ID from correlation key\r\n */\r\nexport function extractTaskId(keyString: string): string | null {\r\n  const key = parseCorrelationKey(keyString);\r\n  return key && key.type === 'task' ? key.id : null;\r\n}\r\n\r\n/**\r\n * Extract agent ID from correlation key\r\n */\r\nexport function extractAgentId(keyString: string): string | null {\r\n  const key = parseCorrelationKey(keyString);\r\n  return key && key.type === 'agent' ? key.id : null;\r\n}\r\n\r\n/**\r\n * Check if correlation key matches pattern\r\n */\r\nexport function matchesPattern(keyString: string, pattern: Partial<CorrelationKey>): boolean {\r\n  const key = parseCorrelationKey(keyString);\r\n\r\n  if (!key) {\r\n    return false;\r\n  }\r\n\r\n  if (pattern.type && key.type !== pattern.type) {\r\n    return false;\r\n  }\r\n\r\n  if (pattern.id && key.id !== pattern.id) {\r\n    return false;\r\n  }\r\n\r\n  if (pattern.entity && key.entity !== pattern.entity) {\r\n    return false;\r\n  }\r\n\r\n  if (pattern.subtype && key.subtype !== pattern.subtype) {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\n/**\r\n * Wildcard pattern for correlation key queries\r\n * Part of Task 3.3: Query Correlation Key Layer\r\n */\r\nexport interface WildcardPattern {\r\n  type?: 'task' | 'agent' | 'skill' | 'execution' | '*';\r\n  id?: string | '*';\r\n  entity?: string | '*';\r\n  subtype?: string | '*';\r\n}\r\n\r\n/**\r\n * Validation error details\r\n */\r\nexport interface ValidationError {\r\n  code: 'INVALID_FORMAT' | 'INVALID_TYPE' | 'MISSING_REQUIRED' | 'INVALID_PATTERN';\r\n  message: string;\r\n  field?: string;\r\n  value?: string;\r\n}\r\n\r\n/**\r\n * Entity type mapping for cross-database queries\r\n */\r\nexport const ENTITY_TYPE_MAP = {\r\n  agent: ['execution', 'result', 'metadata'],\r\n  skill: ['invocation', 'result', 'metadata'],\r\n  task: ['agent', 'skill', 'artifact', 'event'],\r\n  execution: ['step', 'log', 'metric'],\r\n} as const;\r\n\r\n/**\r\n * Generate wildcard pattern string for Redis SCAN operations\r\n *\r\n * @example\r\n * ```typescript\r\n * buildWildcardPattern({ type: 'task', id: '*', entity: 'agent' })\r\n * // Returns: \"task:*:agent\"\r\n *\r\n * buildWildcardPattern({ type: '*', id: 'abc123' })\r\n * // Returns: \"*:abc123\"\r\n * ```\r\n */\r\nexport function buildWildcardPattern(pattern: WildcardPattern): string {\r\n  const parts: string[] = [];\r\n\r\n  parts.push(pattern.type || '*');\r\n  parts.push(pattern.id || '*');\r\n\r\n  if (pattern.entity !== undefined) {\r\n    parts.push(pattern.entity);\r\n  }\r\n\r\n  if (pattern.subtype !== undefined) {\r\n    parts.push(pattern.subtype);\r\n  }\r\n\r\n  return parts.join(':');\r\n}\r\n\r\n/**\r\n * Validate correlation key with detailed error messages\r\n *\r\n * @param keyString - Correlation key string to validate\r\n * @returns Validation errors (empty array if valid)\r\n */\r\nexport function validateCorrelationKey(keyString: string): ValidationError[] {\r\n  const errors: ValidationError[] = [];\r\n\r\n  // Check for null/undefined\r\n  if (!keyString || typeof keyString !== 'string') {\r\n    errors.push({\r\n      code: 'MISSING_REQUIRED',\r\n      message: 'Correlation key must be a non-empty string',\r\n      value: String(keyString),\r\n    });\r\n    return errors;\r\n  }\r\n\r\n  // Check format (minimum 2 parts: type:id)\r\n  const parts = keyString.split(':');\r\n  if (parts.length < 2) {\r\n    errors.push({\r\n      code: 'INVALID_FORMAT',\r\n      message: 'Correlation key must have at least 2 parts (type:id)',\r\n      value: keyString,\r\n    });\r\n    return errors;\r\n  }\r\n\r\n  const [type, id, entity, subtype] = parts;\r\n\r\n  // Validate type\r\n  if (!['task', 'agent', 'skill', 'execution'].includes(type)) {\r\n    errors.push({\r\n      code: 'INVALID_TYPE',\r\n      message: `Invalid correlation type. Must be one of: task, agent, skill, execution`,\r\n      field: 'type',\r\n      value: type,\r\n    });\r\n  }\r\n\r\n  // Validate ID (non-empty)\r\n  if (!id || id.trim() === '') {\r\n    errors.push({\r\n      code: 'MISSING_REQUIRED',\r\n      message: 'Correlation ID cannot be empty',\r\n      field: 'id',\r\n      value: id,\r\n    });\r\n  }\r\n\r\n  // Validate entity (if present, check against type map)\r\n  if (entity && type && isValidKeyType(type)) {\r\n    const validEntities = ENTITY_TYPE_MAP[type];\r\n    if (validEntities && !validEntities.includes(entity as any)) {\r\n      errors.push({\r\n        code: 'INVALID_PATTERN',\r\n        message: `Invalid entity '${entity}' for type '${type}'. Valid entities: ${validEntities.join(', ')}`,\r\n        field: 'entity',\r\n        value: entity,\r\n      });\r\n    }\r\n  }\r\n\r\n  return errors;\r\n}\r\n\r\n/**\r\n * Check if correlation key is valid\r\n *\r\n * @param keyString - Correlation key to check\r\n * @returns True if valid, false otherwise\r\n */\r\nexport function isValidCorrelationKey(keyString: string): boolean {\r\n  return validateCorrelationKey(keyString).length === 0;\r\n}\r\n\r\n/**\r\n * Get entity types for a correlation key type\r\n *\r\n * @param type - Correlation key type\r\n * @returns Array of valid entity types\r\n */\r\nexport function getEntityTypes(type: CorrelationKey['type']): readonly string[] {\r\n  return ENTITY_TYPE_MAP[type] || [];\r\n}\r\n\r\n/**\r\n * Build multiple correlation keys in batch\r\n *\r\n * @param keys - Array of correlation key parts\r\n * @returns Array of correlation key strings\r\n *\r\n * @example\r\n * ```typescript\r\n * buildBatch([\r\n *   { type: 'task', id: 'task-1', entity: 'agent' },\r\n *   { type: 'task', id: 'task-1', entity: 'skill' },\r\n * ])\r\n * // Returns: ['task:task-1:agent', 'task:task-1:skill']\r\n * ```\r\n */\r\nexport function buildBatch(keys: CorrelationKey[]): string[] {\r\n  return keys.map(buildCorrelationKey);\r\n}\r\n\r\n/**\r\n * Parse multiple correlation keys in batch\r\n *\r\n * @param keyStrings - Array of correlation key strings\r\n * @returns Array of parsed correlation keys (nulls filtered out)\r\n */\r\nexport function parseBatch(keyStrings: string[]): CorrelationKey[] {\r\n  return keyStrings\r\n    .map(parseCorrelationKey)\r\n    .filter((key): key is CorrelationKey => key !== null);\r\n}\r\n\r\n/**\r\n * Match correlation key against wildcard pattern\r\n *\r\n * @param keyString - Correlation key to match\r\n * @param pattern - Wildcard pattern\r\n * @returns True if key matches pattern\r\n *\r\n * @example\r\n * ```typescript\r\n * matchesWildcard('task:abc123:agent:backend', {\r\n *   type: 'task',\r\n *   id: '*',\r\n *   entity: 'agent'\r\n * }) // Returns: true\r\n *\r\n * matchesWildcard('agent:xyz:execution', {\r\n *   type: 'task'\r\n * }) // Returns: false\r\n * ```\r\n */\r\nexport function matchesWildcard(keyString: string, pattern: WildcardPattern): boolean {\r\n  const key = parseCorrelationKey(keyString);\r\n\r\n  if (!key) {\r\n    return false;\r\n  }\r\n\r\n  // Check type\r\n  if (pattern.type && pattern.type !== '*' && key.type !== pattern.type) {\r\n    return false;\r\n  }\r\n\r\n  // Check ID\r\n  if (pattern.id && pattern.id !== '*' && key.id !== pattern.id) {\r\n    return false;\r\n  }\r\n\r\n  // Check entity\r\n  if (pattern.entity !== undefined && pattern.entity !== '*' && key.entity !== pattern.entity) {\r\n    return false;\r\n  }\r\n\r\n  // Check subtype\r\n  if (pattern.subtype !== undefined && pattern.subtype !== '*' && key.subtype !== pattern.subtype) {\r\n    return false;\r\n  }\r\n\r\n  return true;\r\n}\r\n\r\n/**\r\n * Filter correlation keys by wildcard pattern\r\n *\r\n * @param keyStrings - Array of correlation keys\r\n * @param pattern - Wildcard pattern to filter by\r\n * @returns Filtered array of keys matching pattern\r\n */\r\nexport function filterByPattern(keyStrings: string[], pattern: WildcardPattern): string[] {\r\n  return keyStrings.filter(key => matchesWildcard(key, pattern));\r\n}\r\n"],"names":["buildCorrelationKey","key","parts","type","id","entity","push","subtype","join","parseCorrelationKey","keyString","split","length","isValidKeyType","includes","buildTaskKey","taskId","buildAgentKey","agentId","buildSkillKey","skillId","buildExecutionKey","executionId","extractTaskId","extractAgentId","matchesPattern","pattern","ENTITY_TYPE_MAP","agent","skill","task","execution","buildWildcardPattern","undefined","validateCorrelationKey","errors","code","message","value","String","field","trim","validEntities","isValidCorrelationKey","getEntityTypes","buildBatch","keys","map","parseBatch","keyStrings","filter","matchesWildcard","filterByPattern"],"mappings":"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"}

package/dist/lib/database-service/errors.js

@@ -0,0 +1,120 @@
+/**
+ * Database Error Handling Utilities
+ *
+ * Provides standardized error handling for database operations.
+ * Part of Task 0.4: Database Query Abstraction Layer (MVP)
+ */ /**
+ * Database error codes
+ */ export var DatabaseErrorCode = /*#__PURE__*/ function(DatabaseErrorCode) {
+    DatabaseErrorCode["CONNECTION_FAILED"] = "DB_CONNECTION_FAILED";
+    DatabaseErrorCode["QUERY_FAILED"] = "DB_QUERY_FAILED";
+    DatabaseErrorCode["TRANSACTION_FAILED"] = "DB_TRANSACTION_FAILED";
+    DatabaseErrorCode["VALIDATION_FAILED"] = "DB_VALIDATION_FAILED";
+    DatabaseErrorCode["NOT_FOUND"] = "DB_NOT_FOUND";
+    DatabaseErrorCode["DUPLICATE_KEY"] = "DB_DUPLICATE_KEY";
+    DatabaseErrorCode["TIMEOUT"] = "DB_TIMEOUT";
+    DatabaseErrorCode["CONSTRAINT_VIOLATION"] = "DB_CONSTRAINT_VIOLATION";
+    DatabaseErrorCode["UNKNOWN_ERROR"] = "DB_UNKNOWN_ERROR";
+    return DatabaseErrorCode;
+}({});
+/**
+ * Create standardized database error
+ */ export function createDatabaseError(code, message, originalError, context) {
+    return {
+        code,
+        message,
+        originalError,
+        context
+    };
+}
+/**
+ * Create failed operation result
+ */ export function createFailedResult(error) {
+    return {
+        success: false,
+        error
+    };
+}
+/**
+ * Create successful operation result
+ */ export function createSuccessResult(data, rowsAffected, insertId) {
+    return {
+        success: true,
+        data,
+        rowsAffected,
+        insertId
+    };
+}
+/**
+ * Wrap database operation with error handling
+ */ export async function wrapDatabaseOperation(operation, errorCode, errorMessage, context) {
+    try {
+        const data = await operation();
+        return createSuccessResult(data);
+    } catch (err) {
+        const error = createDatabaseError(errorCode, errorMessage, err instanceof Error ? err : new Error(String(err)), context);
+        return createFailedResult(error);
+    }
+}
+/**
+ * Check if error is a specific database error code
+ */ export function isDatabaseError(error, code) {
+    return error && typeof error === 'object' && error.code === code;
+}
+/**
+ * Map SQLite error to database error code
+ */ export function mapSQLiteError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes('unique constraint')) {
+        return "DB_DUPLICATE_KEY";
+    }
+    if (message.includes('foreign key constraint')) {
+        return "DB_CONSTRAINT_VIOLATION";
+    }
+    if (message.includes('not found')) {
+        return "DB_NOT_FOUND";
+    }
+    if (message.includes('timeout')) {
+        return "DB_TIMEOUT";
+    }
+    return "DB_QUERY_FAILED";
+}
+/**
+ * Map PostgreSQL error to database error code
+ */ export function mapPostgresError(error) {
+    const code = error.code;
+    // PostgreSQL error codes
+    if (code === '23505') {
+        return "DB_DUPLICATE_KEY";
+    }
+    if (code === '23503') {
+        return "DB_CONSTRAINT_VIOLATION";
+    }
+    if (code === '42P01') {
+        return "DB_NOT_FOUND";
+    }
+    if (code === '57014') {
+        return "DB_TIMEOUT";
+    }
+    if (code?.startsWith('08')) {
+        return "DB_CONNECTION_FAILED";
+    }
+    return "DB_QUERY_FAILED";
+}
+/**
+ * Map Redis error to database error code
+ */ export function mapRedisError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes('connection')) {
+        return "DB_CONNECTION_FAILED";
+    }
+    if (message.includes('timeout')) {
+        return "DB_TIMEOUT";
+    }
+    if (message.includes('not found') || message.includes('nil')) {
+        return "DB_NOT_FOUND";
+    }
+    return "DB_QUERY_FAILED";
+}
+
+//# sourceMappingURL=errors.js.map

package/dist/lib/database-service/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/database-service/errors.ts"],"sourcesContent":["/**\r\n * Database Error Handling Utilities\r\n *\r\n * Provides standardized error handling for database operations.\r\n * Part of Task 0.4: Database Query Abstraction Layer (MVP)\r\n */\r\n\r\nimport { DatabaseError, OperationResult } from './types.js';\r\n\r\n/**\r\n * Database error codes\r\n */\r\nexport enum DatabaseErrorCode {\r\n  CONNECTION_FAILED = 'DB_CONNECTION_FAILED',\r\n  QUERY_FAILED = 'DB_QUERY_FAILED',\r\n  TRANSACTION_FAILED = 'DB_TRANSACTION_FAILED',\r\n  VALIDATION_FAILED = 'DB_VALIDATION_FAILED',\r\n  NOT_FOUND = 'DB_NOT_FOUND',\r\n  DUPLICATE_KEY = 'DB_DUPLICATE_KEY',\r\n  TIMEOUT = 'DB_TIMEOUT',\r\n  CONSTRAINT_VIOLATION = 'DB_CONSTRAINT_VIOLATION',\r\n  UNKNOWN_ERROR = 'DB_UNKNOWN_ERROR',\r\n}\r\n\r\n/**\r\n * Create standardized database error\r\n */\r\nexport function createDatabaseError(\r\n  code: DatabaseErrorCode,\r\n  message: string,\r\n  originalError?: Error,\r\n  context?: Record<string, any>\r\n): DatabaseError {\r\n  return {\r\n    code,\r\n    message,\r\n    originalError,\r\n    context,\r\n  };\r\n}\r\n\r\n/**\r\n * Create failed operation result\r\n */\r\nexport function createFailedResult<T = any>(error: DatabaseError): OperationResult<T> {\r\n  return {\r\n    success: false,\r\n    error,\r\n  };\r\n}\r\n\r\n/**\r\n * Create successful operation result\r\n */\r\nexport function createSuccessResult<T = any>(\r\n  data?: T,\r\n  rowsAffected?: number,\r\n  insertId?: string | number\r\n): OperationResult<T> {\r\n  return {\r\n    success: true,\r\n    data,\r\n    rowsAffected,\r\n    insertId,\r\n  };\r\n}\r\n\r\n/**\r\n * Wrap database operation with error handling\r\n */\r\nexport async function wrapDatabaseOperation<T>(\r\n  operation: () => Promise<T>,\r\n  errorCode: DatabaseErrorCode,\r\n  errorMessage: string,\r\n  context?: Record<string, any>\r\n): Promise<OperationResult<T>> {\r\n  try {\r\n    const data = await operation();\r\n    return createSuccessResult(data);\r\n  } catch (err) {\r\n    const error = createDatabaseError(\r\n      errorCode,\r\n      errorMessage,\r\n      err instanceof Error ? err : new Error(String(err)),\r\n      context\r\n    );\r\n    return createFailedResult(error);\r\n  }\r\n}\r\n\r\n/**\r\n * Check if error is a specific database error code\r\n */\r\nexport function isDatabaseError(error: any, code: DatabaseErrorCode): boolean {\r\n  return error && typeof error === 'object' && error.code === code;\r\n}\r\n\r\n/**\r\n * Map SQLite error to database error code\r\n */\r\nexport function mapSQLiteError(error: Error): DatabaseErrorCode {\r\n  const message = error.message.toLowerCase();\r\n\r\n  if (message.includes('unique constraint')) {\r\n    return DatabaseErrorCode.DUPLICATE_KEY;\r\n  }\r\n  if (message.includes('foreign key constraint')) {\r\n    return DatabaseErrorCode.CONSTRAINT_VIOLATION;\r\n  }\r\n  if (message.includes('not found')) {\r\n    return DatabaseErrorCode.NOT_FOUND;\r\n  }\r\n  if (message.includes('timeout')) {\r\n    return DatabaseErrorCode.TIMEOUT;\r\n  }\r\n\r\n  return DatabaseErrorCode.QUERY_FAILED;\r\n}\r\n\r\n/**\r\n * Map PostgreSQL error to database error code\r\n */\r\nexport function mapPostgresError(error: any): DatabaseErrorCode {\r\n  const code = error.code;\r\n\r\n  // PostgreSQL error codes\r\n  if (code === '23505') {\r\n    return DatabaseErrorCode.DUPLICATE_KEY;\r\n  }\r\n  if (code === '23503') {\r\n    return DatabaseErrorCode.CONSTRAINT_VIOLATION;\r\n  }\r\n  if (code === '42P01') {\r\n    return DatabaseErrorCode.NOT_FOUND;\r\n  }\r\n  if (code === '57014') {\r\n    return DatabaseErrorCode.TIMEOUT;\r\n  }\r\n  if (code?.startsWith('08')) {\r\n    return DatabaseErrorCode.CONNECTION_FAILED;\r\n  }\r\n\r\n  return DatabaseErrorCode.QUERY_FAILED;\r\n}\r\n\r\n/**\r\n * Map Redis error to database error code\r\n */\r\nexport function mapRedisError(error: Error): DatabaseErrorCode {\r\n  const message = error.message.toLowerCase();\r\n\r\n  if (message.includes('connection')) {\r\n    return DatabaseErrorCode.CONNECTION_FAILED;\r\n  }\r\n  if (message.includes('timeout')) {\r\n    return DatabaseErrorCode.TIMEOUT;\r\n  }\r\n  if (message.includes('not found') || message.includes('nil')) {\r\n    return DatabaseErrorCode.NOT_FOUND;\r\n  }\r\n\r\n  return DatabaseErrorCode.QUERY_FAILED;\r\n}\r\n"],"names":["DatabaseErrorCode","createDatabaseError","code","message","originalError","context","createFailedResult","error","success","createSuccessResult","data","rowsAffected","insertId","wrapDatabaseOperation","operation","errorCode","errorMessage","err","Error","String","isDatabaseError","mapSQLiteError","toLowerCase","includes","mapPostgresError","startsWith","mapRedisError"],"mappings":"AAAA;;;;;CAKC,GAID;;CAEC,GACD,OAAO,IAAA,AAAKA,2CAAAA;;;;;;;;;;WAAAA;MAUX;AAED;;CAEC,GACD,OAAO,SAASC,oBACdC,IAAuB,EACvBC,OAAe,EACfC,aAAqB,EACrBC,OAA6B;IAE7B,OAAO;QACLH;QACAC;QACAC;QACAC;IACF;AACF;AAEA;;CAEC,GACD,OAAO,SAASC,mBAA4BC,KAAoB;IAC9D,OAAO;QACLC,SAAS;QACTD;IACF;AACF;AAEA;;CAEC,GACD,OAAO,SAASE,oBACdC,IAAQ,EACRC,YAAqB,EACrBC,QAA0B;IAE1B,OAAO;QACLJ,SAAS;QACTE;QACAC;QACAC;IACF;AACF;AAEA;;CAEC,GACD,OAAO,eAAeC,sBACpBC,SAA2B,EAC3BC,SAA4B,EAC5BC,YAAoB,EACpBX,OAA6B;IAE7B,IAAI;QACF,MAAMK,OAAO,MAAMI;QACnB,OAAOL,oBAAoBC;IAC7B,EAAE,OAAOO,KAAK;QACZ,MAAMV,QAAQN,oBACZc,WACAC,cACAC,eAAeC,QAAQD,MAAM,IAAIC,MAAMC,OAAOF,OAC9CZ;QAEF,OAAOC,mBAAmBC;IAC5B;AACF;AAEA;;CAEC,GACD,OAAO,SAASa,gBAAgBb,KAAU,EAAEL,IAAuB;IACjE,OAAOK,SAAS,OAAOA,UAAU,YAAYA,MAAML,IAAI,KAAKA;AAC9D;AAEA;;CAEC,GACD,OAAO,SAASmB,eAAed,KAAY;IACzC,MAAMJ,UAAUI,MAAMJ,OAAO,CAACmB,WAAW;IAEzC,IAAInB,QAAQoB,QAAQ,CAAC,sBAAsB;QACzC;IACF;IACA,IAAIpB,QAAQoB,QAAQ,CAAC,2BAA2B;QAC9C;IACF;IACA,IAAIpB,QAAQoB,QAAQ,CAAC,cAAc;QACjC;IACF;IACA,IAAIpB,QAAQoB,QAAQ,CAAC,YAAY;QAC/B;IACF;IAEA;AACF;AAEA;;CAEC,GACD,OAAO,SAASC,iBAAiBjB,KAAU;IACzC,MAAML,OAAOK,MAAML,IAAI;IAEvB,yBAAyB;IACzB,IAAIA,SAAS,SAAS;QACpB;IACF;IACA,IAAIA,SAAS,SAAS;QACpB;IACF;IACA,IAAIA,SAAS,SAAS;QACpB;IACF;IACA,IAAIA,SAAS,SAAS;QACpB;IACF;IACA,IAAIA,MAAMuB,WAAW,OAAO;QAC1B;IACF;IAEA;AACF;AAEA;;CAEC,GACD,OAAO,SAASC,cAAcnB,KAAY;IACxC,MAAMJ,UAAUI,MAAMJ,OAAO,CAACmB,WAAW;IAEzC,IAAInB,QAAQoB,QAAQ,CAAC,eAAe;QAClC;IACF;IACA,IAAIpB,QAAQoB,QAAQ,CAAC,YAAY;QAC/B;IACF;IACA,IAAIpB,QAAQoB,QAAQ,CAAC,gBAAgBpB,QAAQoB,QAAQ,CAAC,QAAQ;QAC5D;IACF;IAEA;AACF"}

package/dist/lib/database-service/index.js

@@ -0,0 +1,168 @@
+/**
+ * Database Service - Main Entry Point
+ *
+ * Unified database abstraction layer for Redis, SQLite, and PostgreSQL.
+ * Part of Task 0.4: Database Query Abstraction Layer (MVP)
+ *
+ * @example
+ * ```typescript
+ * const dbService = new DatabaseService({
+ *   redis: { type: 'redis', host: 'localhost', port: 6379 },
+ *   sqlite: { type: 'sqlite', database: './data.db' },
+ *   postgres: { type: 'postgres', connectionString: 'postgresql://...' }
+ * });
+ *
+ * await dbService.connect();
+ *
+ * // Get data by correlation key across all databases
+ * const data = await dbService.getByCorrelationKey({
+ *   type: 'task',
+ *   id: 'abc123',
+ *   entity: 'agent'
+ * });
+ * ```
+ */ import { RedisAdapter } from './redis-adapter.js';
+import { SQLiteAdapter } from './sqlite-adapter.js';
+import { PostgresAdapter } from './postgres-adapter.js';
+import { TransactionManager } from './transaction-manager.js';
+import { buildCorrelationKey, parseCorrelationKey, buildTaskKey, buildAgentKey, buildSkillKey, buildExecutionKey } from './correlation.js';
+import { DatabaseErrorCode, createDatabaseError } from './errors.js';
+export class DatabaseService {
+    adapters = new Map();
+    transactionManager;
+    config;
+    constructor(config){
+        this.config = config;
+        this.transactionManager = new TransactionManager();
+        // Initialize adapters
+        if (config.redis) {
+            this.adapters.set('redis', new RedisAdapter(config.redis));
+        }
+        if (config.sqlite) {
+            this.adapters.set('sqlite', new SQLiteAdapter(config.sqlite));
+        }
+        if (config.postgres) {
+            this.adapters.set('postgres', new PostgresAdapter(config.postgres));
+        }
+    }
+    /**
+   * Connect to all configured databases
+   */ async connect() {
+        const promises = Array.from(this.adapters.values()).map((adapter)=>adapter.connect());
+        await Promise.all(promises);
+    }
+    /**
+   * Disconnect from all databases
+   */ async disconnect() {
+        const promises = Array.from(this.adapters.values()).map((adapter)=>adapter.disconnect());
+        await Promise.all(promises);
+    }
+    /**
+   * Get adapter for specific database
+   */ getAdapter(type) {
+        const adapter = this.adapters.get(type);
+        if (!adapter) {
+            throw createDatabaseError(DatabaseErrorCode.CONNECTION_FAILED, `Database adapter not configured: ${type}`, undefined, {
+                type
+            });
+        }
+        return adapter;
+    }
+    /**
+   * Get record by correlation key across all databases
+   */ async getByCorrelationKey(key) {
+        const correlationKeyString = buildCorrelationKey(key);
+        const result = {
+            correlationKey: correlationKeyString,
+            timestamp: new Date()
+        };
+        // Query each database in parallel
+        const promises = [];
+        if (this.adapters.has('redis')) {
+            promises.push(this.adapters.get('redis').get(correlationKeyString).then((data)=>{
+                if (data !== null && data !== undefined) result.redis = data;
+            }).catch((err)=>console.warn('Redis lookup failed:', err)));
+        }
+        if (this.adapters.has('sqlite')) {
+            promises.push(this.adapters.get('sqlite').get(correlationKeyString).then((data)=>{
+                if (data !== null && data !== undefined) result.sqlite = data;
+            }).catch((err)=>console.warn('SQLite lookup failed:', err)));
+        }
+        if (this.adapters.has('postgres')) {
+            promises.push(this.adapters.get('postgres').get(correlationKeyString).then((data)=>{
+                if (data !== null && data !== undefined) result.postgres = data;
+            }).catch((err)=>console.warn('PostgreSQL lookup failed:', err)));
+        }
+        await Promise.all(promises);
+        return result;
+    }
+    /**
+   * Execute cross-database transaction
+   */ async executeTransaction(operations) {
+        const adapters = operations.map((op)=>this.getAdapter(op.database));
+        const ops = operations.map((op)=>op.operation);
+        return this.transactionManager.executeTransaction(adapters, ops);
+    }
+    /**
+   * Build correlation key
+   */ buildCorrelationKey(key) {
+        return buildCorrelationKey(key);
+    }
+    /**
+   * Parse correlation key
+   */ parseCorrelationKey(key) {
+        return parseCorrelationKey(key);
+    }
+    /**
+   * Get transaction manager
+   */ getTransactionManager() {
+        return this.transactionManager;
+    }
+    /**
+   * Check if all configured databases are connected
+   */ isConnected() {
+        return Array.from(this.adapters.values()).every((adapter)=>adapter.isConnected());
+    }
+    /**
+   * Get database statistics including connection pool metrics
+   */ getStats() {
+        const poolStats = {};
+        // Get pool stats from each adapter
+        if (this.adapters.has('redis')) {
+            const adapter = this.adapters.get('redis');
+            poolStats.redis = adapter.getPoolStats?.();
+        }
+        if (this.adapters.has('sqlite')) {
+            const adapter = this.adapters.get('sqlite');
+            poolStats.sqlite = adapter.getPoolStats?.();
+        }
+        if (this.adapters.has('postgres')) {
+            const adapter = this.adapters.get('postgres');
+            poolStats.postgres = adapter.getPoolStats?.();
+        }
+        return {
+            adapters: {
+                redis: this.adapters.has('redis') && this.adapters.get('redis').isConnected(),
+                sqlite: this.adapters.has('sqlite') && this.adapters.get('sqlite').isConnected(),
+                postgres: this.adapters.has('postgres') && this.adapters.get('postgres').isConnected()
+            },
+            transactions: {
+                active: this.transactionManager.getActiveCount()
+            },
+            connectionPools: poolStats
+        };
+    }
+}
+// Re-export types and utilities
+export * from './types.js';
+export * from './errors.js';
+export * from './correlation.js';
+export { RedisAdapter } from './redis-adapter.js';
+export { SQLiteAdapter } from './sqlite-adapter.js';
+export { PostgresAdapter } from './postgres-adapter.js';
+export { TransactionManager } from './transaction-manager.js';
+export { ConnectionPoolManager } from './connection-pool-manager.js';
+// Re-export correlation utilities
+export { buildTaskKey, buildAgentKey, buildSkillKey, buildExecutionKey };
+
+//# sourceMappingURL=index.js.map