memory-journal-mcp 8.0.1 → 9.1.0

package/dist/chunk-E6IQP6PE.js

@@ -0,0 +1,252 @@
+// src/utils/errors/suggestions.ts
+var GENERIC_CODES = /* @__PURE__ */ new Set(["QUERY_FAILED", "INTERNAL_ERROR", "UNKNOWN_ERROR"]);
+var ERROR_SUGGESTIONS = [
+  // Resource not found patterns
+  {
+    pattern: /not found/i,
+    suggestion: "Verify the resource identifier and try again",
+    code: "RESOURCE_NOT_FOUND"
+  },
+  {
+    pattern: /no such table/i,
+    suggestion: "The database table does not exist. Run database initialization.",
+    code: "TABLE_NOT_FOUND"
+  },
+  // Permission / access patterns
+  {
+    pattern: /permission denied|SQLITE_READONLY/i,
+    suggestion: "Check file permissions and database access rights",
+    code: "PERMISSION_DENIED"
+  },
+  // Connection / lock patterns
+  {
+    pattern: /database is locked/i,
+    suggestion: "The database is locked by another process. Retry after a short delay.",
+    code: "CONNECTION_FAILED"
+  },
+  // Constraint patterns
+  {
+    pattern: /SQLITE_CONSTRAINT|unique constraint/i,
+    suggestion: "A uniqueness or integrity constraint was violated. Check input values.",
+    code: "VALIDATION_ERROR"
+  },
+  // Disk / space patterns
+  {
+    pattern: /disk I\/O|SQLITE_FULL/i,
+    suggestion: "The disk may be full or the filesystem is read-only."
+  },
+  // Malformed input patterns
+  {
+    pattern: /malformed|invalid json|unexpected token/i,
+    suggestion: "The input appears malformed. Check the format and try again.",
+    code: "VALIDATION_ERROR"
+  },
+  // Schema / types patterns
+  {
+    pattern: /invalid input syntax for type|requires a.*column/i,
+    suggestion: "The provided value is not valid for the assigned type.",
+    code: "VALIDATION_ERROR"
+  },
+  {
+    pattern: /^Missing required parameters:/i,
+    suggestion: "Provide all required parameters in your request.",
+    code: "VALIDATION_ERROR"
+  },
+  // Codemode / Sandbox patterns
+  {
+    pattern: /execution timed out/i,
+    suggestion: "Reduce code complexity or increase timeout (max 30s). Break into smaller operations.",
+    code: "QUERY_FAILED"
+  },
+  {
+    pattern: /code validation failed/i,
+    suggestion: "Check for blocked patterns. Use mj.* API instead.",
+    code: "VALIDATION_ERROR"
+  },
+  {
+    pattern: /sandbox.*not initialized/i,
+    suggestion: "Internal sandbox error. Retry the operation.",
+    code: "INTERNAL_ERROR"
+  },
+  {
+    pattern: /(?:memory|mcp|core|journal|api) is not defined/i,
+    suggestion: 'In Code Mode (mj_execute_code), top-level objects like "mj" or "core" provide API access (e.g. mj.core.createEntry, core.getRecentEntries, or mj.analytics.getStatistics). Verify object variable references.',
+    code: "VALIDATION_ERROR"
+  },
+  {
+    pattern: /egress policy|egress limit|output limit exceeded/i,
+    suggestion: "Result payload exceeds egress size boundary. Extract specific fields or reduce search limit (e.g. limit: 10) instead of returning full objects.",
+    code: "VALIDATION_ERROR"
+  },
+  {
+    pattern: /import statement|dynamic import|require.*not allowed/i,
+    suggestion: 'Dynamic import() and require() statements are not permitted in Code Mode sandbox scripts. All API methods are available pre-loaded under the top-level "mj" global object.',
+    code: "VALIDATION_ERROR"
+  },
+  // Zod enum validation patterns — return valid values for self-correction
+  {
+    pattern: /invalid enum value.*significance/i,
+    suggestion: "Valid significance_type values: milestone, breakthrough, decision, architecture, lesson_learned, blocker_resolved, release, security",
+    code: "VALIDATION_ERROR"
+  },
+  {
+    pattern: /invalid enum value.*entry.?type/i,
+    suggestion: "Valid entry_type values: retrospective, bug_fix, project_decision, feature_implementation, technical_note, code_review, planning, research, enhancement, milestone, adversarial_review, development_note, learning, standup, meeting_notes, technical_achievement, plan_draft, plan_refinement, plan_finalized, copilot_validation, other, personal_reflection",
+    code: "VALIDATION_ERROR"
+  }
+];
+function matchSuggestion(message) {
+  for (const entry of ERROR_SUGGESTIONS) {
+    if (entry.pattern.test(message)) {
+      return { suggestion: entry.suggestion, code: entry.code };
+    }
+  }
+  return void 0;
+}
+
+// src/types/errors.ts
+var MemoryJournalMcpError = class extends Error {
+  /** Module-prefixed error code */
+  code;
+  /** Error category for programmatic handling */
+  category;
+  /** Actionable suggestion for resolving the error */
+  suggestion;
+  /** Whether the operation can be retried */
+  recoverable;
+  /** Additional structured context */
+  details;
+  constructor(message, code, category, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "MemoryJournalMcpError";
+    this.category = category;
+    this.recoverable = options?.recoverable ?? false;
+    this.details = options?.details;
+    const matched = matchSuggestion(message);
+    if (GENERIC_CODES.has(code) && matched?.code) {
+      this.code = matched.code;
+    } else {
+      this.code = code;
+    }
+    this.suggestion = options?.suggestion ?? matched?.suggestion;
+  }
+  /**
+   * Convert to a structured ErrorResponse for tool responses.
+   */
+  toResponse() {
+    return {
+      success: false,
+      error: this.message,
+      code: this.code,
+      category: this.category,
+      suggestion: this.suggestion,
+      recoverable: this.recoverable,
+      ...this.details ? { details: this.details } : {}
+    };
+  }
+};
+var ConnectionError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "CONNECTION_FAILED", "connection", {
+      suggestion: "Check database path and file permissions",
+      recoverable: true,
+      details
+    });
+    this.name = "ConnectionError";
+  }
+};
+var QueryError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "QUERY_FAILED", "query", {
+      suggestion: "Check query parameters and database state",
+      recoverable: false,
+      details
+    });
+    this.name = "QueryError";
+  }
+};
+var ValidationError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "VALIDATION_ERROR", "validation", {
+      suggestion: "Check input parameters against the tool schema",
+      recoverable: false,
+      details
+    });
+    this.name = "ValidationError";
+  }
+};
+var ConflictError = class extends MemoryJournalMcpError {
+  currentState;
+  constructor(message, currentState) {
+    super(message, "VERSION_CONFLICT", "conflict", {
+      suggestion: "Re-read the entry to get the current version, then retry your update with the new expected_version",
+      recoverable: true,
+      details: currentState
+    });
+    this.name = "ConflictError";
+    this.currentState = currentState;
+  }
+};
+var ResourceNotFoundError = class extends MemoryJournalMcpError {
+  constructor(resourceType, identifier) {
+    super(
+      `${resourceType} not found: ${identifier}`,
+      "RESOURCE_NOT_FOUND",
+      "resource",
+      {
+        suggestion: `Verify the ${resourceType.toLowerCase()} identifier and try again`,
+        recoverable: false,
+        details: { resourceType, identifier }
+      }
+    );
+    this.name = "ResourceNotFoundError";
+  }
+};
+var ConfigurationError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "CONFIGURATION_ERROR", "configuration", {
+      suggestion: "Check server configuration and environment variables",
+      recoverable: false,
+      details
+    });
+    this.name = "ConfigurationError";
+  }
+};
+var PermissionError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "PERMISSION_DENIED", "permission", {
+      suggestion: "Check file permissions and database access rights",
+      recoverable: false,
+      details
+    });
+    this.name = "PermissionError";
+  }
+};
+var AuthorizationError = class extends MemoryJournalMcpError {
+  constructor(message, details) {
+    super(message, "AUTHORIZATION_FAILED", "authorization", {
+      suggestion: "Check your team role and permissions",
+      recoverable: false,
+      details
+    });
+    this.name = "AuthorizationError";
+  }
+};
+var AggregateMcpError = class extends MemoryJournalMcpError {
+  errors;
+  constructor(message, errors, details) {
+    super(message, "AGGREGATE_ERROR", "internal", {
+      recoverable: false,
+      details
+    });
+    this.name = "AggregateMcpError";
+    this.errors = errors;
+  }
+  toResponse() {
+    const response = super.toResponse();
+    response.aggregated_errors = this.errors;
+    return response;
+  }
+};
+
+export { AggregateMcpError, AuthorizationError, ConfigurationError, ConflictError, ConnectionError, MemoryJournalMcpError, PermissionError, QueryError, ResourceNotFoundError, ValidationError, matchSuggestion };